Diff for /qemu/console.c between versions 1.1.1.5 and 1.1.1.6

version 1.1.1.5, 2018/04/24 16:47:16 version 1.1.1.6, 2018/04/24 16:50:31
Line 28 Line 28
 //#define DEBUG_CONSOLE  //#define DEBUG_CONSOLE
 #define DEFAULT_BACKSCROLL 512  #define DEFAULT_BACKSCROLL 512
 #define MAX_CONSOLES 12  #define MAX_CONSOLES 12
   #define DEFAULT_MONITOR_SIZE "800x600"
   
 #define QEMU_RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))  #define QEMU_RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
 #define QEMU_RGB(r, g, b) QEMU_RGBA(r, g, b, 0xff)  #define QEMU_RGB(r, g, b) QEMU_RGBA(r, g, b, 0xff)
Line 121  struct TextConsole { Line 122  struct TextConsole {
     vga_hw_update_ptr hw_update;      vga_hw_update_ptr hw_update;
     vga_hw_invalidate_ptr hw_invalidate;      vga_hw_invalidate_ptr hw_invalidate;
     vga_hw_screen_dump_ptr hw_screen_dump;      vga_hw_screen_dump_ptr hw_screen_dump;
       vga_hw_text_update_ptr hw_text_update;
     void *hw;      void *hw;
   
     int g_width, g_height;      int g_width, g_height;
Line 135  struct TextConsole { Line 137  struct TextConsole {
     TextAttributes t_attrib_default; /* default text attributes */      TextAttributes t_attrib_default; /* default text attributes */
     TextAttributes t_attrib; /* currently active text attributes */      TextAttributes t_attrib; /* currently active text attributes */
     TextCell *cells;      TextCell *cells;
       int text_x[2], text_y[2], cursor_invalidate;
   
       int update_x0;
       int update_y0;
       int update_x1;
       int update_y1;
   
     enum TTYState state;      enum TTYState state;
     int esc_params[MAX_ESC_PARAMS];      int esc_params[MAX_ESC_PARAMS];
Line 165  void vga_hw_invalidate(void) Line 173  void vga_hw_invalidate(void)
   
 void vga_hw_screen_dump(const char *filename)  void vga_hw_screen_dump(const char *filename)
 {  {
     /* There is currently no was of specifying which screen we want to dump,      TextConsole *previous_active_console;
        so always dump the dirst one.  */  
       previous_active_console = active_console;
       active_console = consoles[0];
       /* There is currently no way of specifying which screen we want to dump,
          so always dump the first one.  */
     if (consoles[0]->hw_screen_dump)      if (consoles[0]->hw_screen_dump)
         consoles[0]->hw_screen_dump(consoles[0]->hw, filename);          consoles[0]->hw_screen_dump(consoles[0]->hw, filename);
       active_console = previous_active_console;
   }
   
   void vga_hw_text_update(console_ch_t *chardata)
   {
       if (active_console && active_console->hw_text_update)
           active_console->hw_text_update(active_console->hw, chardata);
 }  }
   
 /* convert a RGBA color to a color index usable in graphic primitives */  /* convert a RGBA color to a color index usable in graphic primitives */
Line 176  static unsigned int vga_get_color(Displa Line 195  static unsigned int vga_get_color(Displa
 {  {
     unsigned int r, g, b, color;      unsigned int r, g, b, color;
   
     switch(ds->depth) {      switch(ds_get_bits_per_pixel(ds)) {
 #if 0  #if 0
     case 8:      case 8:
         r = (rgba >> 16) & 0xff;          r = (rgba >> 16) & 0xff;
Line 213  static void vga_fill_rect (DisplayState  Line 232  static void vga_fill_rect (DisplayState 
     uint8_t *d, *d1;      uint8_t *d, *d1;
     int x, y, bpp;      int x, y, bpp;
   
     bpp = (ds->depth + 7) >> 3;      bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
     d1 = ds->data +      d1 = ds_get_data(ds) +
         ds->linesize * posy + bpp * posx;          ds_get_linesize(ds) * posy + bpp * posx;
     for (y = 0; y < height; y++) {      for (y = 0; y < height; y++) {
         d = d1;          d = d1;
         switch(bpp) {          switch(bpp) {
Line 238  static void vga_fill_rect (DisplayState  Line 257  static void vga_fill_rect (DisplayState 
             }              }
             break;              break;
         }          }
         d1 += ds->linesize;          d1 += ds_get_linesize(ds);
     }      }
 }  }
   
Line 249  static void vga_bitblt(DisplayState *ds, Line 268  static void vga_bitblt(DisplayState *ds,
     uint8_t *d;      uint8_t *d;
     int wb, y, bpp;      int wb, y, bpp;
   
     bpp = (ds->depth + 7) >> 3;      bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
     wb = w * bpp;      wb = w * bpp;
     if (yd <= ys) {      if (yd <= ys) {
         s = ds->data +          s = ds_get_data(ds) +
             ds->linesize * ys + bpp * xs;              ds_get_linesize(ds) * ys + bpp * xs;
         d = ds->data +          d = ds_get_data(ds) +
             ds->linesize * yd + bpp * xd;              ds_get_linesize(ds) * yd + bpp * xd;
         for (y = 0; y < h; y++) {          for (y = 0; y < h; y++) {
             memmove(d, s, wb);              memmove(d, s, wb);
             d += ds->linesize;              d += ds_get_linesize(ds);
             s += ds->linesize;              s += ds_get_linesize(ds);
         }          }
     } else {      } else {
         s = ds->data +          s = ds_get_data(ds) +
             ds->linesize * (ys + h - 1) + bpp * xs;              ds_get_linesize(ds) * (ys + h - 1) + bpp * xs;
         d = ds->data +          d = ds_get_data(ds) +
             ds->linesize * (yd + h - 1) + bpp * xd;              ds_get_linesize(ds) * (yd + h - 1) + bpp * xd;
        for (y = 0; y < h; y++) {         for (y = 0; y < h; y++) {
             memmove(d, s, wb);              memmove(d, s, wb);
             d -= ds->linesize;              d -= ds_get_linesize(ds);
             s -= ds->linesize;              s -= ds_get_linesize(ds);
         }          }
     }      }
 }  }
Line 359  static const uint32_t color_table_rgb[2] Line 378  static const uint32_t color_table_rgb[2]
   
 static inline unsigned int col_expand(DisplayState *ds, unsigned int col)  static inline unsigned int col_expand(DisplayState *ds, unsigned int col)
 {  {
     switch(ds->depth) {      switch(ds_get_bits_per_pixel(ds)) {
     case 8:      case 8:
         col |= col << 8;          col |= col << 8;
         col |= col << 16;          col |= col << 16;
Line 429  static void vga_putcharxy(DisplayState * Line 448  static void vga_putcharxy(DisplayState *
         bgcol = color_table[t_attrib->bold][t_attrib->bgcol];          bgcol = color_table[t_attrib->bold][t_attrib->bgcol];
     }      }
   
     bpp = (ds->depth + 7) >> 3;      bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
     d = ds->data +      d = ds_get_data(ds) +
         ds->linesize * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;          ds_get_linesize(ds) * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;
     linesize = ds->linesize;      linesize = ds_get_linesize(ds);
     font_ptr = vgafont16 + FONT_HEIGHT * ch;      font_ptr = vgafont16 + FONT_HEIGHT * ch;
     xorcol = bgcol ^ fgcol;      xorcol = bgcol ^ fgcol;
     switch(ds->depth) {      switch(ds_get_bits_per_pixel(ds)) {
     case 8:      case 8:
         for(i = 0; i < FONT_HEIGHT; i++) {          for(i = 0; i < FONT_HEIGHT; i++) {
             font_data = *font_ptr++;              font_data = *font_ptr++;
Line 515  static void text_console_resize(TextCons Line 534  static void text_console_resize(TextCons
     s->cells = cells;      s->cells = cells;
 }  }
   
   static inline void text_update_xy(TextConsole *s, int x, int y)
   {
       s->text_x[0] = MIN(s->text_x[0], x);
       s->text_x[1] = MAX(s->text_x[1], x);
       s->text_y[0] = MIN(s->text_y[0], y);
       s->text_y[1] = MAX(s->text_y[1], y);
   }
   
   static void invalidate_xy(TextConsole *s, int x, int y)
   {
       if (s->update_x0 > x * FONT_WIDTH)
           s->update_x0 = x * FONT_WIDTH;
       if (s->update_y0 > y * FONT_HEIGHT)
           s->update_y0 = y * FONT_HEIGHT;
       if (s->update_x1 < (x + 1) * FONT_WIDTH)
           s->update_x1 = (x + 1) * FONT_WIDTH;
       if (s->update_y1 < (y + 1) * FONT_HEIGHT)
           s->update_y1 = (y + 1) * FONT_HEIGHT;
   }
   
 static void update_xy(TextConsole *s, int x, int y)  static void update_xy(TextConsole *s, int x, int y)
 {  {
     TextCell *c;      TextCell *c;
     int y1, y2;      int y1, y2;
   
     if (s == active_console) {      if (s == active_console) {
           if (!ds_get_bits_per_pixel(s->ds)) {
               text_update_xy(s, x, y);
               return;
           }
   
         y1 = (s->y_base + y) % s->total_height;          y1 = (s->y_base + y) % s->total_height;
         y2 = y1 - s->y_displayed;          y2 = y1 - s->y_displayed;
         if (y2 < 0)          if (y2 < 0)
Line 529  static void update_xy(TextConsole *s, in Line 573  static void update_xy(TextConsole *s, in
             c = &s->cells[y1 * s->width + x];              c = &s->cells[y1 * s->width + x];
             vga_putcharxy(s->ds, x, y2, c->ch,              vga_putcharxy(s->ds, x, y2, c->ch,
                           &(c->t_attrib));                            &(c->t_attrib));
             dpy_update(s->ds, x * FONT_WIDTH, y2 * FONT_HEIGHT,              invalidate_xy(s, x, y2);
                        FONT_WIDTH, FONT_HEIGHT);  
         }          }
     }      }
 }  }
Line 542  static void console_show_cursor(TextCons Line 585  static void console_show_cursor(TextCons
   
     if (s == active_console) {      if (s == active_console) {
         int x = s->x;          int x = s->x;
   
           if (!ds_get_bits_per_pixel(s->ds)) {
               s->cursor_invalidate = 1;
               return;
           }
   
         if (x >= s->width) {          if (x >= s->width) {
             x = s->width - 1;              x = s->width - 1;
         }          }
Line 558  static void console_show_cursor(TextCons Line 607  static void console_show_cursor(TextCons
             } else {              } else {
                 vga_putcharxy(s->ds, x, y, c->ch, &(c->t_attrib));                  vga_putcharxy(s->ds, x, y, c->ch, &(c->t_attrib));
             }              }
             dpy_update(s->ds, x * FONT_WIDTH, y * FONT_HEIGHT,              invalidate_xy(s, x, y);
                        FONT_WIDTH, FONT_HEIGHT);  
         }          }
     }      }
 }  }
Line 571  static void console_refresh(TextConsole  Line 619  static void console_refresh(TextConsole 
   
     if (s != active_console)      if (s != active_console)
         return;          return;
       if (!ds_get_bits_per_pixel(s->ds)) {
           s->text_x[0] = 0;
           s->text_y[0] = 0;
           s->text_x[1] = s->width - 1;
           s->text_y[1] = s->height - 1;
           s->cursor_invalidate = 1;
           return;
       }
   
     vga_fill_rect(s->ds, 0, 0, s->ds->width, s->ds->height,      vga_fill_rect(s->ds, 0, 0, ds_get_width(s->ds), ds_get_height(s->ds),
                   color_table[0][COLOR_BLACK]);                    color_table[0][COLOR_BLACK]);
     y1 = s->y_displayed;      y1 = s->y_displayed;
     for(y = 0; y < s->height; y++) {      for(y = 0; y < s->height; y++) {
Line 585  static void console_refresh(TextConsole  Line 641  static void console_refresh(TextConsole 
         if (++y1 == s->total_height)          if (++y1 == s->total_height)
             y1 = 0;              y1 = 0;
     }      }
     dpy_update(s->ds, 0, 0, s->ds->width, s->ds->height);  
     console_show_cursor(s, 1);      console_show_cursor(s, 1);
       dpy_update(s->ds, 0, 0, ds_get_width(s->ds), ds_get_height(s->ds));
 }  }
   
 static void console_scroll(int ydelta)  static void console_scroll(int ydelta)
Line 648  static void console_put_lf(TextConsole * Line 704  static void console_put_lf(TextConsole *
             c++;              c++;
         }          }
         if (s == active_console && s->y_displayed == s->y_base) {          if (s == active_console && s->y_displayed == s->y_base) {
               if (!ds_get_bits_per_pixel(s->ds)) {
                   s->text_x[0] = 0;
                   s->text_y[0] = 0;
                   s->text_x[1] = s->width - 1;
                   s->text_y[1] = s->height - 1;
                   return;
               }
   
             vga_bitblt(s->ds, 0, FONT_HEIGHT, 0, 0,              vga_bitblt(s->ds, 0, FONT_HEIGHT, 0, 0,
                        s->width * FONT_WIDTH,                         s->width * FONT_WIDTH,
                        (s->height - 1) * FONT_HEIGHT);                         (s->height - 1) * FONT_HEIGHT);
             vga_fill_rect(s->ds, 0, (s->height - 1) * FONT_HEIGHT,              vga_fill_rect(s->ds, 0, (s->height - 1) * FONT_HEIGHT,
                           s->width * FONT_WIDTH, FONT_HEIGHT,                            s->width * FONT_WIDTH, FONT_HEIGHT,
                           color_table[0][s->t_attrib_default.bgcol]);                            color_table[0][s->t_attrib_default.bgcol]);
             dpy_update(s->ds, 0, 0,              s->update_x0 = 0;
                        s->width * FONT_WIDTH, s->height * FONT_HEIGHT);              s->update_y0 = 0;
               s->update_x1 = s->width * FONT_WIDTH;
               s->update_y1 = s->height * FONT_HEIGHT;
         }          }
     }      }
 }  }
Line 995  void console_select(unsigned int index) Line 1061  void console_select(unsigned int index)
   
     if (index >= MAX_CONSOLES)      if (index >= MAX_CONSOLES)
         return;          return;
       active_console->g_width = ds_get_width(active_console->ds);
       active_console->g_height = ds_get_height(active_console->ds);
     s = consoles[index];      s = consoles[index];
     if (s) {      if (s) {
           DisplayState *ds = s->ds;
         active_console = s;          active_console = s;
         if (s->console_type != GRAPHIC_CONSOLE) {          if (ds_get_bits_per_pixel(s->ds)) {
             if (s->g_width != s->ds->width ||              ds->surface = qemu_resize_displaysurface(ds->surface, s->g_width,
                 s->g_height != s->ds->height) {                      s->g_height, 32, 4 * s->g_width);
                 if (s->console_type == TEXT_CONSOLE_FIXED_SIZE) {  
                     dpy_resize(s->ds, s->g_width, s->g_height);  
                 } else {  
                 s->g_width = s->ds->width;  
                 s->g_height = s->ds->height;  
                 text_console_resize(s);  
             }  
             }  
             console_refresh(s);  
         } else {          } else {
             vga_hw_invalidate();              s->ds->surface->width = s->width;
               s->ds->surface->height = s->height;
         }          }
           dpy_resize(s->ds);
           vga_hw_invalidate();
     }      }
 }  }
   
Line 1021  static int console_puts(CharDriverState  Line 1084  static int console_puts(CharDriverState 
     TextConsole *s = chr->opaque;      TextConsole *s = chr->opaque;
     int i;      int i;
   
       s->update_x0 = s->width * FONT_WIDTH;
       s->update_y0 = s->height * FONT_HEIGHT;
       s->update_x1 = 0;
       s->update_y1 = 0;
     console_show_cursor(s, 0);      console_show_cursor(s, 0);
     for(i = 0; i < len; i++) {      for(i = 0; i < len; i++) {
         console_putchar(s, buf[i]);          console_putchar(s, buf[i]);
     }      }
     console_show_cursor(s, 1);      console_show_cursor(s, 1);
       if (ds_get_bits_per_pixel(s->ds) && s->update_x0 < s->update_x1) {
           dpy_update(s->ds, s->update_x0, s->update_y0,
                      s->update_x1 - s->update_x0,
                      s->update_y1 - s->update_y0);
       }
     return len;      return len;
 }  }
   
Line 1116  void kbd_put_keysym(int keysym) Line 1188  void kbd_put_keysym(int keysym)
     }      }
 }  }
   
   static void text_console_invalidate(void *opaque)
   {
       TextConsole *s = (TextConsole *) opaque;
       if (!ds_get_bits_per_pixel(s->ds) && s->console_type == TEXT_CONSOLE) {
           s->g_width = ds_get_width(s->ds);
           s->g_height = ds_get_height(s->ds);
           text_console_resize(s);
       }
       console_refresh(s);
   }
   
   static void text_console_update(void *opaque, console_ch_t *chardata)
   {
       TextConsole *s = (TextConsole *) opaque;
       int i, j, src;
   
       if (s->text_x[0] <= s->text_x[1]) {
           src = (s->y_base + s->text_y[0]) * s->width;
           chardata += s->text_y[0] * s->width;
           for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
               for (j = 0; j < s->width; j ++, src ++)
                   console_write_ch(chardata ++, s->cells[src].ch |
                                   (s->cells[src].t_attrib.fgcol << 12) |
                                   (s->cells[src].t_attrib.bgcol << 8) |
                                   (s->cells[src].t_attrib.bold << 21));
           dpy_update(s->ds, s->text_x[0], s->text_y[0],
                      s->text_x[1] - s->text_x[0], i - s->text_y[0]);
           s->text_x[0] = s->width;
           s->text_y[0] = s->height;
           s->text_x[1] = 0;
           s->text_y[1] = 0;
       }
       if (s->cursor_invalidate) {
           dpy_cursor(s->ds, s->x, s->y);
           s->cursor_invalidate = 0;
       }
   }
   
   static TextConsole *get_graphic_console(DisplayState *ds)
   {
       int i;
       TextConsole *s;
       for (i = 0; i < nb_consoles; i++) {
           s = consoles[i];
           if (s->console_type == GRAPHIC_CONSOLE && s->ds == ds)
               return s;
       }
       return NULL;
   }
   
 static TextConsole *new_console(DisplayState *ds, console_type_t console_type)  static TextConsole *new_console(DisplayState *ds, console_type_t console_type)
 {  {
     TextConsole *s;      TextConsole *s;
Line 1124  static TextConsole *new_console(DisplayS Line 1246  static TextConsole *new_console(DisplayS
     if (nb_consoles >= MAX_CONSOLES)      if (nb_consoles >= MAX_CONSOLES)
         return NULL;          return NULL;
     s = qemu_mallocz(sizeof(TextConsole));      s = qemu_mallocz(sizeof(TextConsole));
     if (!s) {  
         return NULL;  
     }  
     if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&      if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
         (console_type == GRAPHIC_CONSOLE))) {          (console_type == GRAPHIC_CONSOLE))) {
         active_console = s;          active_console = s;
Line 1143  static TextConsole *new_console(DisplayS Line 1262  static TextConsole *new_console(DisplayS
             consoles[i] = consoles[i - 1];              consoles[i] = consoles[i - 1];
         }          }
         consoles[i] = s;          consoles[i] = s;
           nb_consoles++;
     }      }
     return s;      return s;
 }  }
   
 TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,  DisplayState *graphic_console_init(vga_hw_update_ptr update,
                                   vga_hw_invalidate_ptr invalidate,                                     vga_hw_invalidate_ptr invalidate,
                                   vga_hw_screen_dump_ptr screen_dump,                                     vga_hw_screen_dump_ptr screen_dump,
                                   void *opaque)                                     vga_hw_text_update_ptr text_update,
                                      void *opaque)
 {  {
     TextConsole *s;      TextConsole *s;
       DisplayState *ds;
   
       ds = (DisplayState *) qemu_mallocz(sizeof(DisplayState));
       ds->surface = qemu_create_displaysurface(640, 480, 32, 640 * 4);
   
     s = new_console(ds, GRAPHIC_CONSOLE);      s = new_console(ds, GRAPHIC_CONSOLE);
     if (!s)      if (s == NULL) {
       return NULL;          qemu_free_displaysurface(ds->surface);
           qemu_free(ds);
           return NULL;
       }
     s->hw_update = update;      s->hw_update = update;
     s->hw_invalidate = invalidate;      s->hw_invalidate = invalidate;
     s->hw_screen_dump = screen_dump;      s->hw_screen_dump = screen_dump;
       s->hw_text_update = text_update;
     s->hw = opaque;      s->hw = opaque;
     return s;  
       register_displaystate(ds);
       return ds;
 }  }
   
 int is_graphic_console(void)  int is_graphic_console(void)
 {  {
     return active_console->console_type == GRAPHIC_CONSOLE;      return active_console && active_console->console_type == GRAPHIC_CONSOLE;
   }
   
   int is_fixedsize_console(void)
   {
       return active_console && active_console->console_type != TEXT_CONSOLE;
 }  }
   
 void console_color_init(DisplayState *ds)  void console_color_init(DisplayState *ds)
Line 1174  void console_color_init(DisplayState *ds Line 1310  void console_color_init(DisplayState *ds
     int i, j;      int i, j;
     for (j = 0; j < 2; j++) {      for (j = 0; j < 2; j++) {
         for (i = 0; i < 8; i++) {          for (i = 0; i < 8; i++) {
             color_table[j][i] = col_expand(ds,               color_table[j][i] = col_expand(ds,
                    vga_get_color(ds, color_table_rgb[j][i]));                     vga_get_color(ds, color_table_rgb[j][i]));
         }          }
     }      }
 }  }
   
 CharDriverState *text_console_init(DisplayState *ds, const char *p)  static int n_text_consoles;
   static CharDriverState *text_consoles[128];
   static char *text_console_strs[128];
   
   static void text_console_do_init(CharDriverState *chr, DisplayState *ds, const char *p)
 {  {
     CharDriverState *chr;  
     TextConsole *s;      TextConsole *s;
     unsigned width;      unsigned width;
     unsigned height;      unsigned height;
     static int color_inited;      static int color_inited;
   
     chr = qemu_mallocz(sizeof(CharDriverState));  
     if (!chr)  
         return NULL;  
     s = new_console(ds, (p == 0) ? TEXT_CONSOLE : TEXT_CONSOLE_FIXED_SIZE);      s = new_console(ds, (p == 0) ? TEXT_CONSOLE : TEXT_CONSOLE_FIXED_SIZE);
     if (!s) {      if (!s) {
         free(chr);          free(chr);
         return NULL;          return;
     }      }
     chr->opaque = s;      chr->opaque = s;
     chr->chr_write = console_puts;      chr->chr_write = console_puts;
Line 1204  CharDriverState *text_console_init(Displ Line 1340  CharDriverState *text_console_init(Displ
     s->out_fifo.buf = s->out_fifo_buf;      s->out_fifo.buf = s->out_fifo_buf;
     s->out_fifo.buf_size = sizeof(s->out_fifo_buf);      s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
     s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);      s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);
       s->ds = ds;
   
     if (!color_inited) {      if (!color_inited) {
         color_inited = 1;          color_inited = 1;
Line 1214  CharDriverState *text_console_init(Displ Line 1351  CharDriverState *text_console_init(Displ
     s->total_height = DEFAULT_BACKSCROLL;      s->total_height = DEFAULT_BACKSCROLL;
     s->x = 0;      s->x = 0;
     s->y = 0;      s->y = 0;
     width = s->ds->width;      width = ds_get_width(s->ds);
     height = s->ds->height;      height = ds_get_height(s->ds);
     if (p != 0) {      if (p != 0) {
         width = strtoul(p, (char **)&p, 10);          width = strtoul(p, (char **)&p, 10);
         if (*p == 'C') {          if (*p == 'C') {
Line 1234  CharDriverState *text_console_init(Displ Line 1371  CharDriverState *text_console_init(Displ
     s->g_width = width;      s->g_width = width;
     s->g_height = height;      s->g_height = height;
   
       s->hw_invalidate = text_console_invalidate;
       s->hw_text_update = text_console_update;
       s->hw = s;
   
     /* Set text attribute defaults */      /* Set text attribute defaults */
     s->t_attrib_default.bold = 0;      s->t_attrib_default.bold = 0;
     s->t_attrib_default.uline = 0;      s->t_attrib_default.uline = 0;
Line 1242  CharDriverState *text_console_init(Displ Line 1383  CharDriverState *text_console_init(Displ
     s->t_attrib_default.unvisible = 0;      s->t_attrib_default.unvisible = 0;
     s->t_attrib_default.fgcol = COLOR_WHITE;      s->t_attrib_default.fgcol = COLOR_WHITE;
     s->t_attrib_default.bgcol = COLOR_BLACK;      s->t_attrib_default.bgcol = COLOR_BLACK;
   
     /* set current text attributes to default */      /* set current text attributes to default */
     s->t_attrib = s->t_attrib_default;      s->t_attrib = s->t_attrib_default;
     text_console_resize(s);      text_console_resize(s);
   
     qemu_chr_reset(chr);      qemu_chr_reset(chr);
       if (chr->init)
           chr->init(chr);
   }
   
   CharDriverState *text_console_init(const char *p)
   {
       CharDriverState *chr;
   
       chr = qemu_mallocz(sizeof(CharDriverState));
   
       if (n_text_consoles == 128) {
           fprintf(stderr, "Too many text consoles\n");
           exit(1);
       }
       text_consoles[n_text_consoles] = chr;
       text_console_strs[n_text_consoles] = p ? qemu_strdup(p) : NULL;
       n_text_consoles++;
   
     return chr;      return chr;
 }  }
   
   void text_consoles_set_display(DisplayState *ds)
   {
       int i;
   
       for (i = 0; i < n_text_consoles; i++) {
           text_console_do_init(text_consoles[i], ds, text_console_strs[i]);
           qemu_free(text_console_strs[i]);
       }
   
       n_text_consoles = 0;
   }
   
   void qemu_console_resize(DisplayState *ds, int width, int height)
   {
       TextConsole *s = get_graphic_console(ds);
       if (!s) return;
   
       s->g_width = width;
       s->g_height = height;
       if (is_graphic_console()) {
           ds->surface = qemu_resize_displaysurface(ds->surface, width, height, 32, 4 * width);
           dpy_resize(ds);
       }
   }
   
   void qemu_console_copy(DisplayState *ds, int src_x, int src_y,
                          int dst_x, int dst_y, int w, int h)
   {
       if (is_graphic_console()) {
           dpy_copy(ds, src_x, src_y, dst_x, dst_y, w, h);
       }
   }
   
   PixelFormat qemu_different_endianness_pixelformat(int bpp)
   {
       PixelFormat pf;
   
       memset(&pf, 0x00, sizeof(PixelFormat));
   
       pf.bits_per_pixel = bpp;
       pf.bytes_per_pixel = bpp / 8;
       pf.depth = bpp == 32 ? 24 : bpp;
   
       switch (bpp) {
           case 24:
               pf.rmask = 0x000000FF;
               pf.gmask = 0x0000FF00;
               pf.bmask = 0x00FF0000;
               pf.rmax = 255;
               pf.gmax = 255;
               pf.bmax = 255;
               pf.rshift = 0;
               pf.gshift = 8;
               pf.bshift = 16;
               pf.rbits = 8;
               pf.gbits = 8;
               pf.bbits = 8;
               break;
           case 32:
               pf.rmask = 0x0000FF00;
               pf.gmask = 0x00FF0000;
               pf.bmask = 0xFF000000;
               pf.amask = 0x00000000;
               pf.amax = 255;
               pf.rmax = 255;
               pf.gmax = 255;
               pf.bmax = 255;
               pf.ashift = 0;
               pf.rshift = 8;
               pf.gshift = 16;
               pf.bshift = 24;
               pf.rbits = 8;
               pf.gbits = 8;
               pf.bbits = 8;
               pf.abits = 8;
               break;
           default:
               break;
       }
       return pf;
   }
   
   PixelFormat qemu_default_pixelformat(int bpp)
   {
       PixelFormat pf;
   
       memset(&pf, 0x00, sizeof(PixelFormat));
   
       pf.bits_per_pixel = bpp;
       pf.bytes_per_pixel = bpp / 8;
       pf.depth = bpp == 32 ? 24 : bpp;
   
       switch (bpp) {
           case 16:
               pf.rmask = 0x0000F800;
               pf.gmask = 0x000007E0;
               pf.bmask = 0x0000001F;
               pf.rmax = 31;
               pf.gmax = 63;
               pf.bmax = 31;
               pf.rshift = 11;
               pf.gshift = 5;
               pf.bshift = 0;
               pf.rbits = 5;
               pf.gbits = 6;
               pf.bbits = 5;
               break;
           case 24:
               pf.rmask = 0x00FF0000;
               pf.gmask = 0x0000FF00;
               pf.bmask = 0x000000FF;
               pf.rmax = 255;
               pf.gmax = 255;
               pf.bmax = 255;
               pf.rshift = 16;
               pf.gshift = 8;
               pf.bshift = 0;
               pf.rbits = 8;
               pf.gbits = 8;
               pf.bbits = 8;
           case 32:
               pf.rmask = 0x00FF0000;
               pf.gmask = 0x0000FF00;
               pf.bmask = 0x000000FF;
               pf.amax = 255;
               pf.rmax = 255;
               pf.gmax = 255;
               pf.bmax = 255;
               pf.ashift = 24;
               pf.rshift = 16;
               pf.gshift = 8;
               pf.bshift = 0;
               pf.rbits = 8;
               pf.gbits = 8;
               pf.bbits = 8;
               pf.abits = 8;
               break;
           default:
               break;
       }
       return pf;
   }
   
   DisplaySurface* qemu_create_displaysurface(int width, int height, int bpp, int linesize)
   {
       DisplaySurface *surface = (DisplaySurface*) qemu_mallocz(sizeof(DisplaySurface));
   
       surface->width = width;
       surface->height = height;
       surface->linesize = linesize;
       surface->pf = qemu_default_pixelformat(bpp);
   #ifdef WORDS_BIGENDIAN
       surface->flags = QEMU_ALLOCATED_FLAG | QEMU_BIG_ENDIAN_FLAG;
   #else
       surface->flags = QEMU_ALLOCATED_FLAG;
   #endif
       surface->data = (uint8_t*) qemu_mallocz(surface->linesize * surface->height);
   
       return surface;
   }
   
   DisplaySurface* qemu_resize_displaysurface(DisplaySurface *surface,
                                             int width, int height, int bpp, int linesize)
   {
       surface->width = width;
       surface->height = height;
       surface->linesize = linesize;
       surface->pf = qemu_default_pixelformat(bpp);
       if (surface->flags & QEMU_ALLOCATED_FLAG)
           surface->data = (uint8_t*) qemu_realloc(surface->data, surface->linesize * surface->height);
       else
           surface->data = (uint8_t*) qemu_malloc(surface->linesize * surface->height);
   #ifdef WORDS_BIGENDIAN
       surface->flags = QEMU_ALLOCATED_FLAG | QEMU_BIG_ENDIAN_FLAG;
   #else
       surface->flags = QEMU_ALLOCATED_FLAG;
   #endif
   
       return surface;
   }
   
   DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,
                                                 int linesize, uint8_t *data)
   {
       DisplaySurface *surface = (DisplaySurface*) qemu_mallocz(sizeof(DisplaySurface));
   
       surface->width = width;
       surface->height = height;
       surface->linesize = linesize;
       surface->pf = qemu_default_pixelformat(bpp);
   #ifdef WORDS_BIGENDIAN
       surface->flags = QEMU_BIG_ENDIAN_FLAG;
   #endif
       surface->data = data;
   
       return surface;
   }
   
   void qemu_free_displaysurface(DisplaySurface *surface)
   {
       if (surface == NULL)
           return;
       if (surface->flags & QEMU_ALLOCATED_FLAG)
           qemu_free(surface->data);
       qemu_free(surface);
   }

Removed from v.1.1.1.5  
changed lines
  Added in v.1.1.1.6


unix.superglobalmegacorp.com