Archipelago » qemu

{

    unsigned int r, g, b, color;

#if 0

    case 8:

        r = (rgba >> 16) & 0xff;

    uint8_t *d, *d1;

    int x, y, bpp;

    for (y = 0; y < height; y++) {

        d = d1;

        switch(bpp) {

            }

            break;

        }

    }

}

    uint8_t *d;

    int wb, y, bpp;

    wb = w * bpp;

    if (yd <= ys) {

        for (y = 0; y < h; y++) {

            memmove(d, s, wb);

        }

    } else {

       for (y = 0; y < h; y++) {

            memmove(d, s, wb);

        }

    }

}

static inline unsigned int col_expand(DisplayState *ds, unsigned int col)

{

    case 8:

        col |= col << 8;

        col |= col << 16;

        bgcol = color_table[t_attrib->bold][t_attrib->bgcol];

    }

    font_ptr = vgafont16 + FONT_HEIGHT * ch;

    xorcol = bgcol ^ fgcol;

    case 8:

        for(i = 0; i < FONT_HEIGHT; i++) {

            font_data = *font_ptr++;

    int y1, y2;

    if (s == active_console) {

            text_update_xy(s, x, y);

            return;

        }

    if (s == active_console) {

        int x = s->x;

            s->cursor_invalidate = 1;

            return;

        }

    if (s != active_console)

        return;

        s->text_x[0] = 0;

        s->text_y[0] = 0;

        s->text_x[1] = s->width - 1;

        return;

    }

                  color_table[0][COLOR_BLACK]);

    y1 = s->y_displayed;

    for(y = 0; y < s->height; y++) {

        if (++y1 == s->total_height)

            y1 = 0;

    }

    console_show_cursor(s, 1);

}

            c++;

        }

        if (s == active_console && s->y_displayed == s->y_base) {

                s->text_x[0] = 0;

                s->text_y[0] = 0;

                s->text_x[1] = s->width - 1;

    if (s) {

        active_console = s;

        if (s->console_type != TEXT_CONSOLE && s->g_width && s->g_height

            dpy_resize(s->ds, s->g_width, s->g_height);

        vga_hw_invalidate();

    }

{

    TextConsole *s = (TextConsole *) opaque;

        if (s->console_type == TEXT_CONSOLE_FIXED_SIZE)

            dpy_resize(s->ds, s->g_width, s->g_height);

        else {

            text_console_resize(s);

        }

    }

    s->total_height = DEFAULT_BACKSCROLL;

    s->x = 0;

    s->y = 0;

    if (p != 0) {

        width = strtoul(p, (char **)&p, 10);

        if (*p == 'C') {

void qemu_console_resize(QEMUConsole *console, int width, int height)

{

    if (console->g_width != width || console->g_height != height

        console->g_width = width;

        console->g_height = height;

        if (active_console == console) {

        s->dpy_text_cursor(s, x, y);

}

typedef unsigned long console_ch_t;

static inline void console_write_ch(console_ch_t *dest, uint32_t ch)

{

        s->my[1] = s->data.y + s->data.dy;

    bypp[0] = s->bpp;

    bypl[0] = bypp[0] * s->data.pitch;

    bypl[1] = bypp[1] * s->x;

    bypl[2] = bypp[0] * s->data.dx;

    if (!s->enable)

        return;

        s->invalidate = 1;

        qemu_console_resize(s->console, s->x, s->y);

    }

        s->invalidate = 0;

        if (s->blank) {

            return;

        }

    if (s->mx[1] <= s->mx[0])

        return;

    bypl = bypp * s->x;

    bwidth = bypp * (s->mx[1] - s->mx[0]);

    y = s->my[0];

    src = s->fb + bypl * y + bypp * s->mx[0];

    for (; y < s->my[1]; y ++, src += bypl, dst += bypl)

        memcpy(dst, src, bwidth);

    struct blizzard_s *s = (struct blizzard_s *) opaque;

    blizzard_update_display(opaque);

}

#define DEPTH 8

    s->state = ds;

    s->fb = qemu_malloc(0x180000);

    case 0:

        s->line_fn_tab[0] = s->line_fn_tab[1] =

                qemu_mallocz(sizeof(blizzard_fn_t) * 0x10);

    color1 = s->rgb_to_pixel(c6_to_8(palette[0xf * 3]),

                             c6_to_8(palette[0xf * 3 + 1]),

                             c6_to_8(palette[0xf * 3 + 2]));

    d1 += x1 * bpp;

    default:

        break;

    case 8:

static void g364fb_draw_graphic(G364State *s, int full_update)

{

        case 8:

            g364fb_draw_graphic8(s, full_update);

            break;

            g364fb_draw_graphic32(s, full_update);

            break;

        default:

            return;

    }

    if (!full_update)

        return;

    for(i = 0; i < s->scr_height; i++) {

        memset(d, 0, w);

    }

    dpy_update(s->ds, 0, 0, s->scr_width, s->scr_height);

        s->graphic_mode = graphic_mode;

        full_update = 1;

    }

        qemu_console_resize(s->console, s->scr_width, s->scr_height);

        full_update = 1;

    }

    data_buffer = s->vram_buffer;

    w_display = s->scr_width * PIXEL_WIDTH / 8;

    for(i = 0; i < s->scr_height; i++) {

        dd = data_display;

        for (j = 0; j < s->scr_width; j++, dd += PIXEL_WIDTH / 8, data_buffer++) {

                s->palette[index][1],

                s->palette[index][2]);

        }

    }

}

    uint8_t *d;

    int x, bpp;

    switch(bpp) {

        case 1:

            for (x = posx1; x <= posx2; x++) {

    uint8_t *d;

    int y, bpp;

    switch(bpp) {

        case 1:

            for (y = posy1; y <= posy2; y++) {

                *((uint8_t *)d) = color;

            }

            break;

        case 2:

            for (y = posy1; y <= posy2; y++) {

                *((uint16_t *)d) = color;

            }

            break;

        case 4:

            for (y = posy1; y <= posy2; y++) {

                *((uint32_t *)d) = color;

            }

            break;

    }

    if (s->state & REDRAW_BACKGROUND) {

        /* clear screen */

        }

    }

    if (s->state & REDRAW_SEGMENTS) {

        /* set colors according to bpp */

            case 8:

                color_segment = rgb_to_pixel8(0xaa, 0xaa, 0xaa);

                color_led = rgb_to_pixel8(0x00, 0xff, 0x00);

    }

    s->state = REDRAW_NONE;

}

static void jazz_led_invalidate_display(void *opaque)

        (musicpal_lcd_state *s, int x, int y, type col) \

{ \

    int dx, dy; \

\

    for (dy = 0; dy < 3; dy++, pixel += 127 * 3) \

        for (dx = 0; dx < 3; dx++, pixel++) \

    musicpal_lcd_state *s = opaque;

    int x, y, col;

    case 0:

        return;

#define LCD_REFRESH(depth, func) \

    LCD_REFRESH(32, (s->ds->bgr ? rgb_to_pixel32bgr : rgb_to_pixel32))

    default:

        cpu_abort(cpu_single_env, "unsupported colour depth %i\n",

    }

    dpy_update(s->ds, 0, 0, 128*3, 64*3);

    uint8_t *s, *d;

    if (!omap_lcd || omap_lcd->plm == 1 ||

        return;

    frame_offset = 0;

    /* Colour depth */

    switch ((omap_lcd->palette[0] >> 12) & 7) {

    case 1:

        bpp = 2;

        break;

    case 2:

        bpp = 4;

        break;

    case 3:

        bpp = 8;

        break;

    case 4 ... 7:

        if (!omap_lcd->tft)

        else

        bpp = 16;

        break;

    /* Resolution */

    width = omap_lcd->width;

        qemu_console_resize(omap_lcd->console,

                            omap_lcd->width, omap_lcd->height);

        omap_lcd->invalidate = 1;

    if (omap_lcd->dma->dual)

        omap_lcd->dma->current_frame ^= 1;

        return;

    line = 0;

    step = width * bpp >> 3;

    scanline = frame_base + step * line;

    s = (uint8_t *) (phys_ram_base + scanline);

    dirty[0] = dirty[1] =

            cpu_physical_memory_get_dirty(scanline, VGA_DIRTY_FLAG);

static void omap_screen_dump(void *opaque, const char *filename) {

    struct omap_lcd_panel_s *omap_lcd = opaque;

    omap_update_display(opaque);

                omap_lcd->width, omap_lcd->height,

}

static void omap_invalidate_display(void *opaque) {

    if (!pl110_enabled(s))

        return;

    case 0:

        return;

    case 8:

    if (base > 0x80000000)

        base -= 0x80000000;

    src = phys_ram_base + base;

    first = -1;

    addr = base;

        b = (raw & 0x1f) << 3;

        /* The I bit is ignored.  */

        raw >>= 6;

        case 8:

            s->pallette[n] = rgb_to_pixel8(r, g, b);

            break;

            }

            break;

        }

        case 8:

            *dest = rgb_to_pixel8(r, g, b) | alpha;

            break;

    else if (s->bpp > pxa_lcdc_8bpp)

        src_width *= 2;

    dest_width = s->xres * s->dest_width;

    addr = (ram_addr_t) (fb - phys_ram_base);

        src_width *= 2;

    dest_width = s->yres * s->dest_width;

    addr = (ram_addr_t) (fb - phys_ram_base);

    start = addr + s->yres * src_width;

                                      pxa2xx_invalidate_display,

                                      pxa2xx_screen_dump, NULL, s);

    case 0:

        s->dest_width = 0;

        break;

    if (!s->redraw)

        return;

    case 0:

        return;

    case 15:

        colors[0] = colortab + dest_width;

        colors[1] = colortab;

    }

    for (y = 0; y < 16; y++) {

        line = (y + s->start_line) & 63;

        src = s->framebuffer + 132 * (line >> 3) + 36;

    if (!s->redraw)

        return;

    case 0:

        return;

    case 15:

    for (i = 0; i < 16; i++) {

        int n;

        colors[i] = p;

        case 15:

            n = i * 2 + (i >> 3);

            p[0] = n | (n << 5);

        p += dest_width;

    }

    /* TODO: Implement row/column remapping.  */

    for (y = 0; y < 64; y++) {

        line = y;

        src = s->framebuffer + 64 * line;

static void tc6393xb_draw_graphic(struct tc6393xb_s *s, int full_update)

{

        case 8:

            tc6393xb_draw_graphic8(s);

            break;

            tc6393xb_draw_graphic32(s);

            break;

        default:

            return;

    }

    if (!full_update)

        return;

    for(i = 0; i < s->scr_height; i++) {

        memset(d, 0, w);

    }

    dpy_update(s->ds, 0, 0, s->scr_width, s->scr_height);

        s->blanked = s->blank;

        full_update = 1;

    }

        qemu_console_resize(s->console, s->scr_width, s->scr_height);

        full_update = 1;

    }

    data_buffer = (uint16_t*)(phys_ram_base + s->vram_addr);

    w_display = s->scr_width * BITS / 8;

    for(i = 0; i < s->scr_height; i++) {

#if (BITS == 16)

        memcpy(data_display, data_buffer, s->scr_width * 2);

        data_buffer += s->scr_width;

#else

        int j;

        for (j = 0; j < s->scr_width; j++, data_display += BITS / 8, data_buffer++) {

{

    int i;

    for(i = start; i < end; i++) {

        default:

        case 8:

            s->palette[i] = rgb_to_pixel8(s->r[i], s->g[i], s->b[i]);

    uint8_t *d, *s;

    void (*f)(TCXState *s1, uint8_t *dst, const uint8_t *src, int width);

        return;

    page = ts->vram_offset;

    y_start = -1;

    page_min = 0xffffffff;

    page_max = 0;

    s = ts->vram;

    ds = 1024;

    case 32:

        f = tcx_draw_line32;

        break;

    uint8_t *d, *s;

    uint32_t *cptr, *s24;

            return;

    page = ts->vram_offset;

    page24 = ts->vram24_offset;

    y_start = -1;

    page_min = 0xffffffff;

    page_max = 0;

    s = ts->vram;

    s24 = ts->vram24;

    cptr = ts->cplane;

    ds = 1024;

    for(y = 0; y < ts->height; y += 4, page += TARGET_PAGE_SIZE,

static inline int get_depth_index(DisplayState *s)

{

    default:

    case 8:

        return 0;

        cw = 9;

    if (s->sr[1] & 0x08)

        cw = 16; /* NOTE: no 18 pixel wide */

    width = (s->cr[0x01] + 1);

    if (s->cr[0x06] == 100) {

        /* ugly hack for CGA 160x100x16 - explain me the logic */

        vga_draw_glyph8 = vga_draw_glyph8_table[depth_index];

    vga_draw_glyph9 = vga_draw_glyph9_table[depth_index];

    ch_attr_ptr = s->last_ch_attr;

    for(cy = 0; cy < height; cy++) {

        d1 = dest;

    y_start = -1;

    page_min = 0x7fffffff;

    page_max = -1;

    y1 = 0;

    for(y = 0; y < height; y++) {

        addr = addr1;

        return;

    if (s->last_scr_width <= 0 || s->last_scr_height <= 0)

        return;

        val = s->rgb_to_pixel(0, 0, 0);

    else

        val = 0;

    for(i = 0; i < s->last_scr_height; i++) {

        memset(d, val, w);

    }

    dpy_update(s->ds, 0, 0,

               s->last_scr_width, s->last_scr_height);

    VGAState *s = (VGAState *)opaque;

    int full_update, graphic_mode;

        /* nothing to do */

    } else {

        s->rgb_to_pixel =

    s->graphic_mode = -1;

    vga_update_display(s);

    }

    s->ds = saved_ds;

}

    width = s->bypp * w;

    start = s->bypp * x + bypl * y;

    src = s->vram + start;

    for (; line > 0; line --, src += bypl, dst += bypl)

        memcpy(dst, src, width);

static inline void vmsvga_update_screen(struct vmsvga_state_s *s)

{

#ifndef DIRECT_VRAM

#endif

    dpy_update(s->ds, 0, 0, s->width, s->height);

                int x0, int y0, int x1, int y1, int w, int h)

{

# ifdef DIRECT_VRAM

# else

    uint8_t *vram = s->vram;

# endif

                uint32_t c, int x, int y, int w, int h)

{

# ifdef DIRECT_VRAM

# else

    uint8_t *vram = s->vram;

# endif

    s->width = -1;

    s->height = -1;

    s->svgaid = SVGA_ID;

    s->bypp = (s->depth + 7) >> 3;

    s->cursor.on = 0;

    s->redraw_fifo_first = 0;

    }

    if (s->depth == 32) {

    }

}

    struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;

    addr -= s->vram_base;

    if (addr < s->fb_size)

    else

        return *(uint8_t *) (s->vram + addr);

}

    struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;

    addr -= s->vram_base;

    if (addr < s->fb_size)

    else

        return *(uint16_t *) (s->vram + addr);

}

    struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;

    addr -= s->vram_base;

    if (addr < s->fb_size)

    else

        return *(uint32_t *) (s->vram + addr);

}

    struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;

    addr -= s->vram_base;

    if (addr < s->fb_size)

    else

        *(uint8_t *) (s->vram + addr) = value;

}

    struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;

    addr -= s->vram_base;

    if (addr < s->fb_size)

    else

        *(uint16_t *) (s->vram + addr) = value;

}

    struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;

    addr -= s->vram_base;

    if (addr < s->fb_size)

    else

        *(uint32_t *) (s->vram + addr) = value;

}

    }

    memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));

}

/* fastest code */

    vnc_framebuffer_update(vs, x, y, w, h, 0);

    for (i = 0; i < h; i++) {

	vs->write_pixels(vs, row, w * vs->depth);

    }

}

    uint8_t *dst_row;

    char *old_row;

    int y = 0;

    VncState *vs = ds->opaque;

    vnc_update_client(vs);

	pitch = -pitch;

    }

    old_row = vs->old_data + dst;

    for (y = 0; y < h; y++) {

	/* Walk through the dirty map and eliminate tiles that

	   really aren't dirty */

	old_row = vs->old_data;

	for (y = 0; y < vs->height; y++) {

		ptr = row;

		old_ptr = (char*)old_row;

		    if (memcmp(old_ptr, ptr, 16 * vs->depth) == 0) {

			vnc_clear_bit(vs->dirty_row[y], (x / 16));

		    } else {

		}

	    }

	}

	if (!has_dirty) {

	vnc_write_u8(vs, 0);

	vnc_write_u16(vs, 1);

	vnc_framebuffer_update(vs, absolute, 0,

	vnc_flush(vs);

    }

    vs->absolute = absolute;

	dz = 1;

    if (vs->absolute) {

			dz, buttons);

    } else if (vs->has_pointer_type_change) {

	x -= 0x7FFF;

				       int x_position, int y_position,

				       int w, int h)

{

    int i;

    vs->need_update = 1;

    if (!incremental) {

	for (i = 0; i < h; i++) {

            vnc_set_bits(vs->dirty_row[y_position + i],

	}

    }

}

    vnc_write_u8(vs, 0);

    vnc_write_u8(vs, 0);

    vnc_write_u16(vs, 1);

    vnc_flush(vs);

}

    char buf[1024];

    int size;

    pixel_format_message(vs);

    vnc_write(vs, "RFB 003.008\n", 12);

    vnc_flush(vs);

    vnc_read_when(vs, protocol_version, 12);

    memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));

    vs->has_resize = 0;

    vs->has_hextile = 0;

                                             void *last_fg_,

                                             int *has_bg, int *has_fg)

{

    pixel_t *irow = (pixel_t *)row;

    int j, i;

    pixel_t *last_bg = (pixel_t *)last_bg_;

	}

	if (n_colors > 2)

	    break;

    }

    if (n_colors > 1 && fg_count > bg_count) {

		n_data += 2;

		n_subtiles++;

	    }

	}

	break;

    case 3:

		n_data += 2;

		n_subtiles++;

	    }

	}

	/* A SubrectsColoured subtile invalidates the foreground color */

    } else {

	for (j = 0; j < h; j++) {

	    vs->write_pixels(vs, row, w * vs->depth);

	}

    }

}