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