Diff for /qemu/console.c between versions 1.1.1.11 and 1.1.1.12

version 1.1.1.11, 2018/04/24 18:55:58 version 1.1.1.12, 2018/04/24 19:17:02
Line 115  typedef enum { Line 115  typedef enum {
 /* ??? This is mis-named.  /* ??? This is mis-named.
    It is used for both text and graphical consoles.  */     It is used for both text and graphical consoles.  */
 struct TextConsole {  struct TextConsole {
       int index;
     console_type_t console_type;      console_type_t console_type;
     DisplayState *ds;      DisplayState *ds;
     /* Graphic console state.  */      /* Graphic console state.  */
Line 177  void vga_hw_screen_dump(const char *file Line 178  void vga_hw_screen_dump(const char *file
     TextConsole *previous_active_console;      TextConsole *previous_active_console;
   
     previous_active_console = active_console;      previous_active_console = active_console;
     active_console = consoles[0];  
     /* There is currently no way of specifying which screen we want to dump,      /* There is currently no way of specifying which screen we want to dump,
        so always dump the first one.  */         so always dump the first one.  */
     if (consoles[0] && consoles[0]->hw_screen_dump)      console_select(0);
       if (consoles[0] && 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;      }
   
       if (previous_active_console) {
           console_select(previous_active_console->index);
       }
 }  }
   
 void vga_hw_text_update(console_ch_t *chardata)  void vga_hw_text_update(console_ch_t *chardata)
Line 343  static const uint32_t dmask4[4] = { Line 349  static const uint32_t dmask4[4] = {
   
 static uint32_t color_table[2][8];  static uint32_t color_table[2][8];
   
   #ifndef CONFIG_CURSES
 enum color_names {  enum color_names {
     COLOR_BLACK   = 0,      COLOR_BLACK   = 0,
     COLOR_RED     = 1,      COLOR_RED     = 1,
Line 353  enum color_names { Line 360  enum color_names {
     COLOR_CYAN    = 6,      COLOR_CYAN    = 6,
     COLOR_WHITE   = 7      COLOR_WHITE   = 7
 };  };
   #endif
   
 static const uint32_t color_table_rgb[2][8] = {  static const uint32_t color_table_rgb[2][8] = {
     {   /* dark */      {   /* dark */
Line 461  static void vga_putcharxy(DisplayState * Line 469  static void vga_putcharxy(DisplayState *
             font_data = *font_ptr++;              font_data = *font_ptr++;
             if (t_attrib->uline              if (t_attrib->uline
                 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {                  && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
                 font_data = 0xFFFF;                  font_data = 0xFF;
             }              }
             ((uint32_t *)d)[0] = (dmask16[(font_data >> 4)] & xorcol) ^ bgcol;              ((uint32_t *)d)[0] = (dmask16[(font_data >> 4)] & xorcol) ^ bgcol;
             ((uint32_t *)d)[1] = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;              ((uint32_t *)d)[1] = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;
Line 474  static void vga_putcharxy(DisplayState * Line 482  static void vga_putcharxy(DisplayState *
             font_data = *font_ptr++;              font_data = *font_ptr++;
             if (t_attrib->uline              if (t_attrib->uline
                 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {                  && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
                 font_data = 0xFFFF;                  font_data = 0xFF;
             }              }
             ((uint32_t *)d)[0] = (dmask4[(font_data >> 6)] & xorcol) ^ bgcol;              ((uint32_t *)d)[0] = (dmask4[(font_data >> 6)] & xorcol) ^ bgcol;
             ((uint32_t *)d)[1] = (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol;              ((uint32_t *)d)[1] = (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol;
Line 487  static void vga_putcharxy(DisplayState * Line 495  static void vga_putcharxy(DisplayState *
         for(i = 0; i < FONT_HEIGHT; i++) {          for(i = 0; i < FONT_HEIGHT; i++) {
             font_data = *font_ptr++;              font_data = *font_ptr++;
             if (t_attrib->uline && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {              if (t_attrib->uline && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
                 font_data = 0xFFFF;                  font_data = 0xFF;
             }              }
             ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;              ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
             ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;              ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
Line 516  static void text_console_resize(TextCons Line 524  static void text_console_resize(TextCons
     if (s->width < w1)      if (s->width < w1)
         w1 = s->width;          w1 = s->width;
   
     cells = qemu_malloc(s->width * s->total_height * sizeof(TextCell));      cells = g_malloc(s->width * s->total_height * sizeof(TextCell));
     for(y = 0; y < s->total_height; y++) {      for(y = 0; y < s->total_height; y++) {
         c = &cells[y * s->width];          c = &cells[y * s->width];
         if (w1 > 0) {          if (w1 > 0) {
Line 531  static void text_console_resize(TextCons Line 539  static void text_console_resize(TextCons
             c++;              c++;
         }          }
     }      }
     qemu_free(s->cells);      g_free(s->cells);
     s->cells = cells;      s->cells = cells;
 }  }
   
Line 1102  static int console_puts(CharDriverState  Line 1110  static int console_puts(CharDriverState 
     return len;      return len;
 }  }
   
 static void console_send_event(CharDriverState *chr, int event)  
 {  
     TextConsole *s = chr->opaque;  
     int i;  
   
     if (event == CHR_EVENT_FOCUS) {  
         for(i = 0; i < nb_consoles; i++) {  
             if (consoles[i] == s) {  
                 console_select(i);  
                 break;  
             }  
         }  
     }  
 }  
   
 static void kbd_send_chars(void *opaque)  static void kbd_send_chars(void *opaque)
 {  {
     TextConsole *s = opaque;      TextConsole *s = opaque;
     int len;      int len;
     uint8_t buf[16];      uint8_t buf[16];
   
     len = qemu_chr_can_read(s->chr);      len = qemu_chr_be_can_write(s->chr);
     if (len > s->out_fifo.count)      if (len > s->out_fifo.count)
         len = s->out_fifo.count;          len = s->out_fifo.count;
     if (len > 0) {      if (len > 0) {
         if (len > sizeof(buf))          if (len > sizeof(buf))
             len = sizeof(buf);              len = sizeof(buf);
         qemu_fifo_read(&s->out_fifo, buf, len);          qemu_fifo_read(&s->out_fifo, buf, len);
         qemu_chr_read(s->chr, buf, len);          qemu_chr_be_write(s->chr, buf, len);
     }      }
     /* characters are pending: we send them a bit later (XXX:      /* characters are pending: we send them a bit later (XXX:
        horrible, should change char device API) */         horrible, should change char device API) */
Line 1252  static TextConsole *new_console(DisplayS Line 1245  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 = g_malloc0(sizeof(TextConsole));
     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 1260  static TextConsole *new_console(DisplayS Line 1253  static TextConsole *new_console(DisplayS
     s->ds = ds;      s->ds = ds;
     s->console_type = console_type;      s->console_type = console_type;
     if (console_type != GRAPHIC_CONSOLE) {      if (console_type != GRAPHIC_CONSOLE) {
           s->index = nb_consoles;
         consoles[nb_consoles++] = s;          consoles[nb_consoles++] = s;
     } else {      } else {
         /* HACK: Put graphical consoles before text consoles.  */          /* HACK: Put graphical consoles before text consoles.  */
Line 1267  static TextConsole *new_console(DisplayS Line 1261  static TextConsole *new_console(DisplayS
             if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)              if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
                 break;                  break;
             consoles[i] = consoles[i - 1];              consoles[i] = consoles[i - 1];
               consoles[i]->index = i;
         }          }
           s->index = i;
         consoles[i] = s;          consoles[i] = s;
         nb_consoles++;          nb_consoles++;
     }      }
Line 1276  static TextConsole *new_console(DisplayS Line 1272  static TextConsole *new_console(DisplayS
   
 static DisplaySurface* defaultallocator_create_displaysurface(int width, int height)  static DisplaySurface* defaultallocator_create_displaysurface(int width, int height)
 {  {
     DisplaySurface *surface = (DisplaySurface*) qemu_mallocz(sizeof(DisplaySurface));      DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
   
     int linesize = width * 4;      int linesize = width * 4;
     qemu_alloc_display(surface, width, height, linesize,      qemu_alloc_display(surface, width, height, linesize,
Line 1302  void qemu_alloc_display(DisplaySurface * Line 1298  void qemu_alloc_display(DisplaySurface *
     surface->linesize = linesize;      surface->linesize = linesize;
     surface->pf = pf;      surface->pf = pf;
     if (surface->flags & QEMU_ALLOCATED_FLAG) {      if (surface->flags & QEMU_ALLOCATED_FLAG) {
         data = qemu_realloc(surface->data,          data = g_realloc(surface->data,
                             surface->linesize * surface->height);                              surface->linesize * surface->height);
     } else {      } else {
         data = qemu_malloc(surface->linesize * surface->height);          data = g_malloc(surface->linesize * surface->height);
     }      }
     surface->data = (uint8_t *)data;      surface->data = (uint8_t *)data;
     surface->flags = newflags | QEMU_ALLOCATED_FLAG;      surface->flags = newflags | QEMU_ALLOCATED_FLAG;
Line 1317  void qemu_alloc_display(DisplaySurface * Line 1313  void qemu_alloc_display(DisplaySurface *
 DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,  DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,
                                               int linesize, uint8_t *data)                                                int linesize, uint8_t *data)
 {  {
     DisplaySurface *surface = (DisplaySurface*) qemu_mallocz(sizeof(DisplaySurface));      DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
   
     surface->width = width;      surface->width = width;
     surface->height = height;      surface->height = height;
Line 1336  static void defaultallocator_free_displa Line 1332  static void defaultallocator_free_displa
     if (surface == NULL)      if (surface == NULL)
         return;          return;
     if (surface->flags & QEMU_ALLOCATED_FLAG)      if (surface->flags & QEMU_ALLOCATED_FLAG)
         qemu_free(surface->data);          g_free(surface->data);
     qemu_free(surface);      g_free(surface);
 }  }
   
 static struct DisplayAllocator default_allocator = {  static struct DisplayAllocator default_allocator = {
Line 1348  static struct DisplayAllocator default_a Line 1344  static struct DisplayAllocator default_a
   
 static void dumb_display_init(void)  static void dumb_display_init(void)
 {  {
     DisplayState *ds = qemu_mallocz(sizeof(DisplayState));      DisplayState *ds = g_malloc0(sizeof(DisplayState));
     int width = 640;      int width = 640;
     int height = 480;      int height = 480;
   
Line 1403  DisplayState *graphic_console_init(vga_h Line 1399  DisplayState *graphic_console_init(vga_h
     TextConsole *s;      TextConsole *s;
     DisplayState *ds;      DisplayState *ds;
   
     ds = (DisplayState *) qemu_mallocz(sizeof(DisplayState));      ds = (DisplayState *) g_malloc0(sizeof(DisplayState));
     ds->allocator = &default_allocator;       ds->allocator = &default_allocator; 
     ds->surface = qemu_create_displaysurface(ds, 640, 480);      ds->surface = qemu_create_displaysurface(ds, 640, 480);
   
     s = new_console(ds, GRAPHIC_CONSOLE);      s = new_console(ds, GRAPHIC_CONSOLE);
     if (s == NULL) {      if (s == NULL) {
         qemu_free_displaysurface(ds);          qemu_free_displaysurface(ds);
         qemu_free(ds);          g_free(ds);
         return NULL;          return NULL;
     }      }
     s->hw_update = update;      s->hw_update = update;
Line 1462  static void text_console_do_init(CharDri Line 1458  static void text_console_do_init(CharDri
     s = chr->opaque;      s = chr->opaque;
   
     chr->chr_write = console_puts;      chr->chr_write = console_puts;
     chr->chr_send_event = console_send_event;  
   
     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);
Line 1521  int text_console_init(QemuOpts *opts, Ch Line 1516  int text_console_init(QemuOpts *opts, Ch
     unsigned width;      unsigned width;
     unsigned height;      unsigned height;
   
     chr = qemu_mallocz(sizeof(CharDriverState));      chr = g_malloc0(sizeof(CharDriverState));
   
     if (n_text_consoles == 128) {      if (n_text_consoles == 128) {
         fprintf(stderr, "Too many text consoles\n");          fprintf(stderr, "Too many text consoles\n");
Line 1545  int text_console_init(QemuOpts *opts, Ch Line 1540  int text_console_init(QemuOpts *opts, Ch
     }      }
   
     if (!s) {      if (!s) {
         free(chr);          g_free(chr);
         return -EBUSY;          return -EBUSY;
     }      }
   

Removed from v.1.1.1.11  
changed lines
  Added in v.1.1.1.12


unix.superglobalmegacorp.com