fixed memory usage bug.
[swftools.git] / lib / modules / swfrender.c
1 /* swfrender.c
2
3    functions for rendering swf content
4       
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2004 Mederra Oy <http://www.mederra.fi>
9    Copyright (c) 2004 Matthias Kramm
10  
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 2 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software
23    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
24
25 #include <assert.h>
26
27 typedef struct _dummyshape
28 {
29     SHAPE2*shape;
30     //CXFORM //TODO
31     struct _dummyshape*next;
32 } dummyshape_t;
33
34 typedef struct _renderpoint
35 {
36     enum {clip_type, fill_type} type;
37     float fx; //for sorting
38     int x;
39     U32 depth;
40     U32 clipdepth;
41     SHAPELINE*shapeline;
42    
43     dummyshape_t*s;
44 } renderpoint_t;
45
46 /* 
47     enum {clip_type, solidfill_type, texturefill_type, gradientfill_type} type;
48     float fx;
49     int x;
50     U32 depth;
51     U32 clipdepth;
52
53     // solidfill;
54     RGBA color; 
55     
56     // texturefill
57     bitmap_t* bitmap;
58
59     // gradientfill
60     gradient_t* gradient;
61
62     // texture- & gradientfill;
63     U32 x,y;
64     U32 dx,dy;
65
66 */
67
68 typedef struct _renderline
69 {
70     TAG*points; //incremented in 128 byte steps
71 } renderline_t;
72
73 typedef struct _bitmap {
74     int width;
75     int height;
76     RGBA*data;
77     int id;
78     struct _bitmap*next;
79 } bitmap_t;
80
81 typedef struct _renderbuf_internal
82 {
83     renderline_t*lines;
84     bitmap_t*bitmaps;
85     char antialize;
86     int multiply;
87     int width2,height2;
88     dummyshape_t*dshapes;
89     dummyshape_t*dshapes_next;
90     RGBA*background;
91     int background_width, background_height;
92 } renderbuf_internal;
93
94 #define DEBUG 0
95
96 static inline void add_pixel(RENDERBUF*dest, float x, int y, renderpoint_t*p)
97 {
98     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
99     if(x >= i->width2 || y >= i->height2 || y<0) return;
100     p->x = (int)x;
101     p->fx = x;
102     swf_SetBlock(i->lines[y].points, (U8*)p, sizeof(renderpoint_t));
103 }
104
105 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
106    problem appears to often */
107 #define CUT 0.5
108
109 static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p)
110 {
111     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
112     double diffx, diffy;
113     double ny1, ny2, stepx;
114 /*    if(DEBUG&4) {
115         int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
116         printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
117     }*/
118
119     y1=y1*i->multiply;
120     y2=y2*i->multiply;
121     x1=x1*i->multiply;
122     x2=x2*i->multiply;
123     
124     y1 = y1/20.0;
125     y2 = y2/20.0;
126     x1 = x1/20.0;
127     x2 = x2/20.0;
128
129     if(y2 < y1) {
130         double x;
131         double y;
132         x = x1;x1 = x2;x2=x;
133         y = y1;y1 = y2;y2=y;
134     }
135     
136     diffx = x2 - x1;
137     diffy = y2 - y1;
138     
139     ny1 = (int)(y1)+CUT;
140     ny2 = (int)(y2)+CUT;
141
142     if(ny1 < y1) {
143         ny1 = (int)(y1) + 1.0 + CUT;
144     }
145     if(ny2 >= y2) {
146         ny2 = (int)(y2) - 1.0 + CUT;
147     }
148
149     if(ny1 > ny2)
150         return;
151
152     stepx = diffx/diffy;
153     x1 = x1 + (ny1-y1)*stepx;
154     x2 = x2 + (ny2-y2)*stepx;
155
156     {
157         int posy=(int)ny1;
158         int endy=(int)ny2;
159         double posx=0;
160         double startx = x1;
161
162         while(posy<=endy) {
163             float xx = (float)(startx + posx);
164             add_pixel(buf, xx ,posy, p);
165             posx+=stepx;
166             posy++;
167         }
168     }
169 }
170 #define PI 3.14159265358979
171 static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double y2, int width, renderpoint_t*p)
172 {
173     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
174
175     double dx = x2-x1;
176     double dy = y2-y1;
177     double sd;
178     double d;
179
180     int t;
181     int segments;
182     double lastx,lasty;
183     double vx,vy;
184     double xx,yy;
185    
186     /* The Flash Player does this, too. This means every line is always at least
187        one pixel wide */
188     width += 20;
189
190     sd = (double)dx*(double)dx+(double)dy*(double)dy;
191     d = sqrt(sd);
192
193     if(!dx && !dy) {
194         vx = 1;
195         vy = 0;
196     } else {
197         vx = ( dy/d);
198         vy = (-dx/d);
199     }
200
201     segments = width/2;
202     if(segments < 2)
203         segments = 2;
204
205     segments = 8;
206
207     vx=vx*width*0.5;
208     vy=vy*width*0.5;
209
210     xx = x2+vx;
211     yy = y2+vy;
212     add_line(buf, x1+vx, y1+vy, xx, yy, p);
213     lastx = xx;
214     lasty = yy;
215     for(t=1;t<segments;t++) {
216         double s = sin(t*PI/segments);
217         double c = cos(t*PI/segments);
218         xx = (x2 + vx*c - vy*s);
219         yy = (y2 + vx*s + vy*c);
220         add_line(buf, lastx, lasty, xx, yy, p);
221         lastx = xx;
222         lasty = yy;
223     }
224     
225     xx = (x2-vx);
226     yy = (y2-vy);
227     add_line(buf, lastx, lasty, xx, yy, p);
228     lastx = xx;
229     lasty = yy;
230     xx = (x1-vx);
231     yy = (y1-vy);
232     add_line(buf, lastx, lasty, xx, yy, p);
233     lastx = xx;
234     lasty = yy;
235     for(t=1;t<segments;t++) {
236         double s = sin(t*PI/segments);
237         double c = cos(t*PI/segments);
238         xx = (x1 - vx*c + vy*s);
239         yy = (y1 - vx*s - vy*c);
240         add_line(buf, lastx, lasty, xx, yy, p);
241         lastx = xx;
242         lasty = yy;
243     }
244     add_line(buf, lastx, lasty, (x1+vx), (y1+vy), p);
245 }
246
247 static inline void transform_point(MATRIX*m, int x, int y, int*dx, int*dy)
248 {
249     SPOINT p,d;
250     p.x = x;
251     p.y = y;
252     d = swf_TurnPoint(p, m);
253     *dx = d.x;
254     *dy = d.y;
255 }
256
257 static int compare_renderpoints(const void * _a, const void * _b)
258 {
259     renderpoint_t*a = (renderpoint_t*)_a;
260     renderpoint_t*b = (renderpoint_t*)_b;
261     if(a->fx < b->fx) return -1;
262     if(a->fx > b->fx) return 1;
263     return 0;
264 }
265
266 void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, char antialize, int multiply)
267 {
268     renderbuf_internal*i;
269     int y;
270     memset(buf, 0, sizeof(RENDERBUF));
271     buf->width = width*multiply;
272     buf->height = height*multiply;
273     buf->posx = posx;
274     buf->posy = posy;
275     buf->internal = (renderbuf_internal*)rfx_calloc(sizeof(renderbuf_internal));
276     i = (renderbuf_internal*)buf->internal;
277     i->antialize = !!antialize;
278     i->multiply = antialize?multiply*2:multiply;
279     i->height2 = antialize?2*buf->height:buf->height;
280     i->width2 = antialize?2*buf->width:buf->width;
281     i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
282     for(y=0;y<i->height2;y++) {
283         i->lines[y].points = swf_InsertTag(0, 0);
284     }
285 }
286 void swf_Render_SetBackground(RENDERBUF*buf, RGBA*img, int width, int height)
287 {
288     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
289     RGBA*bck = (RGBA*)rfx_alloc(sizeof(RGBA)*width*height);
290     memcpy(bck, img, sizeof(RGBA)*width*height);
291     i->background = bck;
292     i->background_width = width;
293     i->background_height = height;
294 }
295 void swf_Render_SetBackgroundColor(RENDERBUF*buf, RGBA color)
296 {
297     swf_Render_SetBackground(buf, &color, 1, 1);
298 }
299 void swf_Render_AddImage(RENDERBUF*buf, U16 id, RGBA*img, int width, int height)
300 {
301     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
302
303     bitmap_t*bm = rfx_calloc(sizeof(bitmap_t));
304     bm->id = id;
305     bm->width = width;
306     bm->height = height;
307     bm->data = img;
308
309     bm->next = i->bitmaps;
310     i->bitmaps = bm;
311 }
312 void swf_Render_ClearCanvas(RENDERBUF*dest)
313 {
314     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
315     int y;
316     for(y=0;y<i->height2;y++) {
317         swf_ClearTag(i->lines[y].points);
318     }
319 }
320 void swf_Render_Delete(RENDERBUF*dest)
321 {
322     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
323     int y;
324     bitmap_t*b = i->bitmaps;
325     dummyshape_t*d = i->dshapes;
326
327     if(i->background) {
328         free(i->background);i->background=0;
329     }
330
331     /* delete line buffers */
332     for(y=0;y<i->height2;y++) {
333         swf_DeleteTag(i->lines[y].points);
334         i->lines[y].points = 0;
335     }
336
337     while(d) {
338         dummyshape_t*next = d->next;
339         swf_Shape2Free(d->shape);
340         free(d->shape);d->shape=0;
341         free(d);
342         d=next;
343     }
344     i->dshapes = 0;
345     
346     /* delete bitmaps */
347     while(b) {
348         bitmap_t*next = b->next;
349         //free(b->data);b->data=0;
350         rfx_free(b);
351         b = next;
352     }
353
354     rfx_free(i->lines); i->lines = 0;
355     rfx_free(dest->internal); dest->internal = 0;
356 }
357
358 static void swf_Render_AddShape(RENDERBUF*dest,dummyshape_t*s)
359 {
360     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
361
362     s->next = 0;
363     if(i->dshapes_next)
364         i->dshapes_next->next = s;
365     i->dshapes_next = s;
366     if(!i->dshapes) {
367         i->dshapes = s;
368     }
369 }
370
371 static SHAPE2* linestyle2fillstyle(SHAPE2*shape)
372 {
373     SHAPE2*s = rfx_calloc(sizeof(SHAPE2));
374     int t;
375     s->numfillstyles = shape->numlinestyles;
376     s->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles);
377     s->lines = (SHAPELINE*)rfx_calloc(sizeof(SHAPELINE)*shape->numlinestyles);
378     for(t=0;t<shape->numlinestyles;t++) {
379         s->lines[t].fillstyle0 = t+1;
380         s->fillstyles[t].type = FILL_SOLID;
381         s->fillstyles[t].color = shape->linestyles[t].color;
382     }
383     return s;
384 }
385
386 void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _depth,U16 _clipdepth)
387 {
388     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
389     
390     SHAPELINE*line = shape->lines;
391     int x=0,y=0;
392     MATRIX mat = *m;
393     SHAPE2* lshape = 0;
394
395     renderpoint_t p, lp;
396     memset(&p, 0, sizeof(renderpoint_t));
397     memset(&lp, 0, sizeof(renderpoint_t));
398     
399     p.type = _clipdepth?clip_type:fill_type;
400     p.depth = _depth << 16;
401     p.clipdepth = _clipdepth << 16;
402
403     mat.tx -= dest->posx*20;
404     mat.ty -= dest->posy*20;
405
406     if(shape->numfillstyles) {
407         dummyshape_t*fshape = rfx_calloc(sizeof(dummyshape_t));
408         int t;
409         SHAPE2* s2 = swf_Shape2Clone(shape);
410        
411         fshape->shape = s2;
412
413         p.s = fshape;
414
415         /* multiply fillstyles matrices with placement matrix-
416            important for texture and gradient fill */
417         for(t=0;t<s2->numfillstyles;t++) {
418             MATRIX nm;
419             swf_MatrixJoin(&nm, &s2->fillstyles[t].m, &mat); //TODO: is this the right order?
420             nm.sx *= i->multiply;
421             nm.sy *= i->multiply;
422             nm.r0 *= i->multiply;
423             nm.r1 *= i->multiply;
424             nm.tx *= i->multiply;
425             nm.ty *= i->multiply;
426             s2->fillstyles[t].m = nm;
427         }
428
429         /* add this shape to the global shape list, for deallocing */
430         swf_Render_AddShape(dest, fshape);
431     }
432
433     if(shape->numlinestyles) {
434         dummyshape_t*dshape = rfx_calloc(sizeof(dummyshape_t));
435         
436         lshape = linestyle2fillstyle(shape);
437             
438         lp.type = fill_type;
439         lp.s = dshape;
440         lp.depth = (_depth << 16)+1;
441
442         dshape->shape = lshape;
443
444         /* add this shape to the global shape list, for deallocing */
445         swf_Render_AddShape(dest, dshape);
446     }
447
448     if(p.clipdepth) {
449         /* reverse shape */
450         p.shapeline = 0;
451         add_line(dest, -20, 0, -20, i->height2*20, &p);
452     }
453
454     while(line)
455     {
456         int x1,y1,x2,y2,x3,y3;
457
458         p.shapeline = line;
459
460         if(line->type == moveTo) {
461         } else if(line->type == lineTo) {
462             if(DEBUG&4) {
463                 int l;
464                 x1 = x;
465                 y1 = y;
466                 x2 = line->x;
467                 y2 = line->y;
468                 l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
469                 printf("%d - %.2f/%.2f -> %.2f/%.2f ", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
470             }
471
472             transform_point(&mat, x, y, &x1, &y1);
473             transform_point(&mat, line->x, line->y, &x3, &y3);
474             
475             if(line->linestyle && ! p.clipdepth) {
476                 lp.shapeline = &lshape->lines[line->linestyle-1];
477                 add_solidline(dest, x1, y1, x3, y3, shape->linestyles[line->linestyle-1].width, &lp);
478                 lp.depth++;
479             }
480             if(line->fillstyle0 || line->fillstyle1) {
481                 assert(shape->numfillstyles);
482                 add_line(dest, x1, y1, x3, y3, &p);
483             }
484             
485             if(DEBUG&4) printf("\n");
486         } else if(line->type == splineTo) {
487             int c,t,parts,qparts;
488             double xx,yy;
489             
490             transform_point(&mat, x, y, &x1, &y1);
491             transform_point(&mat, line->sx, line->sy, &x2, &y2);
492             transform_point(&mat, line->x, line->y, &x3, &y3);
493             
494             c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
495             xx=x1;
496             yy=y1;
497
498             parts = (int)(sqrt(c)/3);
499             if(!parts) parts = 1;
500
501             if(DEBUG&4)
502             {
503                 printf("spline %.2f/%.2f -(%.2f/%.2f)-> %.2f/%.2f (c=%d, %d parts)", 
504                         x1/20.0, y1/20.0, 
505                         x2/20.0, y2/20.0, 
506                         x3/20.0, y3/20.0, c, parts);
507             }
508
509             for(t=1;t<=parts;t++) {
510                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
511                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
512                 
513                 if(line->linestyle && ! p.clipdepth) {
514                     lp.shapeline = &lshape->lines[line->linestyle-1];
515                     add_solidline(dest, xx, yy, nx, ny, shape->linestyles[line->linestyle-1].width, &lp);
516                     lp.depth++;
517                 }
518                 if(line->fillstyle0 || line->fillstyle1) {
519                     assert(shape->numfillstyles);
520                     add_line(dest, (int)xx, (int)yy, (int)nx, (int)ny, &p);
521                 }
522
523                 xx = nx;
524                 yy = ny;
525             }
526             if(DEBUG&4) 
527                 printf("\n");
528         }
529         x = line->x;
530         y = line->y;
531         line = line->next;
532     }
533 }
534
535 typedef struct _layer {
536     int fillid;
537     U32 clipdepth;
538     renderpoint_t*p;
539     struct _layer*next;
540     struct _layer*prev;
541 } layer_t;
542
543 typedef struct {
544     layer_t*layers;
545 } state_t;
546
547 static RGBA color_red = {255,255,0,0};
548 static RGBA color_white = {255,255,255,255};
549
550 static void fill_plain(RGBA*line, int x1, int x2, RGBA col)
551 {
552     int x = x1;
553     if(col.a!=255) {
554         int ainv = 255-col.a;
555         col.r = (col.r*col.a)>>8;
556         col.g = (col.g*col.a)>>8;
557         col.b = (col.b*col.a)>>8;
558         col.a = 255;
559         do {
560             line[x].r = ((line[x].r*ainv)>>8)+col.r;
561             line[x].g = ((line[x].g*ainv)>>8)+col.g;
562             line[x].b = ((line[x].b*ainv)>>8)+col.b;
563             line[x].a = 255;
564         } while(++x<x2);
565     } else {
566         do {
567             line[x] = col;
568         } while(++x<x2);
569     }
570 }
571
572 static void fill_bitmap(RGBA*line, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clip)
573 {
574     int x = x1;
575     double m11=m->sx/65536.0, m21=m->r1/65536.0;
576     double m12=m->r0/65536.0, m22=m->sy/65536.0;
577     double rx = m->tx/20.0;
578     double ry = m->ty/20.0;
579     double det = m11*m22 - m12*m21;
580     if(fabs(det) < 0.0005) { 
581         /* x direction equals y direction- the image is invisible */
582         return;
583     }
584     det = 20.0/det;
585  
586     if(!b->width || !b->height) {
587         fill_plain(line, x1, x2, color_red);
588         return;
589     }
590
591     do {
592         RGBA col;
593         int xx = (int)((  (x - rx) * m22 - (y - ry) * m21)*det);
594         int yy = (int)((- (x - rx) * m12 + (y - ry) * m11)*det);
595         int ainv;
596         
597         if(clip) {
598             if(xx<0) xx=0;
599             if(xx>=b->width) xx = b->width-1;
600             if(yy<0) yy=0;
601             if(yy>=b->height) yy = b->height-1;
602         } else {
603             xx %= b->width;
604             yy %= b->height;
605         }
606
607         col = b->data[yy*b->width+xx];
608         ainv = 255-col.a;
609
610         line[x].r = ((line[x].r*ainv)>>8)+col.r;
611         line[x].g = ((line[x].g*ainv)>>8)+col.g;
612         line[x].b = ((line[x].b*ainv)>>8)+col.b;
613         line[x].a = 255;
614     } while(++x<x2);
615 }
616
617 static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*state)
618 {
619     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
620     U32 clipdepth;
621
622     layer_t*l = state->layers;
623
624     if(x1>=x2) //zero width? nothing to do.
625         return;
626
627     clipdepth = 0;
628     while(l) {
629         if(l->p->depth < clipdepth) {
630             if(DEBUG&2) printf("(clipped)");
631             l = l->next;
632             continue;
633         }
634         if(l->fillid < 0 /*clip*/) {
635             if(DEBUG&2) printf("(add clip %d)", l->clipdepth);
636             if(l->clipdepth > clipdepth)
637                 clipdepth = l->clipdepth;
638         } else if(l->fillid == 0) {
639             /* not filled. TODO: we should never add those in the first place */
640             if(DEBUG&2)
641                 printf("(not filled)");
642         } else if(l->fillid > l->p->s->shape->numfillstyles) {
643             fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->s->shape->numlinestyles);
644         } else {
645             FILLSTYLE*f;
646             if(DEBUG&2) 
647                 printf("(%d -> %d style %d)", x1, x2, l->fillid);
648
649             f = &l->p->s->shape->fillstyles[l->fillid-1];
650
651             if(f->type == FILL_SOLID) {
652                 /* plain color fill */
653                 fill_plain(line, x1, x2, f->color);
654             } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) {
655                 /* TODO: optimize (do this in add_pixel()?) */
656                 bitmap_t* b = i->bitmaps;
657                 while(b && b->id != f->id_bitmap) {
658                     b = b->next;
659                 }
660                 if(!b) {
661                     fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap);
662                     fill_plain(line, x1, x2, color_red);
663                 } else {
664                     //done in swf_RenderShape now
665                     //MATRIX m = f->m;
666                     //m.tx -= dest->posx*20;
667                     //m.ty -= dest->posy*20;
668                     //m.sx *= i->multiply;
669                     //m.sy *= i->multiply;
670                     //m.r0 *= i->multiply;
671                     //m.r1 *= i->multiply;
672                     //m.tx *= i->multiply;
673                     //m.ty *= i->multiply;
674                     fill_bitmap(line, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0);
675                 }
676             }
677         }
678         l = l->next;
679     }
680 }
681
682 static void search_layer(state_t*state, int depth, layer_t**before, layer_t**self, layer_t**after)
683 {
684     layer_t*last=0,*l = state->layers;
685     while(l && l->p->depth < depth) {
686         last = l;
687         l = l->next;
688     }
689     *before = last;
690     if(l && l->p->depth == depth)
691         *self = l;
692     else
693         *after = l;
694 }
695 static void delete_layer(state_t*state, layer_t*todel)
696 {
697     layer_t*before=todel->prev;
698     layer_t*next = todel->next;
699     rfx_free(todel);
700     if(!before) {
701         state->layers = next;
702         if(next)
703             next->prev = 0;
704     } else {
705         before->next = next;
706         if(before->next)
707             before->next->prev = before;
708     }
709 }
710 static void add_layer(state_t*state, layer_t*before, layer_t*toadd)
711 {
712     if(!before) {
713         toadd->next = state->layers;
714         toadd->prev = 0;
715         state->layers=toadd;
716     } else {
717         toadd->next = before->next;
718         toadd->prev = before;
719         before->next = toadd;
720     }
721     if(toadd->next)
722         toadd->next->prev = toadd;
723 }
724 static void free_layers(state_t* state)
725 {
726     layer_t*l = state->layers;
727     while(l) {
728         layer_t*next = l->next;
729         rfx_free(l);
730         l = next;
731     }
732 }
733
734 static void change_state(int y, state_t* state, renderpoint_t*p)
735 {
736     layer_t*before=0, *self=0, *after=0;
737
738     if(DEBUG&2) { 
739         printf("[%s(%d,%d)/%d/%d-%d]", p->type==clip_type?"C":"F", p->x, y, p->depth, p->shapeline->fillstyle0, p->shapeline->fillstyle1);
740     }
741
742     search_layer(state, p->depth, &before, &self, &after);
743
744     if(self) {
745         /* shape update */
746         if(self->fillid<0 || !p->shapeline->fillstyle0 || !p->shapeline->fillstyle1) {
747             /* filling/clipping ends */
748             if(DEBUG&2) printf("<D>");
749             
750             delete_layer(state, self);
751         } else { 
752             /*both fill0 and fill1 are set- exchange the two, updating the layer */
753             if(self->fillid == p->shapeline->fillstyle0) {
754                 self->fillid = p->shapeline->fillstyle1;
755                 self->clipdepth = 0;
756                 self->p = p;
757                 if(DEBUG&2) printf("<X>");
758             } else if(self->fillid == p->shapeline->fillstyle1) {
759                 self->fillid = p->shapeline->fillstyle0;
760                 self->clipdepth = 0;
761                 self->p = p;
762                 if(DEBUG&2) printf("<X>");
763             } else {
764                 /* buggy shape. keep everything as-is. */
765                 if(DEBUG&2) printf("<!>");
766                 //fprintf(stderr, "<line %d: bad swap>\n", y);
767             }
768         }
769         return;
770     } else {
771         layer_t* n = 0;
772         if(p->shapeline && p->shapeline->fillstyle0 && p->shapeline->fillstyle1) {
773             /* this is a hack- a better way would be to make sure that
774                we always get (0,32), (32, 33), (33, 0) in the right order if
775                they happen to fall on the same pixel.
776                (not: (0,32), (33, 0), (32, 33))
777             */
778             fprintf(stderr, "<line %d: both fillstyles set while not inside shape>\n", y);
779             return;
780         }
781         
782         n = rfx_calloc(sizeof(layer_t));
783
784         if(DEBUG&2) printf("<+>");
785
786         if(p->type == clip_type) {
787             /* add clipping */
788             n->fillid = -1;
789             n->clipdepth = p->clipdepth;
790             n->p = p;
791         } else {
792             n->fillid = p->shapeline->fillstyle0 ? p->shapeline->fillstyle0 : p->shapeline->fillstyle1;
793             n->clipdepth = 0;
794             n->p = p;
795         }
796
797         add_layer(state, before, n);
798     }
799 }
800
801 RGBA* swf_Render(RENDERBUF*dest)
802 {
803     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
804     RGBA* img = (RGBA*)rfx_alloc(sizeof(RGBA)*dest->width*dest->height);
805     int y;
806     long memory = 0;
807     RGBA * line1 = rfx_alloc(sizeof(RGBA)*i->width2);
808     RGBA * line2 = rfx_alloc(sizeof(RGBA)*i->width2);
809
810     for(y=0;y<i->height2;y++) {
811         TAG*tag = i->lines[y].points;
812         int n;
813         int size = sizeof(renderpoint_t);
814         int num = tag->len / size;
815         RGBA*line = line1;
816         state_t state;
817         memset(&state, 0, sizeof(state_t));
818
819         if((y&1) && i->antialize)
820             line = line2;
821
822
823         if(!i->background) {
824             memset(line, 0, sizeof(RGBA)*i->width2);
825         } else {
826             int x,xx;
827             int xstep=i->background_width*65536/i->width2;
828             RGBA*src = &i->background[(i->background_height*y/i->height2)*i->background_width];
829             for(x=0,xx=0;x<i->width2;x++,xx+=xstep) {
830                 line[x] = src[xx>>16];
831             }
832         }
833         memory += tag->memsize;
834         qsort(tag->data, num, size, compare_renderpoints);
835         for(n=0;n<num;n++) {
836             renderpoint_t*p = (renderpoint_t*)&tag->data[size*n];
837             renderpoint_t*next= n<num-1?(renderpoint_t*)&tag->data[size*(n+1)]:0;
838             int startx = p->x;
839             int endx = next?next->x:i->width2;
840             if(endx > i->width2)
841                 endx = i->width2;
842             if(startx < 0)
843                 startx = 0;
844
845             change_state(y, &state, p);
846
847             fill(dest, line, y, startx, endx, &state);
848             if(endx == i->width2)
849                 break;
850         }
851         free_layers(&state);
852         if(DEBUG&2) printf("\n");
853
854         if(!i->antialize) {
855             memcpy(&img[y*dest->width], line, sizeof(RGBA)*dest->width);
856         } else {
857             if(y&1) {
858                 int x;
859                 RGBA* p = &img[(y/2)*dest->width];
860                 for(x=0;x<dest->width;x++) {
861                     RGBA*p1 = &line1[x*2];
862                     RGBA*p2 = &line1[x*2+1];
863                     RGBA*p3 = &line2[x*2];
864                     RGBA*p4 = &line2[x*2+1];
865                     p[x].r = (p1->r + p2->r + p3->r + p4->r)/4;
866                     p[x].g = (p1->g + p2->g + p3->g + p4->g)/4;
867                     p[x].b = (p1->b + p2->b + p3->b + p4->b)/4;
868                     p[x].a = (p1->a + p2->a + p3->a + p4->a)/4;
869                 }
870             }
871         }
872     }
873     free(line1);
874     free(line2);
875     
876     if(DEBUG) printf("\nMemory used: %d\n", memory);
877 #ifdef STATISTICS
878     if(DEBUG) printf("Statistics:\n");
879     if(DEBUG) printf("Average layer depth: %f\n", (double)layers/layernum);
880 #endif
881
882
883     return img;
884 }