[Qemu-devel] [5789] Introduce accessors for DisplayState (Stefano Stabellini)

[Anthony Liguori]

Revision: 5789
          http://svn.sv.gnu.org/viewvc/?view=rev&root=qemu&revision=5789
Author:   aliguori
Date:     2008-11-24 19:29:13 +0000 (Mon, 24 Nov 2008)

Log Message:
-----------
Introduce accessors for DisplayState (Stefano Stabellini)

Introducing some accessors:

ds_get_linesize
ds_get_bits_per_pixel
ds_get_width
ds_get_height
ds_get_data

Signed-off-by: Stefano Stabellini <address@hidden>
Signed-off-by: Anthony Liguori <address@hidden>

Modified Paths:
--------------
    trunk/console.c
    trunk/console.h
    trunk/hw/blizzard.c
    trunk/hw/cirrus_vga.c
    trunk/hw/g364fb.c
    trunk/hw/g364fb_template.h
    trunk/hw/jazz_led.c
    trunk/hw/musicpal.c
    trunk/hw/omap_lcdc.c
    trunk/hw/pl110.c
    trunk/hw/pxa2xx_lcd.c
    trunk/hw/ssd0303.c
    trunk/hw/ssd0323.c
    trunk/hw/tc6393xb.c
    trunk/hw/tc6393xb_template.h
    trunk/hw/tcx.c
    trunk/hw/vga.c
    trunk/hw/vmware_vga.c
    trunk/vnc.c
    trunk/vnchextile.h

Modified: trunk/console.c
===================================================================
--- trunk/console.c     2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/console.c     2008-11-24 19:29:13 UTC (rev 5789)
@@ -190,7 +190,7 @@
 {
     unsigned int r, g, b, color;
 
-    switch(ds->depth) {
+    switch(ds_get_bits_per_pixel(ds)) {
 #if 0
     case 8:
         r = (rgba >> 16) & 0xff;
@@ -227,9 +227,9 @@
     uint8_t *d, *d1;
     int x, y, bpp;
 
-    bpp = (ds->depth + 7) >> 3;
-    d1 = ds->data +
-        ds->linesize * posy + bpp * posx;
+    bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
+    d1 = ds_get_data(ds) +
+        ds_get_linesize(ds) * posy + bpp * posx;
     for (y = 0; y < height; y++) {
         d = d1;
         switch(bpp) {
@@ -252,7 +252,7 @@
             }
             break;
         }
-        d1 += ds->linesize;
+        d1 += ds_get_linesize(ds);
     }
 }
 
@@ -263,27 +263,27 @@
     uint8_t *d;
     int wb, y, bpp;
 
-    bpp = (ds->depth + 7) >> 3;
+    bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
     wb = w * bpp;
     if (yd <= ys) {
-        s = ds->data +
-            ds->linesize * ys + bpp * xs;
-        d = ds->data +
-            ds->linesize * yd + bpp * xd;
+        s = ds_get_data(ds) +
+            ds_get_linesize(ds) * ys + bpp * xs;
+        d = ds_get_data(ds) +
+            ds_get_linesize(ds) * yd + bpp * xd;
         for (y = 0; y < h; y++) {
             memmove(d, s, wb);
-            d += ds->linesize;
-            s += ds->linesize;
+            d += ds_get_linesize(ds);
+            s += ds_get_linesize(ds);
         }
     } else {
-        s = ds->data +
-            ds->linesize * (ys + h - 1) + bpp * xs;
-        d = ds->data +
-            ds->linesize * (yd + h - 1) + bpp * xd;
+        s = ds_get_data(ds) +
+            ds_get_linesize(ds) * (ys + h - 1) + bpp * xs;
+        d = ds_get_data(ds) +
+            ds_get_linesize(ds) * (yd + h - 1) + bpp * xd;
        for (y = 0; y < h; y++) {
             memmove(d, s, wb);
-            d -= ds->linesize;
-            s -= ds->linesize;
+            d -= ds_get_linesize(ds);
+            s -= ds_get_linesize(ds);
         }
     }
 }
@@ -373,7 +373,7 @@
 
 static inline unsigned int col_expand(DisplayState *ds, unsigned int col)
 {
-    switch(ds->depth) {
+    switch(ds_get_bits_per_pixel(ds)) {
     case 8:
         col |= col << 8;
         col |= col << 16;
@@ -443,13 +443,13 @@
         bgcol = color_table[t_attrib->bold][t_attrib->bgcol];
     }
 
-    bpp = (ds->depth + 7) >> 3;
-    d = ds->data +
-        ds->linesize * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;
-    linesize = ds->linesize;
+    bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
+    d = ds_get_data(ds) +
+        ds_get_linesize(ds) * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;
+    linesize = ds_get_linesize(ds);
     font_ptr = vgafont16 + FONT_HEIGHT * ch;
     xorcol = bgcol ^ fgcol;
-    switch(ds->depth) {
+    switch(ds_get_bits_per_pixel(ds)) {
     case 8:
         for(i = 0; i < FONT_HEIGHT; i++) {
             font_data = *font_ptr++;
@@ -543,7 +543,7 @@
     int y1, y2;
 
     if (s == active_console) {
-        if (!s->ds->depth) {
+        if (!ds_get_bits_per_pixel(s->ds)) {
             text_update_xy(s, x, y);
             return;
         }
@@ -570,7 +570,7 @@
     if (s == active_console) {
         int x = s->x;
 
-        if (!s->ds->depth) {
+        if (!ds_get_bits_per_pixel(s->ds)) {
             s->cursor_invalidate = 1;
             return;
         }
@@ -604,7 +604,7 @@
 
     if (s != active_console)
         return;
-    if (!s->ds->depth) {
+    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;
@@ -613,7 +613,7 @@
         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]);
     y1 = s->y_displayed;
     for(y = 0; y < s->height; y++) {
@@ -626,7 +626,7 @@
         if (++y1 == s->total_height)
             y1 = 0;
     }
-    dpy_update(s->ds, 0, 0, s->ds->width, s->ds->height);
+    dpy_update(s->ds, 0, 0, ds_get_width(s->ds), ds_get_height(s->ds));
     console_show_cursor(s, 1);
 }
 
@@ -689,7 +689,7 @@
             c++;
         }
         if (s == active_console && s->y_displayed == s->y_base) {
-            if (!s->ds->depth) {
+            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;
@@ -1048,7 +1048,7 @@
     if (s) {
         active_console = s;
         if (s->console_type != TEXT_CONSOLE && s->g_width && s->g_height
-            && (s->g_width != s->ds->width || s->g_height != s->ds->height))
+            && (s->g_width != ds_get_width(s->ds) || s->g_height != 
ds_get_height(s->ds)))
             dpy_resize(s->ds, s->g_width, s->g_height);
         vga_hw_invalidate();
     }
@@ -1158,12 +1158,12 @@
 {
     TextConsole *s = (TextConsole *) opaque;
 
-    if (s->g_width != s->ds->width || s->g_height != s->ds->height) {
+    if (s->g_width != ds_get_width(s->ds) || s->g_height != 
ds_get_height(s->ds)) {
         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;
+            s->g_width = ds_get_width(s->ds);
+            s->g_height = ds_get_height(s->ds);
             text_console_resize(s);
         }
     }
@@ -1302,8 +1302,8 @@
     s->total_height = DEFAULT_BACKSCROLL;
     s->x = 0;
     s->y = 0;
-    width = s->ds->width;
-    height = s->ds->height;
+    width = ds_get_width(s->ds);
+    height = ds_get_height(s->ds);
     if (p != 0) {
         width = strtoul(p, (char **)&p, 10);
         if (*p == 'C') {
@@ -1347,7 +1347,7 @@
 void qemu_console_resize(QEMUConsole *console, int width, int height)
 {
     if (console->g_width != width || console->g_height != height
-        || !console->ds->data) {
+        || !ds_get_data(console->ds)) {
         console->g_width = width;
         console->g_height = height;
         if (active_console == console) {

Modified: trunk/console.h
===================================================================
--- trunk/console.h     2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/console.h     2008-11-24 19:29:13 UTC (rev 5789)
@@ -114,6 +114,31 @@
         s->dpy_text_cursor(s, x, y);
 }
 
+static inline int ds_get_linesize(DisplayState *ds)
+{
+    return ds->linesize;
+}
+
+static inline uint8_t* ds_get_data(DisplayState *ds)
+{
+    return ds->data;
+}
+
+static inline int ds_get_width(DisplayState *ds)
+{
+    return ds->width;
+}
+
+static inline int ds_get_height(DisplayState *ds)
+{
+    return ds->height;
+}
+
+static inline int ds_get_bits_per_pixel(DisplayState *ds)
+{
+    return ds->depth;
+}
+
 typedef unsigned long console_ch_t;
 static inline void console_write_ch(console_ch_t *dest, uint32_t ch)
 {

Modified: trunk/hw/blizzard.c
===================================================================
--- trunk/hw/blizzard.c 2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/blizzard.c 2008-11-24 19:29:13 UTC (rev 5789)
@@ -166,7 +166,7 @@
         s->my[1] = s->data.y + s->data.dy;
 
     bypp[0] = s->bpp;
-    bypp[1] = (s->state->depth + 7) >> 3;
+    bypp[1] = (ds_get_bits_per_pixel(s->state) + 7) >> 3;
     bypl[0] = bypp[0] * s->data.pitch;
     bypl[1] = bypp[1] * s->x;
     bypl[2] = bypp[0] * s->data.dx;
@@ -895,7 +895,7 @@
     if (!s->enable)
         return;
 
-    if (s->x != s->state->width || s->y != s->state->height) {
+    if (s->x != ds_get_width(s->state) || s->y != ds_get_height(s->state)) {
         s->invalidate = 1;
         qemu_console_resize(s->console, s->x, s->y);
     }
@@ -904,8 +904,8 @@
         s->invalidate = 0;
 
         if (s->blank) {
-            bypp = (s->state->depth + 7) >> 3;
-            memset(s->state->data, 0, bypp * s->x * s->y);
+            bypp = (ds_get_bits_per_pixel(s->state) + 7) >> 3;
+            memset(ds_get_data(s->state), 0, bypp * s->x * s->y);
             return;
         }
 
@@ -918,12 +918,12 @@
     if (s->mx[1] <= s->mx[0])
         return;
 
-    bypp = (s->state->depth + 7) >> 3;
+    bypp = (ds_get_bits_per_pixel(s->state) + 7) >> 3;
     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];
-    dst = s->state->data + bypl * y + bypp * s->mx[0];
+    dst = ds_get_data(s->state) + bypl * y + bypp * s->mx[0];
     for (; y < s->my[1]; y ++, src += bypl, dst += bypl)
         memcpy(dst, src, bwidth);
 
@@ -940,8 +940,8 @@
     struct blizzard_s *s = (struct blizzard_s *) opaque;
 
     blizzard_update_display(opaque);
-    if (s && s->state->data)
-        ppm_save(filename, s->state->data, s->x, s->y, s->state->linesize);
+    if (s && ds_get_data(s->state))
+        ppm_save(filename, ds_get_data(s->state), s->x, s->y, 
ds_get_linesize(s->state));
 }
 
 #define DEPTH 8
@@ -962,7 +962,7 @@
     s->state = ds;
     s->fb = qemu_malloc(0x180000);
 
-    switch (s->state->depth) {
+    switch (ds_get_bits_per_pixel(s->state)) {
     case 0:
         s->line_fn_tab[0] = s->line_fn_tab[1] =
                 qemu_mallocz(sizeof(blizzard_fn_t) * 0x10);

Modified: trunk/hw/cirrus_vga.c
===================================================================
--- trunk/hw/cirrus_vga.c       2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/cirrus_vga.c       2008-11-24 19:29:13 UTC (rev 5789)
@@ -2321,9 +2321,9 @@
     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]));
-    bpp = ((s->ds->depth + 7) >> 3);
+    bpp = ((ds_get_bits_per_pixel(s->ds) + 7) >> 3);
     d1 += x1 * bpp;
-    switch(s->ds->depth) {
+    switch(ds_get_bits_per_pixel(s->ds)) {
     default:
         break;
     case 8:

Modified: trunk/hw/g364fb.c
===================================================================
--- trunk/hw/g364fb.c   2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/g364fb.c   2008-11-24 19:29:13 UTC (rev 5789)
@@ -72,7 +72,7 @@
 
 static void g364fb_draw_graphic(G364State *s, int full_update)
 {
-    switch (s->ds->depth) {
+    switch (ds_get_bits_per_pixel(s->ds)) {
         case 8:
             g364fb_draw_graphic8(s, full_update);
             break;
@@ -86,7 +86,7 @@
             g364fb_draw_graphic32(s, full_update);
             break;
         default:
-            printf("g364fb: unknown depth %d\n", s->ds->depth);
+            printf("g364fb: unknown depth %d\n", ds_get_bits_per_pixel(s->ds));
             return;
     }
 
@@ -101,11 +101,11 @@
     if (!full_update)
         return;
 
-    w = s->scr_width * ((s->ds->depth + 7) >> 3);
-    d = s->ds->data;
+    w = s->scr_width * ((ds_get_bits_per_pixel(s->ds) + 7) >> 3);
+    d = ds_get_data(s->ds);
     for(i = 0; i < s->scr_height; i++) {
         memset(d, 0, w);
-        d += s->ds->linesize;
+        d += ds_get_linesize(s->ds);
     }
 
     dpy_update(s->ds, 0, 0, s->scr_width, s->scr_height);
@@ -131,7 +131,7 @@
         s->graphic_mode = graphic_mode;
         full_update = 1;
     }
-    if (s->scr_width != s->ds->width || s->scr_height != s->ds->height) {
+    if (s->scr_width != ds_get_width(s->ds) || s->scr_height != 
ds_get_height(s->ds)) {
         qemu_console_resize(s->console, s->scr_width, s->scr_height);
         full_update = 1;
     }

Modified: trunk/hw/g364fb_template.h
===================================================================
--- trunk/hw/g364fb_template.h  2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/g364fb_template.h  2008-11-24 19:29:13 UTC (rev 5789)
@@ -28,7 +28,7 @@
 
     data_buffer = s->vram_buffer;
     w_display = s->scr_width * PIXEL_WIDTH / 8;
-    data_display = s->ds->data;
+    data_display = ds_get_data(s->ds);
     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++) {
@@ -38,6 +38,6 @@
                 s->palette[index][1],
                 s->palette[index][2]);
         }
-        data_display += s->ds->linesize;
+        data_display += ds_get_linesize(s->ds);
     }
 }

Modified: trunk/hw/jazz_led.c
===================================================================
--- trunk/hw/jazz_led.c 2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/jazz_led.c 2008-11-24 19:29:13 UTC (rev 5789)
@@ -155,8 +155,8 @@
     uint8_t *d;
     int x, bpp;
 
-    bpp = (ds->depth + 7) >> 3;
-    d = ds->data + ds->linesize * posy + bpp * posx1;
+    bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
+    d = ds_get_data(ds) + ds_get_linesize(ds) * posy + bpp * posx1;
     switch(bpp) {
         case 1:
             for (x = posx1; x <= posx2; x++) {
@@ -184,25 +184,25 @@
     uint8_t *d;
     int y, bpp;
 
-    bpp = (ds->depth + 7) >> 3;
-    d = ds->data + ds->linesize * posy1 + bpp * posx;
+    bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
+    d = ds_get_data(ds) + ds_get_linesize(ds) * posy1 + bpp * posx;
     switch(bpp) {
         case 1:
             for (y = posy1; y <= posy2; y++) {
                 *((uint8_t *)d) = color;
-                d += ds->linesize;
+                d += ds_get_linesize(ds);
             }
             break;
         case 2:
             for (y = posy1; y <= posy2; y++) {
                 *((uint16_t *)d) = color;
-                d += ds->linesize;
+                d += ds_get_linesize(ds);
             }
             break;
         case 4:
             for (y = posy1; y <= posy2; y++) {
                 *((uint32_t *)d) = color;
-                d += ds->linesize;
+                d += ds_get_linesize(ds);
             }
             break;
     }
@@ -218,17 +218,17 @@
 
     if (s->state & REDRAW_BACKGROUND) {
         /* clear screen */
-        bpp = (ds->depth + 7) >> 3;
-        d1 = ds->data;
-        for (y = 0; y < ds->height; y++) {
-            memset(d1, 0x00, ds->width * bpp);
-            d1 += ds->linesize;
+        bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
+        d1 = ds_get_data(ds);
+        for (y = 0; y < ds_get_height(ds); y++) {
+            memset(d1, 0x00, ds_get_width(ds) * bpp);
+            d1 += ds_get_linesize(ds);
         }
     }
 
     if (s->state & REDRAW_SEGMENTS) {
         /* set colors according to bpp */
-        switch (ds->depth) {
+        switch (ds_get_bits_per_pixel(ds)) {
             case 8:
                 color_segment = rgb_to_pixel8(0xaa, 0xaa, 0xaa);
                 color_led = rgb_to_pixel8(0x00, 0xff, 0x00);
@@ -272,7 +272,7 @@
     }
 
     s->state = REDRAW_NONE;
-    dpy_update(ds, 0, 0, ds->width, ds->height);
+    dpy_update(ds, 0, 0, ds_get_width(ds), ds_get_height(ds));
 }
 
 static void jazz_led_invalidate_display(void *opaque)

Modified: trunk/hw/musicpal.c
===================================================================
--- trunk/hw/musicpal.c 2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/musicpal.c 2008-11-24 19:29:13 UTC (rev 5789)
@@ -801,7 +801,7 @@
         (musicpal_lcd_state *s, int x, int y, type col) \
 { \
     int dx, dy; \
-    type *pixel = &((type *) s->ds->data)[(y * 128 * 3 + x) * 3]; \
+    type *pixel = &((type *) ds_get_data(s->ds))[(y * 128 * 3 + x) * 3]; \
 \
     for (dy = 0; dy < 3; dy++, pixel += 127 * 3) \
         for (dx = 0; dx < 3; dx++, pixel++) \
@@ -818,7 +818,7 @@
     musicpal_lcd_state *s = opaque;
     int x, y, col;
 
-    switch (s->ds->depth) {
+    switch (ds_get_bits_per_pixel(s->ds)) {
     case 0:
         return;
 #define LCD_REFRESH(depth, func) \
@@ -838,7 +838,7 @@
     LCD_REFRESH(32, (s->ds->bgr ? rgb_to_pixel32bgr : rgb_to_pixel32))
     default:
         cpu_abort(cpu_single_env, "unsupported colour depth %i\n",
-                  s->ds->depth);
+                  ds_get_bits_per_pixel(s->ds));
     }
 
     dpy_update(s->ds, 0, 0, 128*3, 64*3);

Modified: trunk/hw/omap_lcdc.c
===================================================================
--- trunk/hw/omap_lcdc.c        2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/omap_lcdc.c        2008-11-24 19:29:13 UTC (rev 5789)
@@ -125,7 +125,7 @@
     uint8_t *s, *d;
 
     if (!omap_lcd || omap_lcd->plm == 1 ||
-                    !omap_lcd->enable || !omap_lcd->state->depth)
+                    !omap_lcd->enable || 
!ds_get_bits_per_pixel(omap_lcd->state))
         return;
 
     frame_offset = 0;
@@ -145,25 +145,25 @@
     /* Colour depth */
     switch ((omap_lcd->palette[0] >> 12) & 7) {
     case 1:
-        draw_line = draw_line_table2[omap_lcd->state->depth];
+        draw_line = draw_line_table2[ds_get_bits_per_pixel(omap_lcd->state)];
         bpp = 2;
         break;
 
     case 2:
-        draw_line = draw_line_table4[omap_lcd->state->depth];
+        draw_line = draw_line_table4[ds_get_bits_per_pixel(omap_lcd->state)];
         bpp = 4;
         break;
 
     case 3:
-        draw_line = draw_line_table8[omap_lcd->state->depth];
+        draw_line = draw_line_table8[ds_get_bits_per_pixel(omap_lcd->state)];
         bpp = 8;
         break;
 
     case 4 ... 7:
         if (!omap_lcd->tft)
-            draw_line = draw_line_table12[omap_lcd->state->depth];
+            draw_line = 
draw_line_table12[ds_get_bits_per_pixel(omap_lcd->state)];
         else
-            draw_line = draw_line_table16[omap_lcd->state->depth];
+            draw_line = 
draw_line_table16[ds_get_bits_per_pixel(omap_lcd->state)];
         bpp = 16;
         break;
 
@@ -174,8 +174,8 @@
 
     /* Resolution */
     width = omap_lcd->width;
-    if (width != omap_lcd->state->width ||
-            omap_lcd->height != omap_lcd->state->height) {
+    if (width != ds_get_width(omap_lcd->state) ||
+            omap_lcd->height != ds_get_height(omap_lcd->state)) {
         qemu_console_resize(omap_lcd->console,
                             omap_lcd->width, omap_lcd->height);
         omap_lcd->invalidate = 1;
@@ -202,7 +202,7 @@
     if (omap_lcd->dma->dual)
         omap_lcd->dma->current_frame ^= 1;
 
-    if (!omap_lcd->state->depth)
+    if (!ds_get_bits_per_pixel(omap_lcd->state))
         return;
 
     line = 0;
@@ -217,8 +217,8 @@
     step = width * bpp >> 3;
     scanline = frame_base + step * line;
     s = (uint8_t *) (phys_ram_base + scanline);
-    d = omap_lcd->state->data;
-    linesize = omap_lcd->state->linesize;
+    d = ds_get_data(omap_lcd->state);
+    linesize = ds_get_linesize(omap_lcd->state);
 
     dirty[0] = dirty[1] =
             cpu_physical_memory_get_dirty(scanline, VGA_DIRTY_FLAG);
@@ -293,10 +293,10 @@
 static void omap_screen_dump(void *opaque, const char *filename) {
     struct omap_lcd_panel_s *omap_lcd = opaque;
     omap_update_display(opaque);
-    if (omap_lcd && omap_lcd->state->data)
-        ppm_save(filename, omap_lcd->state->data,
+    if (omap_lcd && ds_get_data(omap_lcd->state))
+        ppm_save(filename, ds_get_data(omap_lcd->state),
                 omap_lcd->width, omap_lcd->height,
-                omap_lcd->state->linesize);
+                ds_get_linesize(omap_lcd->state));
 }
 
 static void omap_invalidate_display(void *opaque) {

Modified: trunk/hw/pl110.c
===================================================================
--- trunk/hw/pl110.c    2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/pl110.c    2008-11-24 19:29:13 UTC (rev 5789)
@@ -124,7 +124,7 @@
     if (!pl110_enabled(s))
         return;
 
-    switch (s->ds->depth) {
+    switch (ds_get_bits_per_pixel(s->ds)) {
     case 0:
         return;
     case 8:
@@ -190,7 +190,7 @@
     if (base > 0x80000000)
         base -= 0x80000000;
     src = phys_ram_base + base;
-    dest = s->ds->data;
+    dest = ds_get_data(s->ds);
     first = -1;
     addr = base;
 
@@ -249,7 +249,7 @@
         b = (raw & 0x1f) << 3;
         /* The I bit is ignored.  */
         raw >>= 6;
-        switch (s->ds->depth) {
+        switch (ds_get_bits_per_pixel(s->ds)) {
         case 8:
             s->pallette[n] = rgb_to_pixel8(r, g, b);
             break;

Modified: trunk/hw/pxa2xx_lcd.c
===================================================================
--- trunk/hw/pxa2xx_lcd.c       2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/pxa2xx_lcd.c       2008-11-24 19:29:13 UTC (rev 5789)
@@ -650,7 +650,7 @@
             }
             break;
         }
-        switch (s->ds->depth) {
+        switch (ds_get_bits_per_pixel(s->ds)) {
         case 8:
             *dest = rgb_to_pixel8(r, g, b) | alpha;
             break;
@@ -693,7 +693,7 @@
     else if (s->bpp > pxa_lcdc_8bpp)
         src_width *= 2;
 
-    dest = s->ds->data;
+    dest = ds_get_data(s->ds);
     dest_width = s->xres * s->dest_width;
 
     addr = (ram_addr_t) (fb - phys_ram_base);
@@ -750,7 +750,7 @@
         src_width *= 2;
 
     dest_width = s->yres * s->dest_width;
-    dest = s->ds->data + dest_width * (s->xres - 1);
+    dest = ds_get_data(s->ds) + dest_width * (s->xres - 1);
 
     addr = (ram_addr_t) (fb - phys_ram_base);
     start = addr + s->yres * src_width;
@@ -1006,7 +1006,7 @@
                                       pxa2xx_invalidate_display,
                                       pxa2xx_screen_dump, NULL, s);
 
-    switch (s->ds->depth) {
+    switch (ds_get_bits_per_pixel(s->ds)) {
     case 0:
         s->dest_width = 0;
         break;

Modified: trunk/hw/ssd0303.c
===================================================================
--- trunk/hw/ssd0303.c  2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/ssd0303.c  2008-11-24 19:29:13 UTC (rev 5789)
@@ -206,7 +206,7 @@
     if (!s->redraw)
         return;
 
-    switch (s->ds->depth) {
+    switch (ds_get_bits_per_pixel(s->ds)) {
     case 0:
         return;
     case 15:
@@ -238,7 +238,7 @@
         colors[0] = colortab + dest_width;
         colors[1] = colortab;
     }
-    dest = s->ds->data;
+    dest = ds_get_data(s->ds);
     for (y = 0; y < 16; y++) {
         line = (y + s->start_line) & 63;
         src = s->framebuffer + 132 * (line >> 3) + 36;

Modified: trunk/hw/ssd0323.c
===================================================================
--- trunk/hw/ssd0323.c  2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/ssd0323.c  2008-11-24 19:29:13 UTC (rev 5789)
@@ -187,7 +187,7 @@
     if (!s->redraw)
         return;
 
-    switch (s->ds->depth) {
+    switch (ds_get_bits_per_pixel(s->ds)) {
     case 0:
         return;
     case 15:
@@ -210,7 +210,7 @@
     for (i = 0; i < 16; i++) {
         int n;
         colors[i] = p;
-        switch (s->ds->depth) {
+        switch (ds_get_bits_per_pixel(s->ds)) {
         case 15:
             n = i * 2 + (i >> 3);
             p[0] = n | (n << 5);
@@ -233,7 +233,7 @@
         p += dest_width;
     }
     /* TODO: Implement row/column remapping.  */
-    dest = s->ds->data;
+    dest = ds_get_data(s->ds);
     for (y = 0; y < 64; y++) {
         line = y;
         src = s->framebuffer + 64 * line;

Modified: trunk/hw/tc6393xb.c
===================================================================
--- trunk/hw/tc6393xb.c 2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/tc6393xb.c 2008-11-24 19:29:13 UTC (rev 5789)
@@ -430,7 +430,7 @@
 
 static void tc6393xb_draw_graphic(struct tc6393xb_s *s, int full_update)
 {
-    switch (s->ds->depth) {
+    switch (ds_get_bits_per_pixel(s->ds)) {
         case 8:
             tc6393xb_draw_graphic8(s);
             break;
@@ -447,7 +447,7 @@
             tc6393xb_draw_graphic32(s);
             break;
         default:
-            printf("tc6393xb: unknown depth %d\n", s->ds->depth);
+            printf("tc6393xb: unknown depth %d\n", 
ds_get_bits_per_pixel(s->ds));
             return;
     }
 
@@ -462,11 +462,11 @@
     if (!full_update)
         return;
 
-    w = s->scr_width * ((s->ds->depth + 7) >> 3);
-    d = s->ds->data;
+    w = s->scr_width * ((ds_get_bits_per_pixel(s->ds) + 7) >> 3);
+    d = ds_get_data(s->ds);
     for(i = 0; i < s->scr_height; i++) {
         memset(d, 0, w);
-        d += s->ds->linesize;
+        d += ds_get_linesize(s->ds);
     }
 
     dpy_update(s->ds, 0, 0, s->scr_width, s->scr_height);
@@ -485,7 +485,7 @@
         s->blanked = s->blank;
         full_update = 1;
     }
-    if (s->scr_width != s->ds->width || s->scr_height != s->ds->height) {
+    if (s->scr_width != ds_get_width(s->ds) || s->scr_height != 
ds_get_height(s->ds)) {
         qemu_console_resize(s->console, s->scr_width, s->scr_height);
         full_update = 1;
     }

Modified: trunk/hw/tc6393xb_template.h
===================================================================
--- trunk/hw/tc6393xb_template.h        2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/tc6393xb_template.h        2008-11-24 19:29:13 UTC (rev 5789)
@@ -46,12 +46,12 @@
 
     data_buffer = (uint16_t*)(phys_ram_base + s->vram_addr);
     w_display = s->scr_width * BITS / 8;
-    data_display = s->ds->data;
+    data_display = ds_get_data(s->ds);
     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;
-        data_display += s->ds->linesize;
+        data_display += ds_get_linesize(s->ds);
 #else
         int j;
         for (j = 0; j < s->scr_width; j++, data_display += BITS / 8, 
data_buffer++) {

Modified: trunk/hw/tcx.c
===================================================================
--- trunk/hw/tcx.c      2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/tcx.c      2008-11-24 19:29:13 UTC (rev 5789)
@@ -55,7 +55,7 @@
 {
     int i;
     for(i = start; i < end; i++) {
-        switch(s->ds->depth) {
+        switch(ds_get_bits_per_pixel(s->ds)) {
         default:
         case 8:
             s->palette[i] = rgb_to_pixel8(s->r[i], s->g[i], s->b[i]);
@@ -200,18 +200,18 @@
     uint8_t *d, *s;
     void (*f)(TCXState *s1, uint8_t *dst, const uint8_t *src, int width);
 
-    if (ts->ds->depth == 0)
+    if (ds_get_bits_per_pixel(ts->ds) == 0)
         return;
     page = ts->vram_offset;
     y_start = -1;
     page_min = 0xffffffff;
     page_max = 0;
-    d = ts->ds->data;
+    d = ds_get_data(ts->ds);
     s = ts->vram;
-    dd = ts->ds->linesize;
+    dd = ds_get_linesize(ts->ds);
     ds = 1024;
 
-    switch (ts->ds->depth) {
+    switch (ds_get_bits_per_pixel(ts->ds)) {
     case 32:
         f = tcx_draw_line32;
         break;
@@ -278,7 +278,7 @@
     uint8_t *d, *s;
     uint32_t *cptr, *s24;
 
-    if (ts->ds->depth != 32)
+    if (ds_get_bits_per_pixel(ts->ds) != 32)
             return;
     page = ts->vram_offset;
     page24 = ts->vram24_offset;
@@ -286,11 +286,11 @@
     y_start = -1;
     page_min = 0xffffffff;
     page_max = 0;
-    d = ts->ds->data;
+    d = ds_get_data(ts->ds);
     s = ts->vram;
     s24 = ts->vram24;
     cptr = ts->cplane;
-    dd = ts->ds->linesize;
+    dd = ds_get_linesize(ts->ds);
     ds = 1024;
 
     for(y = 0; y < ts->height; y += 4, page += TARGET_PAGE_SIZE,

Modified: trunk/hw/vga.c
===================================================================
--- trunk/hw/vga.c      2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/vga.c      2008-11-24 19:29:13 UTC (rev 5789)
@@ -1151,7 +1151,7 @@
 
 static inline int get_depth_index(DisplayState *s)
 {
-    switch(s->depth) {
+    switch(ds_get_bits_per_pixel(s)) {
     default:
     case 8:
         return 0;
@@ -1279,7 +1279,7 @@
         cw = 9;
     if (s->sr[1] & 0x08)
         cw = 16; /* NOTE: no 18 pixel wide */
-    x_incr = cw * ((s->ds->depth + 7) >> 3);
+    x_incr = cw * ((ds_get_bits_per_pixel(s->ds) + 7) >> 3);
     width = (s->cr[0x01] + 1);
     if (s->cr[0x06] == 100) {
         /* ugly hack for CGA 160x100x16 - explain me the logic */
@@ -1329,8 +1329,8 @@
         vga_draw_glyph8 = vga_draw_glyph8_table[depth_index];
     vga_draw_glyph9 = vga_draw_glyph9_table[depth_index];
 
-    dest = s->ds->data;
-    linesize = s->ds->linesize;
+    dest = ds_get_data(s->ds);
+    linesize = ds_get_linesize(s->ds);
     ch_attr_ptr = s->last_ch_attr;
     for(cy = 0; cy < height; cy++) {
         d1 = dest;
@@ -1663,8 +1663,8 @@
     y_start = -1;
     page_min = 0x7fffffff;
     page_max = -1;
-    d = s->ds->data;
-    linesize = s->ds->linesize;
+    d = ds_get_data(s->ds);
+    linesize = ds_get_linesize(s->ds);
     y1 = 0;
     for(y = 0; y < height; y++) {
         addr = addr1;
@@ -1743,15 +1743,15 @@
         return;
     if (s->last_scr_width <= 0 || s->last_scr_height <= 0)
         return;
-    if (s->ds->depth == 8)
+    if (ds_get_bits_per_pixel(s->ds) == 8)
         val = s->rgb_to_pixel(0, 0, 0);
     else
         val = 0;
-    w = s->last_scr_width * ((s->ds->depth + 7) >> 3);
-    d = s->ds->data;
+    w = s->last_scr_width * ((ds_get_bits_per_pixel(s->ds) + 7) >> 3);
+    d = ds_get_data(s->ds);
     for(i = 0; i < s->last_scr_height; i++) {
         memset(d, val, w);
-        d += s->ds->linesize;
+        d += ds_get_linesize(s->ds);
     }
     dpy_update(s->ds, 0, 0,
                s->last_scr_width, s->last_scr_height);
@@ -1766,7 +1766,7 @@
     VGAState *s = (VGAState *)opaque;
     int full_update, graphic_mode;
 
-    if (s->ds->depth == 0) {
+    if (ds_get_bits_per_pixel(s->ds) == 0) {
         /* nothing to do */
     } else {
         s->rgb_to_pixel =
@@ -2455,10 +2455,10 @@
     s->graphic_mode = -1;
     vga_update_display(s);
 
-    if (ds->data) {
-        ppm_save(filename, ds->data, vga_save_w, vga_save_h,
-                 s->ds->linesize);
-        qemu_free(ds->data);
+    if (ds_get_data(ds)) {
+        ppm_save(filename, ds_get_data(ds), vga_save_w, vga_save_h,
+                 ds_get_linesize(s->ds));
+        qemu_free(ds_get_data(ds));
     }
     s->ds = saved_ds;
 }

Modified: trunk/hw/vmware_vga.c
===================================================================
--- trunk/hw/vmware_vga.c       2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/hw/vmware_vga.c       2008-11-24 19:29:13 UTC (rev 5789)
@@ -319,7 +319,7 @@
     width = s->bypp * w;
     start = s->bypp * x + bypl * y;
     src = s->vram + start;
-    dst = s->ds->data + start;
+    dst = ds_get_data(s->ds) + start;
 
     for (; line > 0; line --, src += bypl, dst += bypl)
         memcpy(dst, src, width);
@@ -331,7 +331,7 @@
 static inline void vmsvga_update_screen(struct vmsvga_state_s *s)
 {
 #ifndef DIRECT_VRAM
-    memcpy(s->ds->data, s->vram, s->bypp * s->width * s->height);
+    memcpy(ds_get_data(s->ds), s->vram, s->bypp * s->width * s->height);
 #endif
 
     dpy_update(s->ds, 0, 0, s->width, s->height);
@@ -373,7 +373,7 @@
                 int x0, int y0, int x1, int y1, int w, int h)
 {
 # ifdef DIRECT_VRAM
-    uint8_t *vram = s->ds->data;
+    uint8_t *vram = ds_get_data(s->ds);
 # else
     uint8_t *vram = s->vram;
 # endif
@@ -410,7 +410,7 @@
                 uint32_t c, int x, int y, int w, int h)
 {
 # ifdef DIRECT_VRAM
-    uint8_t *vram = s->ds->data;
+    uint8_t *vram = ds_get_data(s->ds);
 # else
     uint8_t *vram = s->vram;
 # endif
@@ -915,7 +915,7 @@
     s->width = -1;
     s->height = -1;
     s->svgaid = SVGA_ID;
-    s->depth = s->ds->depth ? s->ds->depth : 24;
+    s->depth = ds_get_bits_per_pixel(s->ds) ? ds_get_bits_per_pixel(s->ds) : 
24;
     s->bypp = (s->depth + 7) >> 3;
     s->cursor.on = 0;
     s->redraw_fifo_first = 0;
@@ -976,7 +976,7 @@
     }
 
     if (s->depth == 32) {
-        ppm_save(filename, s->vram, s->width, s->height, s->ds->linesize);
+        ppm_save(filename, s->vram, s->width, s->height, 
ds_get_linesize(s->ds));
     }
 }
 
@@ -994,7 +994,7 @@
     struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;
     addr -= s->vram_base;
     if (addr < s->fb_size)
-        return *(uint8_t *) (s->ds->data + addr);
+        return *(uint8_t *) (ds_get_data(s->ds) + addr);
     else
         return *(uint8_t *) (s->vram + addr);
 }
@@ -1004,7 +1004,7 @@
     struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;
     addr -= s->vram_base;
     if (addr < s->fb_size)
-        return *(uint16_t *) (s->ds->data + addr);
+        return *(uint16_t *) (ds_get_data(s->ds) + addr);
     else
         return *(uint16_t *) (s->vram + addr);
 }
@@ -1014,7 +1014,7 @@
     struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;
     addr -= s->vram_base;
     if (addr < s->fb_size)
-        return *(uint32_t *) (s->ds->data + addr);
+        return *(uint32_t *) (ds_get_data(s->ds) + addr);
     else
         return *(uint32_t *) (s->vram + addr);
 }
@@ -1025,7 +1025,7 @@
     struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;
     addr -= s->vram_base;
     if (addr < s->fb_size)
-        *(uint8_t *) (s->ds->data + addr) = value;
+        *(uint8_t *) (ds_get_data(s->ds) + addr) = value;
     else
         *(uint8_t *) (s->vram + addr) = value;
 }
@@ -1036,7 +1036,7 @@
     struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;
     addr -= s->vram_base;
     if (addr < s->fb_size)
-        *(uint16_t *) (s->ds->data + addr) = value;
+        *(uint16_t *) (ds_get_data(s->ds) + addr) = value;
     else
         *(uint16_t *) (s->vram + addr) = value;
 }
@@ -1047,7 +1047,7 @@
     struct vmsvga_state_s *s = (struct vmsvga_state_s *) opaque;
     addr -= s->vram_base;
     if (addr < s->fb_size)
-        *(uint32_t *) (s->ds->data + addr) = value;
+        *(uint32_t *) (ds_get_data(s->ds) + addr) = value;
     else
         *(uint32_t *) (s->vram + addr) = value;
 }

Modified: trunk/vnc.c
===================================================================
--- trunk/vnc.c 2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/vnc.c 2008-11-24 19:29:13 UTC (rev 5789)
@@ -321,7 +321,7 @@
     }
 
     memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
-    memset(vs->old_data, 42, vs->ds->linesize * vs->ds->height);
+    memset(vs->old_data, 42, ds_get_linesize(vs->ds) * ds_get_height(vs->ds));
 }
 
 /* fastest code */
@@ -414,10 +414,10 @@
 
     vnc_framebuffer_update(vs, x, y, w, h, 0);
 
-    row = vs->ds->data + y * vs->ds->linesize + x * vs->depth;
+    row = ds_get_data(vs->ds) + y * ds_get_linesize(vs->ds) + x * vs->depth;
     for (i = 0; i < h; i++) {
        vs->write_pixels(vs, row, w * vs->depth);
-       row += vs->ds->linesize;
+       row += ds_get_linesize(vs->ds);
     }
 }
 
@@ -495,7 +495,7 @@
     uint8_t *dst_row;
     char *old_row;
     int y = 0;
-    int pitch = ds->linesize;
+    int pitch = ds_get_linesize(ds);
     VncState *vs = ds->opaque;
 
     vnc_update_client(vs);
@@ -505,11 +505,11 @@
        pitch = -pitch;
     }
 
-    src = (ds->linesize * (src_y + y) + vs->depth * src_x);
-    dst = (ds->linesize * (dst_y + y) + vs->depth * dst_x);
+    src = (ds_get_linesize(ds) * (src_y + y) + vs->depth * src_x);
+    dst = (ds_get_linesize(ds) * (dst_y + y) + vs->depth * dst_x);
 
-    src_row = ds->data + src;
-    dst_row = ds->data + dst;
+    src_row = ds_get_data(ds) + src;
+    dst_row = ds_get_data(ds) + dst;
     old_row = vs->old_data + dst;
 
     for (y = 0; y < h; y++) {
@@ -563,7 +563,7 @@
 
        /* Walk through the dirty map and eliminate tiles that
           really aren't dirty */
-       row = vs->ds->data;
+       row = ds_get_data(vs->ds);
        old_row = vs->old_data;
 
        for (y = 0; y < vs->height; y++) {
@@ -575,7 +575,7 @@
                ptr = row;
                old_ptr = (char*)old_row;
 
-               for (x = 0; x < vs->ds->width; x += 16) {
+               for (x = 0; x < ds_get_width(vs->ds); x += 16) {
                    if (memcmp(old_ptr, ptr, 16 * vs->depth) == 0) {
                        vnc_clear_bit(vs->dirty_row[y], (x / 16));
                    } else {
@@ -588,8 +588,8 @@
                }
            }
 
-           row += vs->ds->linesize;
-           old_row += vs->ds->linesize;
+           row += ds_get_linesize(vs->ds);
+           old_row += ds_get_linesize(vs->ds);
        }
 
        if (!has_dirty) {
@@ -918,7 +918,7 @@
        vnc_write_u8(vs, 0);
        vnc_write_u16(vs, 1);
        vnc_framebuffer_update(vs, absolute, 0,
-                              vs->ds->width, vs->ds->height, -257);
+                              ds_get_width(vs->ds), ds_get_height(vs->ds), 
-257);
        vnc_flush(vs);
     }
     vs->absolute = absolute;
@@ -941,8 +941,8 @@
        dz = 1;
 
     if (vs->absolute) {
-       kbd_mouse_event(x * 0x7FFF / (vs->ds->width - 1),
-                       y * 0x7FFF / (vs->ds->height - 1),
+       kbd_mouse_event(x * 0x7FFF / (ds_get_width(vs->ds) - 1),
+                       y * 0x7FFF / (ds_get_height(vs->ds) - 1),
                        dz, buttons);
     } else if (vs->has_pointer_type_change) {
        x -= 0x7FFF;
@@ -1106,25 +1106,25 @@
                                       int x_position, int y_position,
                                       int w, int h)
 {
-    if (x_position > vs->ds->width)
-        x_position = vs->ds->width;
-    if (y_position > vs->ds->height)
-        y_position = vs->ds->height;
-    if (x_position + w >= vs->ds->width)
-        w = vs->ds->width  - x_position;
-    if (y_position + h >= vs->ds->height)
-        h = vs->ds->height - y_position;
+    if (x_position > ds_get_width(vs->ds))
+        x_position = ds_get_width(vs->ds);
+    if (y_position > ds_get_height(vs->ds))
+        y_position = ds_get_height(vs->ds);
+    if (x_position + w >= ds_get_width(vs->ds))
+        w = ds_get_width(vs->ds)  - x_position;
+    if (y_position + h >= ds_get_height(vs->ds))
+        h = ds_get_height(vs->ds) - y_position;
 
     int i;
     vs->need_update = 1;
     if (!incremental) {
-       char *old_row = vs->old_data + y_position * vs->ds->linesize;
+       char *old_row = vs->old_data + y_position * ds_get_linesize(vs->ds);
 
        for (i = 0; i < h; i++) {
             vnc_set_bits(vs->dirty_row[y_position + i],
-                         (vs->ds->width / 16), VNC_DIRTY_WORDS);
-           memset(old_row, 42, vs->ds->width * vs->depth);
-           old_row += vs->ds->linesize;
+                         (ds_get_width(vs->ds) / 16), VNC_DIRTY_WORDS);
+           memset(old_row, 42, ds_get_width(vs->ds) * vs->depth);
+           old_row += ds_get_linesize(vs->ds);
        }
     }
 }
@@ -1134,7 +1134,7 @@
     vnc_write_u8(vs, 0);
     vnc_write_u8(vs, 0);
     vnc_write_u16(vs, 1);
-    vnc_framebuffer_update(vs, 0, 0, vs->ds->width, vs->ds->height, -258);
+    vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), 
ds_get_height(vs->ds), -258);
     vnc_flush(vs);
 }
 
@@ -1497,10 +1497,10 @@
     char buf[1024];
     int size;
 
-    vs->width = vs->ds->width;
-    vs->height = vs->ds->height;
-    vnc_write_u16(vs, vs->ds->width);
-    vnc_write_u16(vs, vs->ds->height);
+    vs->width = ds_get_width(vs->ds);
+    vs->height = ds_get_height(vs->ds);
+    vnc_write_u16(vs, ds_get_width(vs->ds));
+    vnc_write_u16(vs, ds_get_height(vs->ds));
 
     pixel_format_message(vs);
 
@@ -2116,7 +2116,7 @@
     vnc_write(vs, "RFB 003.008\n", 12);
     vnc_flush(vs);
     vnc_read_when(vs, protocol_version, 12);
-    memset(vs->old_data, 0, vs->ds->linesize * vs->ds->height);
+    memset(vs->old_data, 0, ds_get_linesize(vs->ds) * ds_get_height(vs->ds));
     memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
     vs->has_resize = 0;
     vs->has_hextile = 0;

Modified: trunk/vnchextile.h
===================================================================
--- trunk/vnchextile.h  2008-11-24 11:28:19 UTC (rev 5788)
+++ trunk/vnchextile.h  2008-11-24 19:29:13 UTC (rev 5789)
@@ -13,7 +13,7 @@
                                              void *last_fg_,
                                              int *has_bg, int *has_fg)
 {
-    uint8_t *row = (vs->ds->data + y * vs->ds->linesize + x * vs->depth);
+    uint8_t *row = (ds_get_data(vs->ds) + y * ds_get_linesize(vs->ds) + x * 
vs->depth);
     pixel_t *irow = (pixel_t *)row;
     int j, i;
     pixel_t *last_bg = (pixel_t *)last_bg_;
@@ -57,7 +57,7 @@
        }
        if (n_colors > 2)
            break;
-       irow += vs->ds->linesize / sizeof(pixel_t);
+       irow += ds_get_linesize(vs->ds) / sizeof(pixel_t);
     }
 
     if (n_colors > 1 && fg_count > bg_count) {
@@ -105,7 +105,7 @@
                n_data += 2;
                n_subtiles++;
            }
-           irow += vs->ds->linesize / sizeof(pixel_t);
+           irow += ds_get_linesize(vs->ds) / sizeof(pixel_t);
        }
        break;
     case 3:
@@ -161,7 +161,7 @@
                n_data += 2;
                n_subtiles++;
            }
-           irow += vs->ds->linesize / sizeof(pixel_t);
+           irow += ds_get_linesize(vs->ds) / sizeof(pixel_t);
        }
 
        /* A SubrectsColoured subtile invalidates the foreground color */
@@ -198,7 +198,7 @@
     } else {
        for (j = 0; j < h; j++) {
            vs->write_pixels(vs, row, w * vs->depth);
-           row += vs->ds->linesize;
+           row += ds_get_linesize(vs->ds);
        }
     }
 }