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

diff --git a/lib/modules/swfrender.c b/lib/modules/swfrender.c
index a9d5d07..9df996f 100644
--- a/lib/modules/swfrender.c
+++ b/lib/modules/swfrender.c
@@ -23,6 +23,9 @@
    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
@@ -79,7 +82,7 @@ typedef struct _renderbuf_internal
 {
     renderline_t*lines;
     bitmap_t*bitmaps;
-    char antialize;
+    int antialize;
     int multiply;
     int width2,height2;
     int shapes;
@@ -105,7 +108,7 @@ static inline void add_pixel(RENDERBUF*dest, float x, int y, renderpoint_t*p)
 
 /* 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)
 
@@ -116,7 +119,7 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2,
     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);
 
@@ -172,7 +175,7 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2,
     }
 }
 #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;
 
@@ -194,8 +197,10 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double
 #else
     /* That's what Macromedia's Player seems to do at zoom level 0.  */
     /* TODO: needs testing */
-    if(width<20)
-	width = 20;
+
+    /* 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;
@@ -209,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;
 
@@ -274,7 +279,7 @@ static int compare_renderpoints(const void * _a, const void * _b)
     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;
@@ -285,10 +290,12 @@ 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));
@@ -326,11 +333,11 @@ 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 = rfx_alloc(width*height*4);
+    bm->data = (RGBA*)rfx_alloc(width*height*4);
     memcpy(bm->data, img, width*height*4);
 
     bm->next = i->bitmaps;
@@ -358,7 +365,7 @@ void swf_Render_Delete(RENDERBUF*dest)
 
     /* 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;
     }
 
@@ -376,7 +383,7 @@ void swf_Render_Delete(RENDERBUF*dest)
 
 static SHAPE2* linestyle2fillstyle(SHAPE2*shape)
 {
-    SHAPE2*s = rfx_calloc(sizeof(SHAPE2));
+    SHAPE2*s = (SHAPE2*)rfx_calloc(sizeof(SHAPE2));
     int t;
     s->numfillstyles = shape->numlinestyles;
     s->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles);
@@ -391,6 +398,13 @@ static SHAPE2* linestyle2fillstyle(SHAPE2*shape)
 
 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;
@@ -402,6 +416,7 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
     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));
@@ -421,13 +436,13 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
            important for texture and gradient fill */
         for(t=0;t<s2->numfillstyles;t++) {
             MATRIX nm;
-            swf_MatrixJoin(&nm, &s2->fillstyles[t].m, &mat); //TODO: is this the right order?
-            nm.sx *= i->multiply;
+            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;
+            nm.ty *= i->multiply;*/
             s2->fillstyles[t].m = nm;
         }
     }
@@ -438,6 +453,7 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
         lp.depth = (_depth << 16)+1;
     }
 
+
     while(line)
     {
         int x1,y1,x2,y2,x3,y3;
@@ -449,7 +465,7 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
             
             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) {
@@ -469,7 +485,7 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
             xx=x1;
 	    yy=y1;
 
-            parts = (int)(sqrt(c)/3);
+            parts = (int)(sqrt((float)c)/3);
             if(!parts) parts = 1;
 
             for(t=1;t<=parts;t++) {
@@ -478,7 +494,7 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
                 
                 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) {
@@ -509,6 +525,7 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
 
 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)
 {
@@ -522,6 +539,7 @@ static void fill_clip(RGBA*line, int*z, int y, int x1, int x2, U32 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;
@@ -551,20 +569,28 @@ static void fill_solid(RGBA*line, int*z, int y, int x1, int x2, RGBA col, U32 de
     }
 }
 
-static void fill_bitmap(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clipbitmap, U32 depth)
+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_solid(line, z, y, x1, x2, color_red, depth);
         return;
@@ -585,14 +611,97 @@ static void fill_bitmap(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, bitma
 	    } else {
 		xx %= b->width;
 		yy %= b->height;
+		if(xx<0) xx += b->width;
+		if(yy<0) yy += b->height;
 	    }
 
 	    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].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;
+
+    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;
@@ -642,7 +751,7 @@ static void fill(RENDERBUF*dest, RGBA*line, int*zline, int y, int x1, int x2, st
 	    if(f->type == FILL_SOLID) {
                 /* plain color fill */
                 fill_solid(line, zline, y, x1, x2, f->color, l->p->depth);
-            } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) {
+            } 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) {
@@ -652,8 +761,10 @@ static void fill(RENDERBUF*dest, RGBA*line, int*zline, int y, int x1, int x2, st
                     fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap);
                     fill_solid(line, zline, y, x1, x2, color_red, l->p->depth);
                 } else {
-                    fill_bitmap(line, zline, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0, l->p->depth);
+                    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);
 	    }
@@ -722,7 +833,7 @@ static void change_state(int y, state_t* state, renderpoint_t*p)
     layer_t*before=0, *self=0, *after=0;
 
     if(DEBUG&2) { 
-        printf("[(%d,%d)/%d/%d-%d]", 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);
@@ -758,12 +869,13 @@ 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("<+>");
 
@@ -817,6 +929,15 @@ void swf_Process(RENDERBUF*dest, U32 clipdepth)
 	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);
@@ -826,8 +947,8 @@ void swf_Process(RENDERBUF*dest, U32 clipdepth)
         for(n=0;n<num;n++) {
             renderpoint_t*p = &points[n];
             renderpoint_t*next= n<num-1?&points[n+1]:0;
-            int startx = p->x;
-            int endx = next?next->x:i->width2;
+            int startx = (int)p->x;
+            int endx = (int)(next?next->x:i->width2);
             if(endx > i->width2)
                 endx = i->width2;
             if(startx < 0)
@@ -836,11 +957,14 @@ void swf_Process(RENDERBUF*dest, U32 clipdepth)
                 endx = 0;
 
 	    if(clipdepth) {
-		/* for clipping, the inverse is filled */
+		/* 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);
@@ -855,6 +979,7 @@ void swf_Process(RENDERBUF*dest, U32 clipdepth)
                 break;
         }
 	if(clipdepth) {
+	    /* TODO: is lastx *ever* != i->width2 here? */
 	    fill_clip(line, zline, y, lastx, i->width2, clipdepth);
 	}
         free_layers(&fillstate);
@@ -871,48 +996,67 @@ 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*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];
-                    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;
-                }
-            }
-        }
-	line2=line;
+    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 {none_type, shape_type, image_type, text_type, font_type} type;
+    enum CHARACTER_TYPE type;
     union {
         SHAPE2*shape;
-        SWFFONT*font;
+        font_t*font;
     } obj;
 } character_t;
 
@@ -955,29 +1099,165 @@ int compare_placements(const void *v1, const void *v2)
     }*/
 }
 
-void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
+typedef struct textcallbackblock
 {
-    TAG*tag;
+    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;
-    int numplacements;
-    RGBA color;
+    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;
-    
-    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;
+
+    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 = rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements);
+    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(placements);
+}
+
+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);
@@ -988,11 +1268,11 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
         if(swf_isDefiningTag(tag)) {
             int id = swf_GetDefineID(tag);
             idtable[id].tag = tag;
-            idtable[id].bbox = rfx_alloc(sizeof(SRECT));
+            idtable[id].bbox = (SRECT*)rfx_alloc(sizeof(SRECT));
             *idtable[id].bbox = swf_GetDefineBBox(tag);
 
             if(swf_isShapeTag(tag)) {
-                SHAPE2* shape = rfx_calloc(sizeof(SHAPE2));
+                SHAPE2* shape = (SHAPE2*)rfx_calloc(sizeof(SHAPE2));
                 swf_ParseDefineShape(tag, shape);
                 idtable[id].type = shape_type;
                 idtable[id].obj.shape = shape;
@@ -1004,47 +1284,41 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
 		free(data);
             } else if(tag->id == ST_DEFINEFONT ||
                       tag->id == ST_DEFINEFONT2) {
-                //swf_FontExtract(swf,id,&idtable[id].font);
-                idtable[id].obj.font = 0;
+		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_PLACEOBJECT || 
-                  tag->id == ST_PLACEOBJECT2) {
-            SWFPLACEOBJECT p;
-            swf_GetPlaceObject(tag, &p);
-            /* TODO: add move and deletion */
-            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=0;t<numplacements;t++) {
-        SWFPLACEOBJECT*p = &placements[t];
-        int id = p->id;
-            
-        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, &p->matrix, &p->cxform, p->depth, p->clipdepth);
-        } else if(idtable[id].type == text_type) {
-	    /* TODO */
-        } else {
-            fprintf(stderr, "Unknown/Unsupported Object Type for id %d: %s\n", id, swf_TagGetName(idtable[id].tag));
+            } 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) {
@@ -1057,10 +1331,23 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
                 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(placements);
     free(idtable);
-    free(depthtable);
 }
-
+