Changeset 7dba813 in mainline

Timestamp:

2012-11-22T09:03:39Z (12 years ago)

Author:

Petr Koupy <petr.koupy@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

ba733e83

Parents:

8e6ec6e

Message:

Resolved Ticket #485 (Desktop is slow). GUI is usable in Qemu/non-KVM as long as windows are not transparent, rotated or scaled (i.e. if user limits himself only to translation and resizing).

Location:

uspace

Files:

• drv/fb/kfb/port.c (modified) (1 diff)
• lib/draw/drawctx.c (modified) (1 diff)
• lib/draw/source.c (modified) (1 diff)
• lib/draw/source.h (modified) (1 diff)
• lib/draw/surface.c (modified) (1 diff)
• lib/draw/surface.h (modified) (1 diff)
• lib/gui/terminal.c (modified) (1 diff)
• lib/softrend/transform.c (modified) (1 diff)
• lib/softrend/transform.h (modified) (2 diffs)
• srv/hid/compositor/compositor.c (modified) (3 diffs)

uspace/drv/fb/kfb/port.c

@@ -163 +163 @@
                 /* Faster damage routine ignoring offsets. */
                 for (sysarg_t y = y0; y < height + y0; ++y) {
+                        pixel_t *pixel = pixelmap_pixel_at(map, x0, y);
                         for (sysarg_t x = x0; x < width + x0; ++x) {
-                                kfb.pixel2visual(kfb.addr + FB_POS(x, y),
-                                    *pixelmap_pixel_at(map, x, y));
+                                kfb.pixel2visual(kfb.addr + FB_POS(x, y), *pixel++);
                         }
                 }

uspace/lib/draw/drawctx.c

@@ -129 +129 @@
         }
 
-        bool clipped = false;
-        bool masked = false;
-
-        for (sysarg_t _y = y; _y < y + height; ++_y) {
-                for (sysarg_t _x = x; _x < x + width; ++_x) {
-                        if (context->shall_clip) {
-                                clipped = _x < context->clip_x && _x >= context->clip_width
-                                    && _y < context->clip_y && _y >= context->clip_height;
-                        }
-                        
-                        if (context->mask) {
-                                pixel_t p = surface_get_pixel(context->mask, _x, _y);
-                                masked = p > 0 ? false : true;
-                        }
-
-                        if (!clipped && !masked) {
-                                pixel_t p_src = source_determine_pixel(context->source, _x, _y);
-                                pixel_t p_dst = surface_get_pixel(context->surface, _x, _y);
-                                pixel_t p_res = context->compose(p_src, p_dst);
-                                surface_put_pixel(context->surface, _x, _y, p_res);
+        bool transfer_fast = source_is_fast(context->source)
+            && (context->shall_clip == false)
+            && (context->mask == NULL)
+            && (context->compose == compose_src || context->compose == compose_over);
+
+        if (transfer_fast) {
+
+                for (sysarg_t _y = y; _y < y + height; ++_y) {
+                        pixel_t *src = source_direct_access(context->source, x, _y);
+                        pixel_t *dst = pixelmap_pixel_at(surface_pixmap_access(context->surface), x, _y);
+                        if (src && dst) {
+                                sysarg_t count = width;
+                                while (count-- != 0) {
+                                        *dst++ = *src++;
+                                }
                         }
                 }
+                surface_add_damaged_region(context->surface, x, y, width, height);
+
+        } else {
+
+                bool clipped = false;
+                bool masked = false;
+                for (sysarg_t _y = y; _y < y + height; ++_y) {
+                        for (sysarg_t _x = x; _x < x + width; ++_x) {
+                                if (context->shall_clip) {
+                                        clipped = _x < context->clip_x && _x >= context->clip_width
+                                            && _y < context->clip_y && _y >= context->clip_height;
+                                }
+
+                                if (context->mask) {
+                                        pixel_t p = surface_get_pixel(context->mask, _x, _y);
+                                        masked = p > 0 ? false : true;
+                                }
+
+                                if (!clipped && !masked) {
+                                        pixel_t p_src = source_determine_pixel(context->source, _x, _y);
+                                        pixel_t p_dst = surface_get_pixel(context->surface, _x, _y);
+                                        pixel_t p_res = context->compose(p_src, p_dst);
+                                        surface_put_pixel(context->surface, _x, _y, p_res);
+                                }
+                        }
+                }
+
         }
 }

uspace/lib/draw/source.c

@@ -90 +90 @@
 }
 
+bool source_is_fast(source_t *source)
+{
+        return (source->mask == NULL)
+            && (source->alpha == (pixel_t) PIXEL(255, 0, 0, 0))
+            && (source->texture != NULL)
+            && (source->texture_tile == false)
+            && transform_is_fast(&source->transform);
+}
+
+pixel_t *source_direct_access(source_t *source, double x, double y)
+{
+        assert(source_is_fast(source));
+
+        long _x = (long) (x + source->transform.m[0][2]);
+        long _y = (long) (y + source->transform.m[1][2]);
+
+        pixelmap_t *pixmap = surface_pixmap_access(source->texture);
+        if (_x < 0 || _x >= (long) pixmap->width || _y < 0 || _y >= (long) pixmap->height) {
+                return NULL;
+        }
+
+        return pixelmap_pixel_at(pixmap, (sysarg_t) _x, (sysarg_t) _y);
+}
+
 pixel_t source_determine_pixel(source_t *source, double x, double y)
 {

uspace/lib/draw/source.h

@@ -71 +71 @@
 extern void source_set_mask(source_t *, surface_t *, bool);
 
+extern bool source_is_fast(source_t *);
+extern pixel_t *source_direct_access(source_t *, double, double);
 extern pixel_t source_determine_pixel(source_t *, double, double);
 

uspace/lib/draw/surface.c

@@ -143 +143 @@
 }
 
+void surface_add_damaged_region(surface_t *surface, surface_coord_t x, surface_coord_t y,
+    surface_coord_t width, surface_coord_t height)
+{
+        surface->dirty_x_lo = surface->dirty_x_lo > x ? x : surface->dirty_x_lo;
+        surface->dirty_y_lo = surface->dirty_y_lo > y ? y : surface->dirty_y_lo;
+
+        surface_coord_t x_hi = x + width - 1;
+        surface_coord_t y_hi = y + height - 1;
+
+        surface->dirty_x_hi = surface->dirty_x_hi < x_hi ? x_hi : surface->dirty_x_hi;
+        surface->dirty_y_hi = surface->dirty_y_hi < y_hi ? y_hi : surface->dirty_y_hi;
+}
+
 void surface_reset_damaged_region(surface_t *surface)
 {

uspace/lib/draw/surface.h

@@ -61 +61 @@
 extern void surface_get_damaged_region(surface_t *, surface_coord_t *, surface_coord_t *,
     surface_coord_t *, surface_coord_t *);
+extern void surface_add_damaged_region(surface_t *, surface_coord_t , surface_coord_t ,
+    surface_coord_t , surface_coord_t );
 extern void surface_reset_damaged_region(surface_t *);
 

uspace/lib/gui/terminal.c

@@ -196 +196 @@
         uint16_t glyph = fb_font_glyph(field->ch);
         
-        // FIXME: This font drawing routine is shamelessly
-        //        suboptimal. It should be optimized for
-        //        aligned memory transfers, etc.
-        
         for (unsigned int y = 0; y < FONT_SCANLINES; y++) {
-                for (unsigned int x = 0; x < FONT_WIDTH; x++) {
-                        pixel_t pixel =
-                            (fb_font[glyph][y] & (1 << (7 - x))) ? fgcolor : bgcolor;
-                        surface_put_pixel(surface, bx + x, by + y, pixel);
+                pixel_t *dst = pixelmap_pixel_at(
+                    surface_pixmap_access(surface), bx, by + y);
+                int count = FONT_WIDTH;
+                while (count-- != 0) {
+                        *dst++ = (fb_font[glyph][y] & (1 << count)) ? fgcolor : bgcolor;
                 }
         }
+        surface_add_damaged_region(surface, bx, by, FONT_WIDTH, FONT_SCANLINES);
 }
 

uspace/lib/softrend/transform.c

@@ -136 +136 @@
 }
 
+bool transform_is_fast(transform_t *t)
+{
+        return (t->m[0][0] == 1) && (t->m[0][1] == 0)
+            && (t->m[1][0] == 0) && (t->m[1][1] == 1)
+            && ((t->m[0][2] - ((long) t->m[0][2])) == 0.0)
+            && ((t->m[1][2] - ((long) t->m[1][2])) == 0.0);
+}
+
 void transform_apply_linear(const transform_t *t, double *x, double *y)
 {

uspace/lib/softrend/transform.h

@@ -37 +37 @@
 #define SOFTREND_TRANSFORM_H_
 
+#include <bool.h>
+
 #ifndef PI
 #define PI 3.141592653589793
@@ -53 +55 @@
 extern void transform_rotate(transform_t *, double);
 
+extern bool transform_is_fast(transform_t *);
+
 extern void transform_apply_linear(const transform_t *, double *, double *);
 extern void transform_apply_affine(const transform_t *, double *, double *);

uspace/srv/hid/compositor/compositor.c

@@ -314 +314 @@
                         /* Paint background color. */
                         for (sysarg_t y = y_dmg_vp - vp->pos.y; y <  y_dmg_vp - vp->pos.y + h_dmg_vp; ++y) {
-                                for (sysarg_t x = x_dmg_vp - vp->pos.x; x < x_dmg_vp - vp->pos.x + w_dmg_vp; ++x) {
-                                        surface_put_pixel(vp->surface, x, y, bg_color);
+                                pixel_t *dst = pixelmap_pixel_at(
+                                    surface_pixmap_access(vp->surface), x_dmg_vp - vp->pos.x, y);
+                                sysarg_t count = w_dmg_vp;
+                                while (count-- != 0) {
+                                        *dst++ = bg_color;
                                 }
                         }
+                        surface_add_damaged_region(vp->surface,
+                            x_dmg_vp - vp->pos.x, y_dmg_vp - vp->pos.y, w_dmg_vp, h_dmg_vp);
 
                         transform_t transform;
@@ -381 +386 @@
                                 if (isec_ptr) {
                                         /* Pointer is currently painted directly by copying pixels.
-                                         * However, it is possible to draw the painter similarly
+                                         * However, it is possible to draw the pointer similarly
                                          * as window by using drawctx_transfer. It would allow
                                          * more sophisticated control over drawing, but would also
                                          * cost more regarding the performance. */
 
-                                        pixel_t pix = 0;
                                         sysarg_t x_vp = x_dmg_ptr - vp->pos.x;
                                         sysarg_t y_vp = y_dmg_ptr - vp->pos.y;
@@ -393 +397 @@
 
                                         for (sysarg_t y = 0; y < h_dmg_ptr; ++y) {
-                                                for (sysarg_t x = 0; x < w_dmg_ptr; ++x) {
-                                                        pix = surface_get_pixel(sf_ptr, x_ptr + x, y_ptr + y);
-                                                        if (ALPHA(pix) == 255) {
-                                                                surface_put_pixel(vp->surface, x_vp + x, y_vp + y, pix);
-                                                        }
+                                                pixel_t *src = pixelmap_pixel_at(
+                                                    surface_pixmap_access(sf_ptr), x_ptr, y_ptr + y);
+                                                pixel_t *dst = pixelmap_pixel_at(
+                                                    surface_pixmap_access(vp->surface), x_vp, y_vp + y);
+                                                sysarg_t count = w_dmg_ptr;
+                                                while (count-- != 0) {
+                                                        *dst = (*src & 0xff000000) ? *src : *dst;
+                                                        ++dst; ++src;
                                                 }
                                         }
+                                        surface_add_damaged_region(vp->surface, x_vp, y_vp, w_dmg_ptr, h_dmg_ptr);
                                 }
                         }