X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fmodules%2Fswfrender.c;h=a9d5d077dfcc60c1b981f8ea263de95dcf8e9c18;hb=8451385a196293f2d9ce889040e649c310ee6632;hp=1cdc4987d4e4f7ae12355578166d6697e0d17ee5;hpb=46f30b047372fada7fb6044b04c1d4c2ffedd753;p=swftools.git

diff --git a/lib/modules/swfrender.c b/lib/modules/swfrender.c
index 1cdc498..a9d5d07 100644
--- a/lib/modules/swfrender.c
+++ b/lib/modules/swfrender.c
@@ -24,27 +24,17 @@
 
 #include <assert.h>
 
-typedef struct _dummyshape
-{
-    SHAPE2*shape;
-    //CXFORM //TODO
-    struct _dummyshape*next;
-} dummyshape_t;
-
 /* one bit flag: */
 #define clip_type 0
 #define fill_type 1
 
 typedef struct _renderpoint
 {
-    char type;
     float x;
     U32 depth;
 
     SHAPELINE*shapeline;
-    
-    U32 clipdepth;
-    dummyshape_t*s;
+    SHAPE2*s;
     
 } renderpoint_t;
 
@@ -73,6 +63,8 @@ typedef struct _renderpoint
 typedef struct _renderline
 {
     TAG*points; //incremented in 128 byte steps
+    int num;
+    U32 pending_clipdepth;
 } renderline_t;
 
 typedef struct _bitmap {
@@ -90,121 +82,33 @@ typedef struct _renderbuf_internal
     char antialize;
     int multiply;
     int width2,height2;
-    dummyshape_t*dshapes;
-    dummyshape_t*dshapes_next;
-    RGBA*background;
-    int background_width, background_height;
+    int shapes;
+    int ymin, ymax;
+    
+    RGBA* img;
+    int* zbuf; 
 } renderbuf_internal;
 
 #define DEBUG 0
 
-static void renderpoint_write(TAG*tag, renderpoint_t*p)
-{
-    if(tag->len == 0) {
-	swf_SetU32(tag, 1);
-    } else {
-	int num = GET32(tag->data);
-	PUT32(tag->data, num+1);
-    }
-
-    swf_SetBits(tag, p->type, 1);
-    swf_SetBits(tag, *(U32*)&p->x, 32);
-    if(p->depth & 0xffff) {
-	swf_SetBits(tag, 1, 1);
-	swf_SetBits(tag, p->depth, 32);
-    } else {
-	swf_SetBits(tag, 0, 1);
-	swf_SetBits(tag, p->depth >> 16, 16);
-    }
-    if(p->shapeline) {
-	swf_SetBits(tag, 1, 1);
-	swf_SetBits(tag, *(U32*)&p->shapeline, 32);
-    } else {
-	swf_SetBits(tag, 0, 1);
-    }
-
-    if(p->type == clip_type) {
-	//printf("type=%d x=%f, depth=%08x, shapeline=%08x, clipdepth=%08x\n", p->type, p->x, p->depth, p->shapeline, p->clipdepth);
-	assert((p->clipdepth & 0xffff) == 0xffff);
-	swf_SetBits(tag, p->clipdepth >> 16, 16);
-	/* don't set s */
-    } else {
-	//printf("type=%d x=%f, depth=%08x, shapeline=%08x, s=%08x\n", p->type, p->x, p->depth, p->shapeline, p->s);
-	swf_SetBits(tag, *(U32*)&p->s, 32);
-	/* don't set clipdepth */
-    }
-}
-static renderpoint_t renderpoint_read(TAG*tag, int num)
-{
-    renderpoint_t p;
-    U8 flag = 0;
-    U32 dummy = 0;
-
-    p.type = swf_GetBits(tag, 1);
-    
-    dummy = swf_GetBits(tag, 32);p.x = *(float*)&dummy;
-    flag = swf_GetBits(tag, 1);
-    if(flag) {
-	p.depth = swf_GetBits(tag, 32);
-    } else {
-	p.depth = swf_GetBits(tag, 16) << 16;
-    }
-    flag = swf_GetBits(tag, 1);
-    if(flag) {
-	dummy = swf_GetBits(tag, 32);p.shapeline = *(SHAPELINE**)&dummy;
-    } else {
-	p.shapeline = 0;
-    }
-
-    if(p.type == clip_type) {
-	p.clipdepth = swf_GetBits(tag, 16) << 16 | 0xffff;
-	p.s = 0;
-    } else {
-	dummy = swf_GetBits(tag, 32);p.s = *(dummyshape_t**)&dummy;
-	p.clipdepth = 0;
-    }
-
-    return p;
-}
-
-static int renderpoint_num(TAG*tag)
-{
-    if(tag->len == 0)
-	return 0;
-    return GET32(tag->data);
-}
-
-static renderpoint_t* renderpoint_readall(TAG*tag)
-{
-    int num;
-    int t;
-    renderpoint_t*p;
-    swf_SetTagPos(tag, 0);
-    if(tag->len == 0)
-	num = 0;
-    else
-	num = swf_GetU32(tag);
-    p = (renderpoint_t*)rfx_alloc(num*sizeof(renderpoint_t));
-    for(t=0;t<num;t++)
-	p[t] = renderpoint_read(tag,t);
-    return p;
-}
-
 static inline void add_pixel(RENDERBUF*dest, float x, int y, renderpoint_t*p)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
     if(x >= i->width2 || y >= i->height2 || y<0) return;
     p->x = x;
-    if(y<10)
-	renderpoint_write(i->lines[y].points, p);
-    else
-	renderpoint_write(i->lines[y].points, p);
+    if(y<i->ymin) i->ymin = y;
+    if(y>i->ymax) i->ymax = y;
+
+    i->lines[y].num++;
+    swf_SetBlock(i->lines[y].points, (U8*)p, sizeof(renderpoint_t));
 }
 
 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
    problem appears to often */
 #define CUT 0.5
 
+#define INT(x) ((int)((x)+16)-16)
+
 static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p)
 {
     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
@@ -214,6 +118,7 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2,
         int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
         printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
     }*/
+    assert(p->shapeline);
 
     y1=y1*i->multiply;
     y2=y2*i->multiply;
@@ -235,14 +140,14 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2,
     diffx = x2 - x1;
     diffy = y2 - y1;
     
-    ny1 = (int)(y1)+CUT;
-    ny2 = (int)(y2)+CUT;
+    ny1 = INT(y1)+CUT;
+    ny2 = INT(y2)+CUT;
 
     if(ny1 < y1) {
-        ny1 = (int)(y1) + 1.0 + CUT;
+        ny1 = INT(y1) + 1.0 + CUT;
     }
     if(ny2 >= y2) {
-        ny2 = (int)(y2) - 1.0 + CUT;
+        ny2 = INT(y2) - 1.0 + CUT;
     }
 
     if(ny1 > ny2)
@@ -253,8 +158,8 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2,
     x2 = x2 + (ny2-y2)*stepx;
 
     {
-	int posy=(int)ny1;
-	int endy=(int)ny2;
+	int posy=INT(ny1);
+	int endy=INT(ny2);
 	double posx=0;
 	double startx = x1;
 
@@ -386,17 +291,32 @@ void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, c
     i->width2 = antialize?2*buf->width:buf->width;
     i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
     for(y=0;y<i->height2;y++) {
+	memset(&i->lines[y], 0, sizeof(renderline_t));
         i->lines[y].points = swf_InsertTag(0, 0);
+        i->lines[y].num = 0;
     }
+    i->zbuf = (int*)rfx_calloc(sizeof(int)*i->width2*i->height2);
+    i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
+    i->shapes = 0;
+    i->ymin = 0x7fffffff;
+    i->ymax = -0x80000000;
 }
 void swf_Render_SetBackground(RENDERBUF*buf, RGBA*img, int width, int height)
 {
     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
-    RGBA*bck = (RGBA*)rfx_alloc(sizeof(RGBA)*width*height);
-    memcpy(bck, img, sizeof(RGBA)*width*height);
-    i->background = bck;
-    i->background_width = width;
-    i->background_height = height;
+    int x,xx,y,yy;
+    int xstep=width*65536/i->width2;
+    int ystep=height*65536/i->height2;
+    if(i->shapes) {
+	fprintf(stderr, "rfxswf: Warning: swf_Render_SetBackground() called after drawing shapes\n");
+    }
+    for(y=0,yy=0;y<i->height2;y++,yy+=ystep) {
+	RGBA*src = &img[(yy>>16) * width];
+	RGBA*line = &i->img[y * i->width2];
+	for(x=0,xx=0;x<i->width2;x++,xx+=xstep) {
+	    line[x] = src[xx>>16];
+	}
+    }
 }
 void swf_Render_SetBackgroundColor(RENDERBUF*buf, RGBA color)
 {
@@ -423,17 +343,18 @@ void swf_Render_ClearCanvas(RENDERBUF*dest)
     for(y=0;y<i->height2;y++) {
         swf_ClearTag(i->lines[y].points);
     }
+    memset(i->zbuf, 0, sizeof(int)*i->width2*i->height2);
+    memset(i->img, 0, sizeof(RGBA)*i->width2*i->height2);
 }
 void swf_Render_Delete(RENDERBUF*dest)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
     int y;
     bitmap_t*b = i->bitmaps;
-    dummyshape_t*d = i->dshapes;
 
-    if(i->background) {
-	free(i->background);i->background=0;
-    }
+    /* delete canvas */
+    rfx_free(i->zbuf);
+    rfx_free(i->img);
 
     /* delete line buffers */
     for(y=0;y<i->height2;y++) {
@@ -441,15 +362,6 @@ void swf_Render_Delete(RENDERBUF*dest)
         i->lines[y].points = 0;
     }
 
-    while(d) {
-        dummyshape_t*next = d->next;
-        swf_Shape2Free(d->shape);
-        free(d->shape);d->shape=0;
-        free(d);
-        d=next;
-    }
-    i->dshapes = 0;
-    
     /* delete bitmaps */
     while(b) {
         bitmap_t*next = b->next;
@@ -462,19 +374,6 @@ void swf_Render_Delete(RENDERBUF*dest)
     rfx_free(dest->internal); dest->internal = 0;
 }
 
-static void swf_Render_AddShape(RENDERBUF*dest,dummyshape_t*s)
-{
-    renderbuf_internal*i = (renderbuf_internal*)dest->internal;
-
-    s->next = 0;
-    if(i->dshapes_next)
-        i->dshapes_next->next = s;
-    i->dshapes_next = s;
-    if(!i->dshapes) {
-        i->dshapes = s;
-    }
-}
-
 static SHAPE2* linestyle2fillstyle(SHAPE2*shape)
 {
     SHAPE2*s = rfx_calloc(sizeof(SHAPE2));
@@ -490,6 +389,8 @@ static SHAPE2* linestyle2fillstyle(SHAPE2*shape)
     return s;
 }
 
+void swf_Process(RENDERBUF*dest, U32 clipdepth);
+
 void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _depth,U16 _clipdepth)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
@@ -497,31 +398,25 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
     SHAPELINE*line;
     int x=0,y=0;
     MATRIX mat = *m;
+    SHAPE2* s2 = 0;
     SHAPE2* lshape = 0;
-
-    SHAPE2* s2 = swf_Shape2Clone(shape);
-    /* add this shape to the global shape list, for deallocing */
-    dummyshape_t*fshape = rfx_calloc(sizeof(dummyshape_t));
-    fshape->shape = s2;
-    swf_Render_AddShape(dest, fshape);
-
-    line = s2->lines;
-
     renderpoint_t p, lp;
+    U32 clipdepth;
+
     memset(&p, 0, sizeof(renderpoint_t));
     memset(&lp, 0, sizeof(renderpoint_t));
     
-    p.type = _clipdepth?clip_type:fill_type;
+    clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0;
     p.depth = _depth << 16;
-    p.clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0;
 
     mat.tx -= dest->posx*20;
     mat.ty -= dest->posy*20;
-        
 
+    s2 = swf_Shape2Clone(shape);
+    line = s2->lines;
     if(shape->numfillstyles) {
         int t;
-        p.s = fshape;
+        p.s = s2;
         /* multiply fillstyles matrices with placement matrix-
            important for texture and gradient fill */
         for(t=0;t<s2->numfillstyles;t++) {
@@ -535,62 +430,33 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
             nm.ty *= i->multiply;
             s2->fillstyles[t].m = nm;
         }
-
     }
 
     if(shape->numlinestyles) {
-        dummyshape_t*dshape = rfx_calloc(sizeof(dummyshape_t));
-        
         lshape = linestyle2fillstyle(shape);
-            
-        lp.type = fill_type;
-        lp.s = dshape;
+        lp.s = lshape;
         lp.depth = (_depth << 16)+1;
-
-        dshape->shape = lshape;
-
-        /* add this shape to the global shape list, for deallocing */
-        swf_Render_AddShape(dest, dshape);
-    }
-
-    if(p.clipdepth) {
-        /* invert shape */
-        p.shapeline = 0;
-        add_line(dest, -20, 0, -20, i->height2*20, &p);
     }
 
     while(line)
     {
         int x1,y1,x2,y2,x3,y3;
 
-        p.shapeline = line;
-
         if(line->type == moveTo) {
         } else if(line->type == lineTo) {
-            if(DEBUG&4) {
-		int l;
-                x1 = x;
-                y1 = y;
-                x2 = line->x;
-                y2 = line->y;
-                l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
-                printf("%d - %.2f/%.2f -> %.2f/%.2f ", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
-            }
-
             transform_point(&mat, x, y, &x1, &y1);
             transform_point(&mat, line->x, line->y, &x3, &y3);
             
-            if(line->linestyle && ! p.clipdepth) {
+            if(line->linestyle && ! clipdepth) {
                 lp.shapeline = &lshape->lines[line->linestyle-1];
                 add_solidline(dest, x1, y1, x3, y3, shape->linestyles[line->linestyle-1].width, &lp);
                 lp.depth++;
             }
             if(line->fillstyle0 || line->fillstyle1) {
                 assert(shape->numfillstyles);
+		p.shapeline = line;
                 add_line(dest, x1, y1, x3, y3, &p);
             }
-            
-            if(DEBUG&4) printf("\n");
         } else if(line->type == splineTo) {
 	    int c,t,parts,qparts;
 	    double xx,yy;
@@ -606,58 +472,60 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
             parts = (int)(sqrt(c)/3);
             if(!parts) parts = 1;
 
-            if(DEBUG&4)
-            {
-                printf("spline %.2f/%.2f -(%.2f/%.2f)-> %.2f/%.2f (c=%d, %d parts)", 
-                        x1/20.0, y1/20.0, 
-                        x2/20.0, y2/20.0, 
-                        x3/20.0, y3/20.0, c, parts);
-            }
-
             for(t=1;t<=parts;t++) {
                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
                 
-                if(line->linestyle && ! p.clipdepth) {
+                if(line->linestyle && ! clipdepth) {
                     lp.shapeline = &lshape->lines[line->linestyle-1];
                     add_solidline(dest, xx, yy, nx, ny, shape->linestyles[line->linestyle-1].width, &lp);
                     lp.depth++;
                 }
                 if(line->fillstyle0 || line->fillstyle1) {
                     assert(shape->numfillstyles);
-                    add_line(dest, (int)xx, (int)yy, (int)nx, (int)ny, &p);
+		    p.shapeline = line;
+                    add_line(dest, xx, yy, nx, ny, &p);
                 }
 
                 xx = nx;
                 yy = ny;
             }
-            if(DEBUG&4) 
-                printf("\n");
         }
         x = line->x;
         y = line->y;
         line = line->next;
     }
-}
-
-typedef struct _layer {
-    int fillid;
-    U32 clipdepth;
-    renderpoint_t*p;
-    struct _layer*next;
-    struct _layer*prev;
-} layer_t;
+    
+    swf_Process(dest, clipdepth);
+    
+    if(s2) {
+	swf_Shape2Free(s2);rfx_free(s2);s2=0;
+    }
+    if(lshape) {
+	swf_Shape2Free(lshape);rfx_free(lshape);lshape=0;
+    }
 
-typedef struct {
-    layer_t*layers;
-} state_t;
+}
 
 static RGBA color_red = {255,255,0,0};
 static RGBA color_white = {255,255,255,255};
 
-static void fill_plain(RGBA*line, int x1, int x2, RGBA col)
+static void fill_clip(RGBA*line, int*z, int y, int x1, int x2, U32 depth)
+{
+    int x = x1;
+    if(x1>=x2)
+	return;
+    do {
+	if(depth > z[x]) {
+	    z[x] = depth;
+	}
+    } while(++x<x2);
+}
+
+static void fill_solid(RGBA*line, int*z, int y, int x1, int x2, RGBA col, U32 depth)
 {
     int x = x1;
+
     if(col.a!=255) {
         int ainv = 255-col.a;
         col.r = (col.r*col.a)>>8;
@@ -665,19 +533,25 @@ static void fill_plain(RGBA*line, int x1, int x2, RGBA col)
         col.b = (col.b*col.a)>>8;
         col.a = 255;
         do {
-            line[x].r = ((line[x].r*ainv)>>8)+col.r;
-            line[x].g = ((line[x].g*ainv)>>8)+col.g;
-            line[x].b = ((line[x].b*ainv)>>8)+col.b;
-            line[x].a = 255;
+	    if(depth >= z[x]) {
+		line[x].r = ((line[x].r*ainv)>>8)+col.r;
+		line[x].g = ((line[x].g*ainv)>>8)+col.g;
+		line[x].b = ((line[x].b*ainv)>>8)+col.b;
+		line[x].a = 255;
+		z[x] = depth;
+	    }
         } while(++x<x2);
     } else {
         do {
-            line[x] = col;
+	    if(depth >= z[x]) {
+		line[x] = col;
+		z[x] = depth;
+	    }
         } while(++x<x2);
     }
 }
 
-static void fill_bitmap(RGBA*line, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clip)
+static void fill_bitmap(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clipbitmap, U32 depth)
 {
     int x = x1;
     double m11=m->sx/65536.0, m21=m->r1/65536.0;
@@ -690,94 +564,84 @@ static void fill_bitmap(RGBA*line, int y, int x1, int x2, MATRIX*m, bitmap_t*b,
 	return;
     }
     det = 20.0/det;
- 
+    
     if(!b->width || !b->height) {
-        fill_plain(line, x1, x2, color_red);
+        fill_solid(line, z, y, x1, x2, color_red, depth);
         return;
     }
 
     do {
-	RGBA col;
-        int xx = (int)((  (x - rx) * m22 - (y - ry) * m21)*det);
-        int yy = (int)((- (x - rx) * m12 + (y - ry) * m11)*det);
-	int ainv;
-        
-        if(clip) {
-            if(xx<0) xx=0;
-            if(xx>=b->width) xx = b->width-1;
-            if(yy<0) yy=0;
-            if(yy>=b->height) yy = b->height-1;
-        } else {
-            xx %= b->width;
-            yy %= b->height;
-        }
+	if(depth >= z[x]) {
+	    RGBA col;
+	    int xx = (int)((  (x - rx) * m22 - (y - ry) * m21)*det);
+	    int yy = (int)((- (x - rx) * m12 + (y - ry) * m11)*det);
+	    int ainv;
+
+	    if(clipbitmap) {
+		if(xx<0) xx=0;
+		if(xx>=b->width) xx = b->width-1;
+		if(yy<0) yy=0;
+		if(yy>=b->height) yy = b->height-1;
+	    } else {
+		xx %= b->width;
+		yy %= b->height;
+	    }
 
-        col = b->data[yy*b->width+xx];
-        ainv = 255-col.a;
+	    col = b->data[yy*b->width+xx];
+	    ainv = 255-col.a;
 
-        line[x].r = ((line[x].r*ainv)>>8)+col.r;
-        line[x].g = ((line[x].g*ainv)>>8)+col.g;
-        line[x].b = ((line[x].b*ainv)>>8)+col.b;
-        line[x].a = 255;
+	    line[x].r = ((line[x].r*ainv)>>8)+col.r;
+	    line[x].g = ((line[x].g*ainv)>>8)+col.g;
+	    line[x].b = ((line[x].b*ainv)>>8)+col.b;
+	    line[x].a = 255;
+	    
+	    z[x] = depth;
+	}
     } while(++x<x2);
 }
 
-static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*clipstate, state_t*fillstate)
+typedef struct _layer {
+    int fillid;
+    renderpoint_t*p;
+    struct _layer*next;
+    struct _layer*prev;
+} layer_t;
+
+typedef struct {
+    layer_t*layers;
+} state_t;
+
+
+static void fill(RENDERBUF*dest, RGBA*line, int*zline, int y, int x1, int x2, state_t*fillstate, U32 clipdepth)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
-    U32 clipdepth;
+    int clip=1;
 
-    layer_t*lc = clipstate->layers;
-    layer_t*lf = fillstate->layers;
-    layer_t*l = 0;
+    layer_t*l = fillstate->layers;
 
     if(x1>=x2) //zero width? nothing to do.
         return;
     
-    clipdepth = 0;
-    while(lf) {
-	if(lc && (!lf || lc->p->depth < lf->p->depth)) {
-	    l = lc;
-	    lc = lc->next;
-	} else if(lf && (!lc || lf->p->depth < lc->p->depth)) {
-	    l = lf;
-	    lf = lf->next;
-	} else if(lf && lc && lf->p->depth == lc->p->depth) {
-	    /* A clipshape and a fillshape at the same depth. Yuck.
-	       Bug in the SWF file */
-	    fprintf(stderr, "Error: Multiple use of depth %d in SWF\n", lf->p->depth);
-	    l = lc;
-	    lc = lc->next;
-	} else {
-	    fprintf(stderr, "Internal error: %08x %08x\n", lc, lf);
-	    if(lc) fprintf(stderr, "                lc->depth = %08x\n", lc->p->depth);
-	    if(lf) fprintf(stderr, "                lf->depth = %08x\n", lf->p->depth);
-	}
-
-        if(l->p->depth <= clipdepth) {
-            if(DEBUG&2) printf("(clipped)");
-	    continue;
-        }
-        if(l->fillid < 0 /*clip*/) {
-            if(DEBUG&2) printf("(add clip %d)", l->clipdepth);
-            if(l->clipdepth > clipdepth)
-                clipdepth = l->clipdepth;
-        } else if(l->fillid == 0) {
+    while(l) {
+        if(l->fillid == 0) {
             /* not filled. TODO: we should never add those in the first place */
             if(DEBUG&2)
                 printf("(not filled)");
-        } else if(l->fillid > l->p->s->shape->numfillstyles) {
-            fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->s->shape->numlinestyles);
-        } else {
+        } else if(l->fillid > l->p->s->numfillstyles) {
+            fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->s->numlinestyles);
+        } else if(clipdepth) {
+	    /* filled region- not used for clipping */
+	    clip = 0;
+	} else {
             FILLSTYLE*f;
             if(DEBUG&2) 
                 printf("(%d -> %d style %d)", x1, x2, l->fillid);
 
-            f = &l->p->s->shape->fillstyles[l->fillid-1];
+            f = &l->p->s->fillstyles[l->fillid-1];
 
-            if(f->type == FILL_SOLID) {
+	    if(f->type == FILL_SOLID) {
                 /* plain color fill */
-                fill_plain(line, x1, x2, f->color);
+                fill_solid(line, zline, y, x1, x2, f->color, l->p->depth);
             } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) {
                 /* TODO: optimize (do this in add_pixel()?) */
                 bitmap_t* b = i->bitmaps;
@@ -786,22 +650,18 @@ static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*clips
                 }
                 if(!b) {
                     fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap);
-                    fill_plain(line, x1, x2, color_red);
+                    fill_solid(line, zline, y, x1, x2, color_red, l->p->depth);
                 } else {
-                    //done in swf_RenderShape now
-                    //MATRIX m = f->m;
-                    //m.tx -= dest->posx*20;
-                    //m.ty -= dest->posy*20;
-                    //m.sx *= i->multiply;
-                    //m.sy *= i->multiply;
-                    //m.r0 *= i->multiply;
-                    //m.r1 *= i->multiply;
-                    //m.tx *= i->multiply;
-                    //m.ty *= i->multiply;
-                    fill_bitmap(line, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0);
+                    fill_bitmap(line, zline, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0, l->p->depth);
                 }
-            }
+            } else {
+                fprintf(stderr, "Undefined fillmode: %02x\n", f->type);
+	    }
         }
+	l = l->next;
+    }
+    if(clip && clipdepth) {
+	fill_clip(line, zline, y, x1, x2, clipdepth);
     }
 }
 
@@ -862,15 +722,15 @@ static void change_state(int y, state_t* state, renderpoint_t*p)
     layer_t*before=0, *self=0, *after=0;
 
     if(DEBUG&2) { 
-        printf("[%s(%d,%d)/%d/%d-%d]", p->type==clip_type?"C":"F", p->x, y, p->depth, p->shapeline->fillstyle0, p->shapeline->fillstyle1);
+        printf("[(%d,%d)/%d/%d-%d]", p->x, y, p->depth, p->shapeline->fillstyle0, p->shapeline->fillstyle1);
     }
 
     search_layer(state, p->depth, &before, &self, &after);
 
     if(self) {
         /* shape update */
-        if(self->fillid<0 || !p->shapeline->fillstyle0 || !p->shapeline->fillstyle1) {
-            /* filling/clipping ends */
+        if(self->fillid<0/*??*/ || !p->shapeline->fillstyle0 || !p->shapeline->fillstyle1) {
+            /* filling ends */
             if(DEBUG&2) printf("<D>");
             
             delete_layer(state, self);
@@ -878,12 +738,10 @@ static void change_state(int y, state_t* state, renderpoint_t*p)
             /*both fill0 and fill1 are set- exchange the two, updating the layer */
             if(self->fillid == p->shapeline->fillstyle0) {
                 self->fillid = p->shapeline->fillstyle1;
-                self->clipdepth = 0;
                 self->p = p;
                 if(DEBUG&2) printf("<X>");
             } else if(self->fillid == p->shapeline->fillstyle1) {
                 self->fillid = p->shapeline->fillstyle0;
-                self->clipdepth = 0;
                 self->p = p;
                 if(DEBUG&2) printf("<X>");
             } else {
@@ -909,56 +767,62 @@ static void change_state(int y, state_t* state, renderpoint_t*p)
 
         if(DEBUG&2) printf("<+>");
 
-        if(p->type == clip_type) {
-            /* add clipping */
-            n->fillid = -1;
-            n->clipdepth = p->clipdepth;
-            n->p = p;
-        } else {
-            n->fillid = p->shapeline->fillstyle0 ? p->shapeline->fillstyle0 : p->shapeline->fillstyle1;
-            n->clipdepth = 0;
-            n->p = p;
-        }
+	n->fillid = p->shapeline->fillstyle0 ? p->shapeline->fillstyle0 : p->shapeline->fillstyle1;
+	n->p = p;
 
         add_layer(state, before, n);
     }
 }
 
-RGBA* swf_Render(RENDERBUF*dest)
+void swf_Process(RENDERBUF*dest, U32 clipdepth)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
-    RGBA* img = (RGBA*)rfx_alloc(sizeof(RGBA)*dest->width*dest->height);
     int y;
-    long memory = 0;
-    RGBA * line1 = rfx_alloc(sizeof(RGBA)*i->width2);
-    RGBA * line2 = rfx_alloc(sizeof(RGBA)*i->width2);
+    
+    if(i->ymax < i->ymin) {
+	/* shape is empty. return. 
+	   only, if it's a clipshape, remember the clipdepth */
+	if(clipdepth) {
+	    for(y=0;y<i->height2;y++) {
+		if(clipdepth > i->lines[y].pending_clipdepth)
+		    i->lines[y].pending_clipdepth = clipdepth;
+	    }
+	}
+	return; //nothing (else) to do
+    }
 
-    for(y=0;y<i->height2;y++) {
-        TAG*tag = i->lines[y].points;
+    if(clipdepth) {
+	/* lines outside the clip shape are not filled
+	   immediately, only the highest clipdepth so far is
+	   stored there. They will be clipfilled once there's
+	   actually something about to happen in that line */
+	for(y=0;y<i->ymin;y++) {
+	    if(clipdepth > i->lines[y].pending_clipdepth)
+		i->lines[y].pending_clipdepth = clipdepth;
+	}
+	for(y=i->ymax+1;y<i->height2;y++) {
+	    if(clipdepth > i->lines[y].pending_clipdepth)
+		i->lines[y].pending_clipdepth = clipdepth;
+	}
+    }
+    
+    for(y=i->ymin;y<=i->ymax;y++) {
         int n;
-        int num = renderpoint_num(tag);
-	renderpoint_t*points = renderpoint_readall(tag);
-        RGBA*line = line1;
-	state_t clipstate;
+        TAG*tag = i->lines[y].points;
+        int num = i->lines[y].num;
+	renderpoint_t*points = (renderpoint_t*)tag->data;
+        RGBA*line = &i->img[i->width2*y];
+        int*zline = &i->zbuf[i->width2*y];
+	int lastx = 0;
 	state_t fillstate;
-        memset(&clipstate, 0, sizeof(state_t));
         memset(&fillstate, 0, sizeof(state_t));
+        qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
 
-        if((y&1) && i->antialize)
-            line = line2;
-
-	if(!i->background) {
-	    memset(line, 0, sizeof(RGBA)*i->width2);
-	} else {
-	    int x,xx;
-	    int xstep=i->background_width*65536/i->width2;
-	    RGBA*src = &i->background[(i->background_height*y/i->height2)*i->background_width];
-	    for(x=0,xx=0;x<i->width2;x++,xx+=xstep) {
-		line[x] = src[xx>>16];
-	    }
+	if(i->lines[y].pending_clipdepth && !clipdepth) {
+	    fill_clip(line, zline, y, 0, i->width2, i->lines[y].pending_clipdepth);
+	    i->lines[y].pending_clipdepth=0;
 	}
-        memory += tag->memsize;
-        qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
+
         for(n=0;n<num;n++) {
             renderpoint_t*p = &points[n];
             renderpoint_t*next= n<num-1?&points[n+1]:0;
@@ -968,26 +832,61 @@ RGBA* swf_Render(RENDERBUF*dest)
                 endx = i->width2;
             if(startx < 0)
                 startx = 0;
+            if(endx < 0)
+                endx = 0;
 
-	    if(p->type == clip_type)
-		change_state(y, &clipstate, p);
-	    else
-		change_state(y, &fillstate, p);
-
-            fill(dest, line, y, startx, endx, &clipstate, &fillstate);
+	    if(clipdepth) {
+		/* for clipping, the inverse is filled */
+		fill_clip(line, zline, y, lastx, startx, clipdepth);
+	    }
+	    change_state(y, &fillstate, p);
+	
+	    fill(dest, line, zline, y, startx, endx, &fillstate, clipdepth);
+/*	    if(y == 0 && startx == 232 && endx == 418) {
+		printf("ymin=%d ymax=%d\n", i->ymin, i->ymax);
+		for(n=0;n<num;n++) {
+		    renderpoint_t*p = &points[n];
+		    printf("x=%f depth=%08x\n", p->x, p->depth);
+		}
+	    }*/
+
+	    lastx = endx;
             if(endx == i->width2)
                 break;
         }
-        free_layers(&clipstate);
+	if(clipdepth) {
+	    fill_clip(line, zline, y, lastx, i->width2, clipdepth);
+	}
         free_layers(&fillstate);
-        if(DEBUG&2) printf("\n");
+	
+	i->lines[y].num = 0;
+	swf_ClearTag(i->lines[y].points);
+    }
+    i->ymin = 0x7fffffff;
+    i->ymax = -0x80000000;
+}
+
+RGBA* swf_Render(RENDERBUF*dest)
+{
+    renderbuf_internal*i = (renderbuf_internal*)dest->internal;
+    RGBA* img = (RGBA*)rfx_alloc(sizeof(RGBA)*dest->width*dest->height);
+    int y;
+    RGBA*line2=0;
+    
+    for(y=0;y<i->height2;y++) {
+        int n;
+        RGBA*line = &i->img[y*i->width2];
 
         if(!i->antialize) {
             memcpy(&img[y*dest->width], line, sizeof(RGBA)*dest->width);
         } else {
             if(y&1) {
                 int x;
-                RGBA* p = &img[(y/2)*dest->width];
+		RGBA*line1=line;
+		RGBA* p;
+		if(!line2)
+		    line2=line1;
+                p = &img[(y/2)*dest->width];
                 for(x=0;x<dest->width;x++) {
                     RGBA*p1 = &line1[x*2];
                     RGBA*p2 = &line1[x*2+1];
@@ -1000,19 +899,8 @@ RGBA* swf_Render(RENDERBUF*dest)
                 }
             }
         }
-	free(points);
+	line2=line;
     }
-    free(line1);
-    free(line2);
-
-#define MEMORY
-    
-    if(DEBUG) printf("\nMemory used: %d\n", memory);
-#ifdef STATISTICS
-    if(DEBUG) printf("Statistics:\n");
-    if(DEBUG) printf("Average layer depth: %f\n", (double)layers/layernum);
-#endif
-
 
     return img;
 }
@@ -1025,19 +913,73 @@ typedef struct
     union {
         SHAPE2*shape;
         SWFFONT*font;
-    };
+    } obj;
 } character_t;
 
+int compare_placements(const void *v1, const void *v2)
+{
+    SWFPLACEOBJECT*p1 = (SWFPLACEOBJECT*)v1;
+    SWFPLACEOBJECT*p2 = (SWFPLACEOBJECT*)v2;
+    if(p1->depth != p2->depth)
+	return (int)p1->depth - (int)p2->depth;
+    else 
+	if(p2->clipdepth)
+	    return 1; // do the clip first
+	else
+	    return -1;
+
+/*    if(!p1->clipdepth) {
+	if(!p2->clipdepth) {
+	    // !p1->clipdepth && !p2->clipdepth
+	    return (int)p1->depth - (int)p2->depth;
+	} else {
+	    // !p1->clipdepth && p2->clipdepth
+	    if(p1->depth != p2->clipdepth)
+		return (int)p1->depth - (int)p2->clipdepth;
+	    else
+		return 1; // do the clip first
+	}
+    } else {
+	if(!p2->clipdepth) {
+	    // p1->clipdepth && !p2->clipdepth
+	    if(p1->clipdepth != p2->depth)
+		return (int)p1->clipdepth - (int)p2->depth;
+	    else
+		return -1;// do the clip first
+	} else {
+	    if(p1->clipdepth != p2->clipdepth)
+		return (int)p1->clipdepth - (int)p2->clipdepth;
+	    else
+		return (int)p1->depth - (int)p2->depth;
+	}
+    }*/
+}
+
 void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
 {
     TAG*tag;
     int t;
-
+    int numplacements;
+    RGBA color;
+    SWFPLACEOBJECT* placements;
+    
     character_t* idtable = rfx_calloc(sizeof(character_t)*65536);            // id to character mapping
     SWFPLACEOBJECT** depthtable = rfx_calloc(sizeof(SWFPLACEOBJECT*)*65536); // depth to placeobject mapping
+    
+    tag = swf->firstTag;
+    numplacements = 0;
+    while(tag) {
+        if(tag->id == ST_PLACEOBJECT || 
+           tag->id == ST_PLACEOBJECT2) {
+	    numplacements++;
+	}
+	tag = tag->next;
+    }
+    placements = rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements);
+    numplacements = 0;
 
     /* set background color */
-    RGBA color = swf_GetSWFBackgroundColor(swf);
+    color = swf_GetSWFBackgroundColor(swf);
     swf_Render_SetBackgroundColor(buf, color);
 
     /* parse definitions */
@@ -1053,7 +995,7 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
                 SHAPE2* shape = rfx_calloc(sizeof(SHAPE2));
                 swf_ParseDefineShape(tag, shape);
                 idtable[id].type = shape_type;
-                idtable[id].shape = shape;
+                idtable[id].obj.shape = shape;
             } else if(swf_isImageTag(tag)) {
 		int width,height;
                 RGBA*data = swf_ExtractImage(tag, &width, &height);
@@ -1063,7 +1005,7 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
             } else if(tag->id == ST_DEFINEFONT ||
                       tag->id == ST_DEFINEFONT2) {
                 //swf_FontExtract(swf,id,&idtable[id].font);
-                idtable[id].font = 0;
+                idtable[id].obj.font = 0;
             } else if(tag->id == ST_DEFINEFONTINFO ||
                       tag->id == ST_DEFINEFONTINFO2) {
                 idtable[id].type = font_type;
@@ -1073,16 +1015,19 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
             }
         } else if(tag->id == ST_PLACEOBJECT || 
                   tag->id == ST_PLACEOBJECT2) {
-            SWFPLACEOBJECT* p = rfx_calloc(sizeof(SWFPLACEOBJECT));
-            swf_GetPlaceObject(tag, p);
+            SWFPLACEOBJECT p;
+            swf_GetPlaceObject(tag, &p);
             /* TODO: add move and deletion */
-            depthtable[p->depth] = p;
+            placements[numplacements++] = p;
+	    swf_PlaceObjectFree(&p); //dirty! but it only removes items we don't need
         }
         tag = tag->next;
     }
+
+    qsort(placements, numplacements, sizeof(SWFPLACEOBJECT), compare_placements);
       
-    for(t=65535;t>=0;t--) if(depthtable[t]) {
-        SWFPLACEOBJECT*p = depthtable[t];
+    for(t=0;t<numplacements;t++) {
+        SWFPLACEOBJECT*p = &placements[t];
         int id = p->id;
             
         if(!idtable[id].tag) { 
@@ -1092,7 +1037,7 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
 
         if(idtable[id].type == shape_type) {
             SRECT sbbox = swf_TurnRect(*idtable[id].bbox, &p->matrix);
-            swf_RenderShape(buf, idtable[id].shape, &p->matrix, &p->cxform, p->depth, p->clipdepth);
+            swf_RenderShape(buf, idtable[id].obj.shape, &p->matrix, &p->cxform, p->depth, p->clipdepth);
         } else if(idtable[id].type == text_type) {
 	    /* TODO */
         } else {
@@ -1107,17 +1052,14 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
             idtable[t].bbox=0;
         }
         if(idtable[t].type == shape_type) {
-            SHAPE2* shape = idtable[t].shape;
+            SHAPE2* shape = idtable[t].obj.shape;
             if(shape) {
                 swf_Shape2Free(shape); // FIXME
-                free(idtable[t].shape);idtable[t].shape = 0;
+                free(idtable[t].obj.shape);idtable[t].obj.shape = 0;
             }
         }
-        if(depthtable[t]) {
-            swf_PlaceObjectFree(depthtable[t]);
-            free(depthtable[t]);depthtable[t] = 0;
-        }
     }
+    free(placements);
     free(idtable);
     free(depthtable);
 }