Archipelago » qemu

static void vnc_update_client(VncState *vs, int has_dirty);

static void framebuffer_update_request(VncState *vs, int incremental,

                                       int x_position, int y_position,

                                       int w, int h);

static void vnc_refresh(void *opaque);

static int vnc_refresh_server_surface(VncDisplay *vd);

static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)

    VncDisplay *vd = ds->opaque;

    struct VncSurface *s = &vd->guest;

static void vnc_dpy_resize(DisplayState *ds)

    VncDisplay *vd = ds->opaque;

    VncState *vs = vd->clients;

    /* server surface */

    if (!vd->server)

        vd->server = qemu_mallocz(sizeof(*vd->server));

    if (vd->server->data)

        qemu_free(vd->server->data);

    *(vd->server) = *(ds->surface);

    vd->server->data = qemu_mallocz(vd->server->linesize *

                                    vd->server->height);

    if (!vd->guest.ds)

        vd->guest.ds = qemu_mallocz(sizeof(*vd->guest.ds));

    if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)

    size_changed = ds_get_width(ds) != vd->guest.ds->width ||

                   ds_get_height(ds) != vd->guest.ds->height;

    *(vd->guest.ds) = *(ds->surface);

    memset(vd->guest.dirty, 0xFF, sizeof(vd->guest.dirty));

        vnc_colordepth(vs);

        if (size_changed) {

            if (vs->csock != -1 && vnc_has_feature(vs, VNC_FEATURE_RESIZE)) {

                vnc_write_u8(vs, 0);  /* msg id */

                vnc_write_u8(vs, 0);

                vnc_write_u16(vs, 1); /* number of rects */

                vnc_framebuffer_update(vs, 0, 0, ds_get_width(ds), ds_get_height(ds),

                        VNC_ENCODING_DESKTOPRESIZE);

                vnc_flush(vs);

            }

        }

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

    VncDisplay *vd = vs->vd;

    r = ((((v & vd->server->pf.rmask) >> vd->server->pf.rshift) << vs->clientds.pf.rbits) >>

        vd->server->pf.rbits);

    g = ((((v & vd->server->pf.gmask) >> vd->server->pf.gshift) << vs->clientds.pf.gbits) >>

        vd->server->pf.gbits);

    b = ((((v & vd->server->pf.bmask) >> vd->server->pf.bshift) << vs->clientds.pf.bbits) >>

        vd->server->pf.bbits);

    VncDisplay *vd = vs->vd;

    if (vd->server->pf.bytes_per_pixel == 4) {

    } else if (vd->server->pf.bytes_per_pixel == 2) {

    } else if (vd->server->pf.bytes_per_pixel == 1) {

    VncDisplay *vd = vs->vd;

    row = vd->server->data + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);

    VncDisplay *vd = vs->vd;

    last_fg = (uint8_t *) qemu_malloc(vd->server->pf.bytes_per_pixel);

    last_bg = (uint8_t *) qemu_malloc(vd->server->pf.bytes_per_pixel);

    uint8_t *src_row;

    uint8_t *dst_row;

    int i,x,y,pitch,depth,inc,w_lim,s;

    int cmp_bytes;

    vnc_refresh_server_surface(vd);

            vnc_update_client(vs, 1);

    /* do bitblit op on the local surface too */

    pitch = ds_get_linesize(vd->ds);

    depth = ds_get_bytes_per_pixel(vd->ds);

    src_row = vd->server->data + pitch * src_y + depth * src_x;

    dst_row = vd->server->data + pitch * dst_y + depth * dst_x;

    y = dst_y;

    inc = 1;

    if (dst_y > src_y) {

        /* copy backwards */

        src_row += pitch * (h-1);

        dst_row += pitch * (h-1);

        pitch = -pitch;

        y = dst_y + h - 1;

        inc = -1;

    }

    w_lim = w - (16 - (dst_x % 16));

    if (w_lim < 0)

        w_lim = w;

    else

        w_lim = w - (w_lim % 16);

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

        for (x = 0; x <= w_lim;

                x += s, src_row += cmp_bytes, dst_row += cmp_bytes) {

            if (x == w_lim) {

                if ((s = w - w_lim) == 0)

                    break;

            } else if (!x) {

                s = (16 - (dst_x % 16));

                s = MIN(s, w_lim);

            } else {

                s = 16;

            }

            cmp_bytes = s * depth;

            if (memcmp(src_row, dst_row, cmp_bytes) == 0)

                continue;

            memmove(dst_row, src_row, cmp_bytes);

            vs = vd->clients;

            while (vs != NULL) {

                if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT))

                    vnc_set_bit(vs->dirty[y], ((x + dst_x) / 16));

                vs = vs->next;

            }

        }

        src_row += pitch - w * depth;

        dst_row += pitch - w * depth;

        y += inc;

    }

static int find_and_clear_dirty_height(struct VncState *vs,

    VncDisplay *vd = vs->vd;

    for (h = 1; h < (vd->server->height - y); h++) {

        if (!vnc_get_bit(vs->dirty[y + h], last_x))

            vnc_clear_bit(vs->dirty[y + h], tmp_x);

static void vnc_update_client(VncState *vs, int has_dirty)

        VncDisplay *vd = vs->vd;

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

            for (x = 0; x < vd->server->width / 16; x++) {

                if (vnc_get_bit(vs->dirty[y], x)) {

                    vnc_clear_bit(vs->dirty[y], x);

                        int h = find_and_clear_dirty_height(vs, y, last_x, x);

                int h = find_and_clear_dirty_height(vs, y, last_x, x);

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

    vs->clientds = *(vs->vd->guest.ds);

static int vnc_refresh_server_surface(VncDisplay *vd)

{

    int y;

    uint8_t *guest_row;

    uint8_t *server_row;

    int cmp_bytes;

    uint32_t width_mask[VNC_DIRTY_WORDS];

    VncState *vs = NULL;

    int has_dirty = 0;

    /*

     * Walk through the guest dirty map.

     * Check and copy modified bits from guest to server surface.

     * Update server dirty map.

     */

    vnc_set_bits(width_mask, (ds_get_width(vd->ds) / 16), VNC_DIRTY_WORDS);

    cmp_bytes = 16 * ds_get_bytes_per_pixel(vd->ds);

    guest_row  = vd->guest.ds->data;

    server_row = vd->server->data;

    for (y = 0; y < vd->guest.ds->height; y++) {

        if (vnc_and_bits(vd->guest.dirty[y], width_mask, VNC_DIRTY_WORDS)) {

            int x;

            uint8_t *guest_ptr;

            uint8_t *server_ptr;

            guest_ptr  = guest_row;

            server_ptr = server_row;

            for (x = 0; x < vd->guest.ds->width;

                    x += 16, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {

                if (!vnc_get_bit(vd->guest.dirty[y], (x / 16)))

                    continue;

                vnc_clear_bit(vd->guest.dirty[y], (x / 16));

                if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0)

                    continue;

                memcpy(server_ptr, guest_ptr, cmp_bytes);

                vs = vd->clients;

                while (vs != NULL) {

                    vnc_set_bit(vs->dirty[y], (x / 16));

                    vs = vs->next;

                }

                has_dirty++;

            }

        }

        guest_row  += ds_get_linesize(vd->ds);

        server_row += ds_get_linesize(vd->ds);

    }

    return has_dirty;

}

    VncState *vs = NULL;

    int has_dirty = 0;

    has_dirty = vnc_refresh_server_surface(vd);

    vs = vd->clients;

        vnc_update_client(vs, has_dirty);

        vnc_refresh(vd);

    vs->next = vd->clients;

    vd->clients = vs;

    vga_hw_update();

struct VncSurface

{

    uint32_t dirty[VNC_MAX_HEIGHT][VNC_DIRTY_WORDS];

    DisplaySurface *ds;

};

    struct VncSurface guest;   /* guest visible surface (aka ds->surface) */

    DisplaySurface *server;  /* vnc server surface */

    uint32_t dirty[VNC_MAX_HEIGHT][VNC_DIRTY_WORDS];

    VncDisplay *vd = vs->vd;

    uint8_t *row = vd->server->data + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);