X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fmodules%2Fswfrender.c;h=9df996fb5cfdefb51a37ecb3e43e358691aab86f;hp=29b6e4b4368ba079e7cf4d2e7fc74ba05adf1818;hb=2391d7ae5d8a145a250a8b80ab8c93ba74eba030;hpb=93d303cf5009b1e3c011933997d71e78a6a99e85

diff --git a/lib/modules/swfrender.c b/lib/modules/swfrender.c
index 29b6e4b..9df996f 100644
--- a/lib/modules/swfrender.c
+++ b/lib/modules/swfrender.c
@@ -22,21 +22,52 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "../rfxswf.h"
+
+/* one bit flag: */
+#define clip_type 0
+#define fill_type 1
+
 typedef struct _renderpoint
 {
-    enum {clip_type, fill_type} type;
+    float x;
+    U32 depth;
+
+    SHAPELINE*shapeline;
+    SHAPE2*s;
+    
+} renderpoint_t;
+
+/* 
+    enum {clip_type, solidfill_type, texturefill_type, gradientfill_type} type;
     float fx;
     int x;
     U32 depth;
     U32 clipdepth;
-    SHAPE2*shape;
-    SHAPELINE*shapeline;
-    //CXFORM?
-} renderpoint_t;
+
+    // solidfill;
+    RGBA color; 
+    
+    // texturefill
+    bitmap_t* bitmap;
+
+    // gradientfill
+    gradient_t* gradient;
+
+    // texture- & gradientfill;
+    U32 x,y;
+    U32 dx,dy;
+
+*/
 
 typedef struct _renderline
 {
     TAG*points; //incremented in 128 byte steps
+    int num;
+    U32 pending_clipdepth;
 } renderline_t;
 
 typedef struct _bitmap {
@@ -47,23 +78,18 @@ typedef struct _bitmap {
     struct _bitmap*next;
 } bitmap_t;
 
-typedef struct _dummyshape
-{
-    SHAPE2*shape;
-    struct _dummyshape*next;
-} dummyshape_t;
-
 typedef struct _renderbuf_internal
 {
     renderline_t*lines;
     bitmap_t*bitmaps;
-    char antialize;
+    int 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
@@ -72,22 +98,30 @@ 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 = (int)x;
-    p->fx = x;
+    p->x = x;
+    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 CUT 0.77887789
+
+#define INT(x) ((int)((x)+16)-16)
 
-static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p, char thin)
+static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p)
 {
     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
+    double diffx, diffy;
+    double ny1, ny2, stepx;
 /*    if(DEBUG&4) {
         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);
+        printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]\n", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
     }*/
+    assert(p->shapeline);
 
     y1=y1*i->multiply;
     y2=y2*i->multiply;
@@ -100,44 +134,48 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2,
     x2 = x2/20.0;
 
     if(y2 < y1) {
-        double x = x1;x1 = x2;x2=x;
-        double y = y1;y1 = y2;y2=y;
+        double x;
+        double y;
+	x = x1;x1 = x2;x2=x;
+	y = y1;y1 = y2;y2=y;
     }
     
-    double diffx = x2 - x1;
-    double diffy = y2 - y1;
+    diffx = x2 - x1;
+    diffy = y2 - y1;
     
-    double ny1 = (int)(y1)+CUT;
-    double 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)
         return;
 
-    double stepx = diffx/diffy;
+    stepx = diffx/diffy;
     x1 = x1 + (ny1-y1)*stepx;
     x2 = x2 + (ny2-y2)*stepx;
 
-    int posy=(int)ny1;
-    int endy=(int)ny2;
-    double posx=0;
-    double startx = x1;
-
-    while(posy<=endy) {
-        float xx = (float)(startx + posx);
-        add_pixel(buf, xx ,posy, p);
-        posx+=stepx;
-        posy++;
+    {
+	int posy=INT(ny1);
+	int endy=INT(ny2);
+	double posx=0;
+	double startx = x1;
+
+	while(posy<=endy) {
+	    float xx = (float)(startx + posx);
+	    add_pixel(buf, xx ,posy, p);
+	    posx+=stepx;
+	    posy++;
+	}
     }
 }
 #define PI 3.14159265358979
-static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double y2, int width, renderpoint_t*p)
+static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double y2, double width, renderpoint_t*p)
 {
     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
 
@@ -151,10 +189,19 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double
     double lastx,lasty;
     double vx,vy;
     double xx,yy;
-   
-    /* The Flash Player does this, too. This means every line is always at least
-       one pixel wide */
+  
+    /* Make sure the line is always at least one pixel wide */
+#ifdef LINEMODE1
+    /* That's what Macromedia's Player does at least at zoom level >= 1.  */
     width += 20;
+#else
+    /* That's what Macromedia's Player seems to do at zoom level 0.  */
+    /* TODO: needs testing */
+
+    /* TODO: how does this interact with scaling? */
+    if(width * i->multiply < 20)
+	width = 20 / i->multiply;
+#endif
 
     sd = (double)dx*(double)dx+(double)dy*(double)dy;
     d = sqrt(sd);
@@ -167,7 +214,7 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double
         vy = (-dx/d);
     }
 
-    segments = width/2;
+    segments = (int)(width/2);
     if(segments < 2)
         segments = 2;
 
@@ -178,7 +225,7 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double
 
     xx = x2+vx;
     yy = y2+vy;
-    add_line(buf, x1+vx, y1+vy, xx, yy, p, 0);
+    add_line(buf, x1+vx, y1+vy, xx, yy, p);
     lastx = xx;
     lasty = yy;
     for(t=1;t<segments;t++) {
@@ -186,19 +233,19 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double
         double c = cos(t*PI/segments);
         xx = (x2 + vx*c - vy*s);
         yy = (y2 + vx*s + vy*c);
-        add_line(buf, lastx, lasty, xx, yy, p, 0);
+        add_line(buf, lastx, lasty, xx, yy, p);
         lastx = xx;
         lasty = yy;
     }
     
     xx = (x2-vx);
     yy = (y2-vy);
-    add_line(buf, lastx, lasty, xx, yy, p, 0);
+    add_line(buf, lastx, lasty, xx, yy, p);
     lastx = xx;
     lasty = yy;
     xx = (x1-vx);
     yy = (y1-vy);
-    add_line(buf, lastx, lasty, xx, yy, p, 0);
+    add_line(buf, lastx, lasty, xx, yy, p);
     lastx = xx;
     lasty = yy;
     for(t=1;t<segments;t++) {
@@ -206,11 +253,11 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double
         double c = cos(t*PI/segments);
         xx = (x1 - vx*c + vy*s);
         yy = (y1 - vx*s - vy*c);
-        add_line(buf, lastx, lasty, xx, yy, p, 0);
+        add_line(buf, lastx, lasty, xx, yy, p);
         lastx = xx;
         lasty = yy;
     }
-    add_line(buf, lastx, lasty, (x1+vx), (y1+vy), p, 0);
+    add_line(buf, lastx, lasty, (x1+vx), (y1+vy), p);
 }
 
 static inline void transform_point(MATRIX*m, int x, int y, int*dx, int*dy)
@@ -227,12 +274,12 @@ static int compare_renderpoints(const void * _a, const void * _b)
 {
     renderpoint_t*a = (renderpoint_t*)_a;
     renderpoint_t*b = (renderpoint_t*)_b;
-    if(a->fx < b->fx) return -1;
-    if(a->fx > b->fx) return 1;
+    if(a->x < b->x) return -1;
+    if(a->x > b->x) return 1;
     return 0;
 }
 
-void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, char antialize, int multiply)
+void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, int antialize, int multiply)
 {
     renderbuf_internal*i;
     int y;
@@ -243,23 +290,40 @@ void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, c
     buf->posy = posy;
     buf->internal = (renderbuf_internal*)rfx_calloc(sizeof(renderbuf_internal));
     i = (renderbuf_internal*)buf->internal;
-    i->antialize = !!antialize;
-    i->multiply = antialize?multiply*2:multiply;
-    i->height2 = antialize?2*buf->height:buf->height;
-    i->width2 = antialize?2*buf->width:buf->width;
+    if(antialize < 1)
+	antialize = 1;
+    i->antialize = antialize;
+    i->multiply = multiply*antialize;
+    i->height2 = antialize*buf->height;
+    i->width2 = antialize*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)
 {
@@ -269,11 +333,12 @@ void swf_Render_AddImage(RENDERBUF*buf, U16 id, RGBA*img, int width, int height)
 {
     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
 
-    bitmap_t*bm = rfx_calloc(sizeof(bitmap_t));
+    bitmap_t*bm = (bitmap_t*)rfx_calloc(sizeof(bitmap_t));
     bm->id = id;
     bm->width = width;
     bm->height = height;
-    bm->data = img;
+    bm->data = (RGBA*)rfx_alloc(width*height*4);
+    memcpy(bm->data, img, width*height*4);
 
     bm->next = i->bitmaps;
     i->bitmaps = bm;
@@ -285,37 +350,29 @@ 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++) {
-        swf_DeleteTag(i->lines[y].points);
+        swf_DeleteTag(0, i->lines[y].points);
         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;
-        //free(b->data);b->data=0;
+        free(b->data);b->data=0;
         rfx_free(b);
         b = next;
     }
@@ -324,148 +381,169 @@ void swf_Render_Delete(RENDERBUF*dest)
     rfx_free(dest->internal); dest->internal = 0;
 }
 
+static SHAPE2* linestyle2fillstyle(SHAPE2*shape)
+{
+    SHAPE2*s = (SHAPE2*)rfx_calloc(sizeof(SHAPE2));
+    int t;
+    s->numfillstyles = shape->numlinestyles;
+    s->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles);
+    s->lines = (SHAPELINE*)rfx_calloc(sizeof(SHAPELINE)*shape->numlinestyles);
+    for(t=0;t<shape->numlinestyles;t++) {
+        s->lines[t].fillstyle0 = t+1;
+        s->fillstyles[t].type = FILL_SOLID;
+        s->fillstyles[t].color = shape->linestyles[t].color;
+    }
+    return s;
+}
+
+void swf_Process(RENDERBUF*dest, U32 clipdepth);
+
+double matrixsize(MATRIX*m)
+{
+    double l1 = sqrt((m->sx /65536.0) * (m->sx /65536.0) + (m->r0 /65536.0) * (m->r0/65536.0) );
+    double l2 = sqrt((m->r1 /65536.0) * (m->r1 /65536.0) + (m->sy /65536.0) * (m->sy/65536.0) );
+    return sqrt(l1*l2);
+}
+
 void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _depth,U16 _clipdepth)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
     
-    SHAPELINE*line = shape->lines;
+    SHAPELINE*line;
     int x=0,y=0;
     MATRIX mat = *m;
+    SHAPE2* s2 = 0;
     SHAPE2* lshape = 0;
-
     renderpoint_t p, lp;
+    U32 clipdepth;
+    double widthmultiply = matrixsize(m);
+
     memset(&p, 0, sizeof(renderpoint_t));
     memset(&lp, 0, sizeof(renderpoint_t));
-    p.type = _clipdepth?clip_type:fill_type;
-    p.shape = shape;
+    
+    clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0;
     p.depth = _depth << 16;
-    p.clipdepth = _clipdepth << 16;
+
     mat.tx -= dest->posx*20;
     mat.ty -= dest->posy*20;
 
-    if(shape->numlinestyles) {
-        dummyshape_t*dshape = rfx_calloc(sizeof(dummyshape_t));
-        lshape = rfx_calloc(sizeof(SHAPE2));
+    s2 = swf_Shape2Clone(shape);
+    line = s2->lines;
+    if(shape->numfillstyles) {
         int t;
-        lshape->numfillstyles = shape->numlinestyles;
-        lshape->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles);
-        lshape->lines = (SHAPELINE*)rfx_calloc(sizeof(SHAPELINE)*shape->numlinestyles);
-        for(t=0;t<shape->numlinestyles;t++) {
-            lshape->lines[t].fillstyle0 = t+1;
-            lshape->fillstyles[t].type = FILL_SOLID;
-            lshape->fillstyles[t].color = shape->linestyles[t].color;
-        }
-        lp.type = fill_type;
-        lp.shape = lshape;
-        lp.depth = p.depth+1;
-
-        /* add this shape to the global shape list, for deallocing */
-        dshape->shape = lshape;
-        i->dshapes_next = dshape;
-        if(!i->dshapes) {
-            i->dshapes = dshape;
+        p.s = s2;
+        /* multiply fillstyles matrices with placement matrix-
+           important for texture and gradient fill */
+        for(t=0;t<s2->numfillstyles;t++) {
+            MATRIX nm;
+            swf_MatrixJoin(&nm, &mat, &s2->fillstyles[t].m);
+            /*nm.sx *= i->multiply;
+            nm.sy *= i->multiply;
+            nm.r0 *= i->multiply;
+            nm.r1 *= i->multiply;
+            nm.tx *= i->multiply;
+            nm.ty *= i->multiply;*/
+            s2->fillstyles[t].m = nm;
         }
     }
 
-    if(p.clipdepth) {
-        /* reverse shape */
-        p.shapeline = 0;
-        add_line(dest, -20, 0, -20, i->height2*20, &p, 0);
+    if(shape->numlinestyles) {
+        lshape = linestyle2fillstyle(shape);
+        lp.s = lshape;
+        lp.depth = (_depth << 16)+1;
     }
 
+
     while(line)
     {
         int x1,y1,x2,y2,x3,y3;
 
-        p.shapeline = line;
-
         if(line->type == moveTo) {
         } else if(line->type == lineTo) {
-            if(DEBUG&4) {
-                x1 = x;
-                y1 = y;
-                x2 = line->x;
-                y2 = line->y;
-                int 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);
+                add_solidline(dest, x1, y1, x3, y3, shape->linestyles[line->linestyle-1].width * widthmultiply, &lp);
                 lp.depth++;
             }
-            if(line->fillstyle0 || line->fillstyle1)
-                add_line(dest, x1, y1, x3, y3, &p, 0);
-            
-            if(DEBUG&4) printf("\n");
+            if(line->fillstyle0 || line->fillstyle1) {
+                assert(shape->numfillstyles);
+		p.shapeline = line;
+                add_line(dest, x1, y1, x3, y3, &p);
+            }
         } else if(line->type == splineTo) {
+	    int c,t,parts,qparts;
+	    double xx,yy;
             
             transform_point(&mat, x, y, &x1, &y1);
             transform_point(&mat, line->sx, line->sy, &x2, &y2);
             transform_point(&mat, line->x, line->y, &x3, &y3);
             
-            int c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
-            int parts,qparts;
-            int t;
-            double xx=x1,yy=y1;
+            c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
+            xx=x1;
+	    yy=y1;
 
-            parts = (int)(sqrt(c)/3);
+            parts = (int)(sqrt((float)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);
+                    add_solidline(dest, xx, yy, nx, ny, shape->linestyles[line->linestyle-1].width * widthmultiply, &lp);
                     lp.depth++;
                 }
-                if(line->fillstyle0 || line->fillstyle1)
-                    add_line(dest, (int)xx, (int)yy, (int)nx, (int)ny, &p, 0);
+                if(line->fillstyle0 || line->fillstyle1) {
+                    assert(shape->numfillstyles);
+		    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 RGBA color_black = {255,0,0,0};
+
+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_plain(RGBA*line, int x1, int x2, RGBA col)
+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;
@@ -473,98 +551,207 @@ 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 int inline clamp(int v)
+{
+    if(v>255) return 255;
+    else return v;
+}
+
+static void fill_bitmap(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clipbitmap, U32 depth, double fmultiply)
 {
     int x = x1;
-    double m11=m->sx/65536.0, m21=m->r1/65536.0;
-    double m12=m->r0/65536.0, m22=m->sy/65536.0;
-    double rx = m->tx/20.0;
-    double ry = m->ty/20.0;
+    
+    double m11= m->sx*fmultiply/65536.0, m21= m->r1*fmultiply/65536.0;
+    double m12= m->r0*fmultiply/65536.0, m22= m->sy*fmultiply/65536.0;
+    double rx = m->tx*fmultiply/20.0;
+    double ry = m->ty*fmultiply/20.0;
+
     double det = m11*m22 - m12*m21;
     if(fabs(det) < 0.0005) { 
 	/* x direction equals y direction- the image is invisible */
 	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 {
-        int xx = (int)((  (x - rx) * m22 - (y - ry) * m21)*det);
-        int yy = (int)((- (x - rx) * m12 + (y - ry) * m11)*det);
-        
-        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;
+		if(xx<0) xx += b->width;
+		if(yy<0) yy += b->height;
+	    }
 
-        RGBA col = b->data[yy*b->width+xx];
-        int ainv = 255-col.a;
+	    col = b->data[yy*b->width+xx];
+	    ainv = 255-col.a;
+
+	    line[x].r = clamp(((line[x].r*ainv)>>8)+col.r);
+	    line[x].g = clamp(((line[x].g*ainv)>>8)+col.g);
+	    line[x].b = clamp(((line[x].b*ainv)>>8)+col.b);
+	    line[x].a = 255;
+	    
+	    z[x] = depth;
+	}
+    } while(++x<x2);
+}
+
+static void fill_gradient(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, GRADIENT*g, int type, U32 depth, double fmultiply)
+{
+    int x = x1;
+    
+    double m11= m->sx*fmultiply/80, m21= m->r1*fmultiply/80;
+    double m12= m->r0*fmultiply/80, m22= m->sy*fmultiply/80;
+    double rx = m->tx*fmultiply/20.0;
+    double ry = m->ty*fmultiply/20.0;
+
+    double det = m11*m22 - m12*m21;
+    if(fabs(det) < 0.0005) { 
+	/* x direction equals y direction- the image is invisible */
+	return;
+    }
+    det = 1.0/det;
 
-        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;
+    RGBA palette[512];
+    RGBA oldcol = g->rgba[0];
+    int r0 = g->ratios[0]*2;
+    int t;
+    for(t=0;t<r0;t++) 
+	palette[t] = oldcol;
+    for(t=1;t<g->num;t++) {
+	int r1 = g->ratios[t]*2;
+	RGBA newcol = g->rgba[t];
+	if(r0 == r1)
+	    continue;
+	//printf("%d %d->%d %02x%02x%02x%02x->%02x%02x%02x%02x\n", 
+	//	t, r0, r1, oldcol.r,oldcol.g,oldcol.b,oldcol.a,
+	//	newcol.r,newcol.g,newcol.b,newcol.a);
+	double f = 1.0 / (r1-r0);
+	double p0 = 1;
+	double p1 = 0;
+	int s;
+	for(;r0<=r1;r0++) {
+	    palette[r0].r = oldcol.r*p0 + newcol.r*p1;
+	    palette[r0].g = oldcol.g*p0 + newcol.g*p1;
+	    palette[r0].b = oldcol.b*p0 + newcol.b*p1;
+	    palette[r0].a = oldcol.a*p0 + newcol.a*p1;
+	    p0 -= f;
+	    p1 += f;
+	}
+	oldcol = newcol;
+    }
+    for(t=r0;t<512;t++) 
+	palette[t] = oldcol;
+
+    do {
+	if(depth >= z[x]) {
+	    RGBA col;
+	    double xx = (  (x - rx) * m22 - (y - ry) * m21)*det;
+	    double yy = (- (x - rx) * m12 + (y - ry) * m11)*det;
+	    int ainv;
+	    ainv = 255-col.a;
+
+	    if(type == FILL_LINEAR) {
+		int xr = xx*256;
+		if(xr<-256)
+		    xr = -256;
+		if(xr>255)
+		    xr = 255;
+		col = palette[xr+256];
+	    } else {
+		int xr = sqrt(xx*xx+yy*yy)*511;
+		if(xr<0)
+		    xr = 0;
+		if(xr>511)
+		    xr = 511;
+		col = palette[xr];
+	    }
+
+	    line[x].r = clamp(((line[x].r*ainv)>>8)+col.r);
+	    line[x].g = clamp(((line[x].g*ainv)>>8)+col.g);
+	    line[x].b = clamp(((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*state)
+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;
+    int clip=1;
 
-    layer_t*l = state->layers;
+    layer_t*l = fillstate->layers;
 
     if(x1>=x2) //zero width? nothing to do.
         return;
-
-    U32 clipdepth = 0;
+    
     while(l) {
-        if(l->p->depth < clipdepth) {
-            if(DEBUG&2) printf("(clipped)");
-            l = l->next;
-            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) {
+        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->shape->numfillstyles) {
-            fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->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->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);
-            } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) {
+                fill_solid(line, zline, y, x1, x2, f->color, l->p->depth);
+            } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED || f->type == (FILL_TILED|2) || f->type == (FILL_CLIPPED|2)) {
                 /* TODO: optimize (do this in add_pixel()?) */
                 bitmap_t* b = i->bitmaps;
                 while(b && b->id != f->id_bitmap) {
@@ -572,22 +759,20 @@ static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*state
                 }
                 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 {
-                    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, &m, b, FILL_CLIPPED?1:0);
+                    fill_bitmap(line, zline, y, x1, x2, &f->m, b, /*clipped?*/f->type&1, l->p->depth, i->multiply);
                 }
-            }
+            } else if(f->type == FILL_LINEAR || f->type == FILL_RADIAL) {
+		fill_gradient(line, zline, y, x1, x2, &f->m, &f->gradient, f->type, l->p->depth, i->multiply);
+            } else {
+                fprintf(stderr, "Undefined fillmode: %02x\n", f->type);
+	    }
         }
-        l = l->next;
+	l = l->next;
+    }
+    if(clip && clipdepth) {
+	fill_clip(line, zline, y, x1, x2, clipdepth);
     }
 }
 
@@ -648,15 +833,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("[(%f,%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);
@@ -664,12 +849,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 {
@@ -686,110 +869,485 @@ static void change_state(int y, state_t* state, renderpoint_t*p)
                we always get (0,32), (32, 33), (33, 0) in the right order if
                they happen to fall on the same pixel.
                (not: (0,32), (33, 0), (32, 33))
+	       Notice: Weird fill styles appear if linestyles are involved, too.
             */
             fprintf(stderr, "<line %d: both fillstyles set while not inside shape>\n", y);
             return;
         }
         
-        n = rfx_calloc(sizeof(layer_t));
+        n = (layer_t*)rfx_calloc(sizeof(layer_t));
 
         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 size = sizeof(renderpoint_t);
-        int num = tag->len / size;
-        RGBA*line = line1;
-        if((y&1) && i->antialize)
-            line = line2;
-
-        state_t state;
-        memset(&state, 0, sizeof(state_t));
-
-	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];
+        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(&fillstate, 0, sizeof(state_t));
+        qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
+	/* resort points */
+	/*if(y==884) {
+	    for(n=0;n<num;n++) {
+		printf("%f (%d/%d) %d\n", points[n].x, 
+			points[n].shapeline->fillstyle0,
+			points[n].shapeline->fillstyle1,
+			points[n].shapeline->linestyle);
 	    }
+	}*/
+
+	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(tag->data, num, size, compare_renderpoints);
+
         for(n=0;n<num;n++) {
-            renderpoint_t*p = (renderpoint_t*)&tag->data[size*n];
-            renderpoint_t*next= n<num-1?(renderpoint_t*)&tag->data[size*(n+1)]:0;
-            int startx = p->x;
-            int endx = next?next->x:i->width2;
+            renderpoint_t*p = &points[n];
+            renderpoint_t*next= n<num-1?&points[n+1]:0;
+            int startx = (int)p->x;
+            int endx = (int)(next?next->x:i->width2);
             if(endx > i->width2)
                 endx = i->width2;
             if(startx < 0)
                 startx = 0;
-
-            change_state(y, &state, p);
-
-            fill(dest, line, y, startx, endx, &state);
+            if(endx < 0)
+                endx = 0;
+
+	    if(clipdepth) {
+		/* for clipping, the inverse is filled 
+		   TODO: lastx!=startx only at the start of the loop, 
+		         so this might be moved up
+		 */
+		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(&state);
-        if(DEBUG&2) printf("\n");
+	if(clipdepth) {
+	    /* TODO: is lastx *ever* != i->width2 here? */
+	    fill_clip(line, zline, y, lastx, i->width2, clipdepth);
+	}
+        free_layers(&fillstate);
+	
+	i->lines[y].num = 0;
+	swf_ClearTag(i->lines[y].points);
+    }
+    i->ymin = 0x7fffffff;
+    i->ymax = -0x80000000;
+}
 
-        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];
-                for(x=0;x<dest->width;x++) {
-                    RGBA*p1 = &line1[x*2];
-                    RGBA*p2 = &line1[x*2+1];
-                    RGBA*p3 = &line2[x*2];
-                    RGBA*p4 = &line2[x*2+1];
-                    p[x].r = (p1->r + p2->r + p3->r + p4->r)/4;
-                    p[x].g = (p1->g + p2->g + p3->g + p4->g)/4;
-                    p[x].b = (p1->b + p2->b + p3->b + p4->b)/4;
-                    p[x].a = (p1->a + p2->a + p3->a + p4->a)/4;
-                }
+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;
+    int antialize = i->antialize;
+   
+    if(antialize <= 1) /* no antializing */ {
+	for(y=0;y<i->height2;y++) {
+	    RGBA*line = &i->img[y*i->width2];
+	    memcpy(&img[y*dest->width], line, sizeof(RGBA)*dest->width);
+	}
+    } else {
+	RGBA**lines = (RGBA**)rfx_calloc(sizeof(RGBA*)*antialize);
+	int q = antialize*antialize;
+	int ypos = 0;
+	for(y=0;y<i->height2;y++) {
+	    int n;
+	    ypos = y % antialize;
+	    lines[ypos] = &i->img[y*i->width2];
+	    if(ypos == antialize-1) {
+		RGBA*out = &img[(y / antialize)*dest->width];
+		int x;
+		int r,g,b,a;
+		for(x=0;x<dest->width;x++) {
+		    int xpos = x*antialize;
+		    int yp;
+		    U32 r=0,g=0,b=0,a=0;
+		    for(yp=0;yp<antialize;yp++) {
+			RGBA*lp = &lines[yp][xpos];
+			int xp;
+			for(xp=0;xp<antialize;xp++) {
+			    RGBA*p = &lp[xp];
+			    r += p->r;
+			    g += p->g;
+			    b += p->b;
+			    a += p->a;
+			}
+		    }
+		    out[x].r = r / q;
+		    out[x].g = g / q;
+		    out[x].b = b / q;
+		    out[x].a = a / q;
+		}
+	    }
+	}
+	rfx_free(lines);
+    }
+    return img;
+}
+
+typedef struct
+{
+    int numchars;
+    SHAPE2**glyphs;
+} font_t;
+
+enum CHARACTER_TYPE {none_type, shape_type, image_type, text_type, edittext_type, font_type, sprite_type};
+typedef struct
+{
+    TAG*tag;
+    SRECT*bbox;
+    enum CHARACTER_TYPE type;
+    union {
+        SHAPE2*shape;
+        font_t*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;
+	}
+    }*/
+}
+
+typedef struct textcallbackblock
+{
+    character_t*idtable;
+    U16 depth;
+    U16 clipdepth;
+    CXFORM* cxform;
+    MATRIX m;
+    RENDERBUF*buf;
+} textcallbackblock_t;
+
+static void textcallback(void*self, int*chars, int*xpos, int nr, int fontid, int fontsize, 
+		    int xstart, int ystart, RGBA* color)
+{
+    textcallbackblock_t * info = (textcallbackblock_t*)self;
+    font_t*font = 0;
+    int t;
+    if(info->idtable[fontid].type != font_type) {
+	fprintf(stderr, "ID %d is not a font\n", fontid);
+	return;
+    } else if(!info->idtable[fontid].obj.font) {
+	fprintf(stderr, "Font %d unknown\n", fontid);
+	return;
+    } else {
+	font  = info->idtable[fontid].obj.font;
+    }
+    for(t=0;t<nr;t++) {
+	int x = xstart + xpos[t];
+	int y = ystart;
+	MATRIX m = info->m;
+	SPOINT p;
+	
+	p.x = x; p.y = y; 
+	p = swf_TurnPoint(p, &m);
+	
+	m.sx = (m.sx * fontsize) / 1024;
+	m.sy = (m.sy * fontsize) / 1024;
+	m.r0 = (m.r0 * fontsize) / 1024;
+	m.r1 = (m.r1 * fontsize) / 1024;
+	m.tx = p.x;
+	m.ty = p.y;
+
+	if(chars[t]<0 || chars[t]>= font->numchars) {
+	    fprintf(stderr, "Character out of range: %d\n", chars[t]);
+	} else {
+	    SHAPE2*shape = font->glyphs[chars[t]];
+	    shape->fillstyles[0].color = *color; //q&d
+	    /*printf("Rendering char %d (size %d, x:%d, y:%d) color:%02x%02x%02x%02x\n", chars[t], fontsize, x, y,
+		    color->a, color->r, color->g, color->b);
+	    swf_DumpMatrix(stdout, &m);
+	    swf_DumpShape(shape);*/
+	    swf_RenderShape(info->buf, shape, &m, info->cxform, info->depth, info->clipdepth);
+	}
+    }
+}
+
+static void renderFromTag(RENDERBUF*buf, character_t*idtable, TAG*firstTag, MATRIX*m)
+{
+    TAG*tag = 0;
+    int numplacements = 0;
+    SWFPLACEOBJECT* placements;
+
+    tag = firstTag;
+    numplacements = 0;
+    while(tag) {
+        if(tag->id == ST_PLACEOBJECT || 
+           tag->id == ST_PLACEOBJECT2) {
+	    numplacements++;
+	}
+	if(tag->id == ST_SHOWFRAME || tag->id == ST_END)
+	    break;
+	tag = tag->next;
+    }
+    placements = (SWFPLACEOBJECT*)rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements);
+    numplacements = 0;
+
+    tag = firstTag;
+    while(tag) {
+	if(swf_isPlaceTag(tag)) {
+	    SWFPLACEOBJECT p;
+	    swf_GetPlaceObject(tag, &p);
+	    /* TODO: add move and deletion */
+	    placements[numplacements++] = p;
+	    swf_PlaceObjectFree(&p); //dirty! but it only frees fields we don't use
+	}
+	if(tag->id == ST_SHOWFRAME || tag->id == ST_END)
+	    break;
+        tag = tag->next;
+    }
+
+    qsort(placements, numplacements, sizeof(SWFPLACEOBJECT), compare_placements);
+     
+    int t;
+    for(t=0;t<numplacements;t++) {
+        SWFPLACEOBJECT*p = &placements[t];
+        int id = p->id;
+	MATRIX m2;
+	swf_MatrixJoin(&m2, m, &p->matrix);
+            
+        if(!idtable[id].tag) { 
+            fprintf(stderr, "rfxswf: Id %d is unknown\n", id);
+            continue;
+        }
+
+        if(idtable[id].type == shape_type) {
+            //SRECT sbbox = swf_TurnRect(*idtable[id].bbox, &p->matrix);
+            swf_RenderShape(buf, idtable[id].obj.shape, &m2, &p->cxform, p->depth, p->clipdepth);
+	} else if(idtable[id].type == sprite_type) {
+	    swf_UnFoldSprite(idtable[id].tag);
+	    renderFromTag(buf, idtable, idtable[id].tag->next, &m2);
+	    swf_FoldSprite(idtable[id].tag);
+        } else if(idtable[id].type == text_type) {
+	    TAG* tag = idtable[id].tag;
+	    textcallbackblock_t info;
+	    MATRIX mt;
+
+	    swf_SetTagPos(tag, 0);
+	    swf_GetU16(tag);
+	    swf_GetRect(tag,0);
+  	    swf_GetMatrix(tag,&mt);
+	    swf_MatrixJoin(&info.m, &m2, &mt);
+	    /*printf("Text matrix:\n");
+	    swf_DumpMatrix(stdout, &m);
+	    printf("Placement matrix:\n");
+	    swf_DumpMatrix(stdout, &p->matrix);
+	    printf("Final matrix:\n");
+	    swf_DumpMatrix(stdout, &info.m);*/
+
+	    info.idtable = idtable;
+	    info.depth = p->depth;
+	    info.cxform = &p->cxform;
+	    info.clipdepth = p->clipdepth;
+	    info.buf = buf;
+	    
+	    swf_ParseDefineText(tag, textcallback, &info);
+        } else if(idtable[id].type == edittext_type) {
+	    TAG* tag = idtable[id].tag;
+            U16 flags = swf_GetBits(tag, 16);
+	    if(flags & ET_HASTEXT) {
+                fprintf(stderr, "edittext not supported yet (id %d)\n", id);
             }
+        } else {
+            fprintf(stderr, "Unknown/Unsupported Object Type for id %d: %s\n", id, swf_TagGetName(idtable[id].tag));
         }
     }
-    free(line1);
-    free(line2);
-    
-    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
 
+    free(placements);
+}
 
-    return img;
+void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
+{
+    TAG*tag;
+    int t;
+    RGBA color;
+
+    swf_OptimizeTagOrder(swf);
+    swf_FoldAll(swf);
+    
+    character_t* idtable = (character_t*)rfx_calloc(sizeof(character_t)*65536);            // id to character mapping
+    
+    /* set background color */
+    color = swf_GetSWFBackgroundColor(swf);
+    swf_Render_SetBackgroundColor(buf, color);
+
+    /* parse definitions */
+    tag = swf->firstTag;
+    while(tag) {
+        if(swf_isDefiningTag(tag)) {
+            int id = swf_GetDefineID(tag);
+            idtable[id].tag = tag;
+            idtable[id].bbox = (SRECT*)rfx_alloc(sizeof(SRECT));
+            *idtable[id].bbox = swf_GetDefineBBox(tag);
+
+            if(swf_isShapeTag(tag)) {
+                SHAPE2* shape = (SHAPE2*)rfx_calloc(sizeof(SHAPE2));
+                swf_ParseDefineShape(tag, shape);
+                idtable[id].type = shape_type;
+                idtable[id].obj.shape = shape;
+            } else if(swf_isImageTag(tag)) {
+		int width,height;
+                RGBA*data = swf_ExtractImage(tag, &width, &height);
+                idtable[id].type = image_type;
+                swf_Render_AddImage(buf, id, data, width, height);
+		free(data);
+            } else if(tag->id == ST_DEFINEFONT ||
+                      tag->id == ST_DEFINEFONT2) {
+		int t;
+		SWFFONT*swffont;
+		font_t*font = (font_t*)rfx_calloc(sizeof(font_t));
+		idtable[id].obj.font = font;
+                swf_FontExtract(swf,id,&swffont);
+		font->numchars = swffont->numchars;
+		font->glyphs = (SHAPE2**)rfx_calloc(sizeof(SHAPE2*)*font->numchars);
+		for(t=0;t<font->numchars;t++) {
+		    if(!swffont->glyph[t].shape->fillstyle.n) {
+			/* the actual fill color will be overwritten while rendering */
+			swf_ShapeAddSolidFillStyle(swffont->glyph[t].shape, &color_white);
+		    }
+		    font->glyphs[t] = swf_ShapeToShape2(swffont->glyph[t].shape);
+		}
+		swf_FontFree(swffont);
+                idtable[id].type = font_type;
+
+            } else if(tag->id == ST_DEFINEFONTINFO ||
+                      tag->id == ST_DEFINEFONTINFO2) {
+                idtable[id].type = font_type;
+            } else if(tag->id == ST_DEFINETEXT ||
+                      tag->id == ST_DEFINETEXT2) {
+                idtable[id].type = text_type;
+            } else if(tag->id == ST_DEFINESPRITE) {
+		idtable[id].type = sprite_type;
+            } else if(tag->id == ST_DEFINEEDITTEXT) {
+		idtable[id].type = edittext_type;
+	    }
+        }
+	tag = tag->next;
+    }
+    MATRIX m;
+    swf_GetMatrix(0, &m);
+    renderFromTag(buf, idtable, swf->firstTag, &m);
+    
+    /* free id and depth tables again */
+    for(t=0;t<65536;t++) {
+        if(idtable[t].bbox) {
+            free(idtable[t].bbox);
+            idtable[t].bbox=0;
+        }
+        if(idtable[t].type == shape_type) {
+            SHAPE2* shape = idtable[t].obj.shape;
+            if(shape) {
+                swf_Shape2Free(shape); // FIXME
+                free(idtable[t].obj.shape);idtable[t].obj.shape = 0;
+            }
+        } else if(idtable[t].type == font_type) {
+	    font_t* font = idtable[t].obj.font;
+	    if(font) {
+		if(font->glyphs) {
+		    int t;
+		    for(t=0;t<font->numchars;t++) {
+			swf_Shape2Free(font->glyphs[t]);
+			free(font->glyphs[t]); font->glyphs[t] = 0;
+		    }
+		    free(font->glyphs);
+		    font->glyphs = 0;
+		}
+		free(idtable[t].obj.font); idtable[t].obj.font = 0;
+		font = 0;
+	    }
+	}
+    }
+    free(idtable);
 }
+