added some consistency checking for id table
[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 /* one bit flag: */
28 #define clip_type 0
29 #define fill_type 1
30
31 typedef struct _renderpoint
32 {
33     float x;
34     U32 depth;
35
36     SHAPELINE*shapeline;
37     SHAPE2*s;
38     
39 } renderpoint_t;
40
41 /* 
42     enum {clip_type, solidfill_type, texturefill_type, gradientfill_type} type;
43     float fx;
44     int x;
45     U32 depth;
46     U32 clipdepth;
47
48     // solidfill;
49     RGBA color; 
50     
51     // texturefill
52     bitmap_t* bitmap;
53
54     // gradientfill
55     gradient_t* gradient;
56
57     // texture- & gradientfill;
58     U32 x,y;
59     U32 dx,dy;
60
61 */
62
63 typedef struct _renderline
64 {
65     TAG*points; //incremented in 128 byte steps
66     int num;
67     U32 pending_clipdepth;
68 } renderline_t;
69
70 typedef struct _bitmap {
71     int width;
72     int height;
73     RGBA*data;
74     int id;
75     struct _bitmap*next;
76 } bitmap_t;
77
78 typedef struct _renderbuf_internal
79 {
80     renderline_t*lines;
81     bitmap_t*bitmaps;
82     int antialize;
83     int multiply;
84     int width2,height2;
85     int shapes;
86     int ymin, ymax;
87     
88     RGBA* img;
89     int* zbuf; 
90 } renderbuf_internal;
91
92 #define DEBUG 0
93
94 static inline void add_pixel(RENDERBUF*dest, float x, int y, renderpoint_t*p)
95 {
96     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
97     if(x >= i->width2 || y >= i->height2 || y<0) return;
98     p->x = x;
99     if(y<i->ymin) i->ymin = y;
100     if(y>i->ymax) i->ymax = y;
101
102     i->lines[y].num++;
103     swf_SetBlock(i->lines[y].points, (U8*)p, sizeof(renderpoint_t));
104 }
105
106 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
107    problem appears to often */
108 #define CUT 0.5
109
110 #define INT(x) ((int)((x)+16)-16)
111
112 static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p)
113 {
114     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
115     double diffx, diffy;
116     double ny1, ny2, stepx;
117 /*    if(DEBUG&4) {
118         int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
119         printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]\n", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
120     }*/
121     assert(p->shapeline);
122
123     y1=y1*i->multiply;
124     y2=y2*i->multiply;
125     x1=x1*i->multiply;
126     x2=x2*i->multiply;
127     
128     y1 = y1/20.0;
129     y2 = y2/20.0;
130     x1 = x1/20.0;
131     x2 = x2/20.0;
132
133     if(y2 < y1) {
134         double x;
135         double y;
136         x = x1;x1 = x2;x2=x;
137         y = y1;y1 = y2;y2=y;
138     }
139     
140     diffx = x2 - x1;
141     diffy = y2 - y1;
142     
143     ny1 = INT(y1)+CUT;
144     ny2 = INT(y2)+CUT;
145
146     if(ny1 < y1) {
147         ny1 = INT(y1) + 1.0 + CUT;
148     }
149     if(ny2 >= y2) {
150         ny2 = INT(y2) - 1.0 + CUT;
151     }
152
153     if(ny1 > ny2)
154         return;
155
156     stepx = diffx/diffy;
157     x1 = x1 + (ny1-y1)*stepx;
158     x2 = x2 + (ny2-y2)*stepx;
159
160     {
161         int posy=INT(ny1);
162         int endy=INT(ny2);
163         double posx=0;
164         double startx = x1;
165
166         while(posy<=endy) {
167             float xx = (float)(startx + posx);
168             add_pixel(buf, xx ,posy, p);
169             posx+=stepx;
170             posy++;
171         }
172     }
173 }
174 #define PI 3.14159265358979
175 static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double y2, double width, renderpoint_t*p)
176 {
177     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
178
179     double dx = x2-x1;
180     double dy = y2-y1;
181     double sd;
182     double d;
183
184     int t;
185     int segments;
186     double lastx,lasty;
187     double vx,vy;
188     double xx,yy;
189   
190     /* Make sure the line is always at least one pixel wide */
191 #ifdef LINEMODE1
192     /* That's what Macromedia's Player does at least at zoom level >= 1.  */
193     width += 20;
194 #else
195     /* That's what Macromedia's Player seems to do at zoom level 0.  */
196     /* TODO: needs testing */
197
198     /* TODO: how does this interact with scaling? */
199     if(width * i->multiply < 20)
200         width = 20 / i->multiply;
201 #endif
202
203     sd = (double)dx*(double)dx+(double)dy*(double)dy;
204     d = sqrt(sd);
205
206     if(!dx && !dy) {
207         vx = 1;
208         vy = 0;
209     } else {
210         vx = ( dy/d);
211         vy = (-dx/d);
212     }
213
214     segments = width/2;
215     if(segments < 2)
216         segments = 2;
217
218     segments = 8;
219
220     vx=vx*width*0.5;
221     vy=vy*width*0.5;
222
223     xx = x2+vx;
224     yy = y2+vy;
225     add_line(buf, x1+vx, y1+vy, xx, yy, p);
226     lastx = xx;
227     lasty = yy;
228     for(t=1;t<segments;t++) {
229         double s = sin(t*PI/segments);
230         double c = cos(t*PI/segments);
231         xx = (x2 + vx*c - vy*s);
232         yy = (y2 + vx*s + vy*c);
233         add_line(buf, lastx, lasty, xx, yy, p);
234         lastx = xx;
235         lasty = yy;
236     }
237     
238     xx = (x2-vx);
239     yy = (y2-vy);
240     add_line(buf, lastx, lasty, xx, yy, p);
241     lastx = xx;
242     lasty = yy;
243     xx = (x1-vx);
244     yy = (y1-vy);
245     add_line(buf, lastx, lasty, xx, yy, p);
246     lastx = xx;
247     lasty = yy;
248     for(t=1;t<segments;t++) {
249         double s = sin(t*PI/segments);
250         double c = cos(t*PI/segments);
251         xx = (x1 - vx*c + vy*s);
252         yy = (y1 - vx*s - vy*c);
253         add_line(buf, lastx, lasty, xx, yy, p);
254         lastx = xx;
255         lasty = yy;
256     }
257     add_line(buf, lastx, lasty, (x1+vx), (y1+vy), p);
258 }
259
260 static inline void transform_point(MATRIX*m, int x, int y, int*dx, int*dy)
261 {
262     SPOINT p,d;
263     p.x = x;
264     p.y = y;
265     d = swf_TurnPoint(p, m);
266     *dx = d.x;
267     *dy = d.y;
268 }
269
270 static int compare_renderpoints(const void * _a, const void * _b)
271 {
272     renderpoint_t*a = (renderpoint_t*)_a;
273     renderpoint_t*b = (renderpoint_t*)_b;
274     if(a->x < b->x) return -1;
275     if(a->x > b->x) return 1;
276     return 0;
277 }
278
279 void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, int antialize, int multiply)
280 {
281     renderbuf_internal*i;
282     int y;
283     memset(buf, 0, sizeof(RENDERBUF));
284     buf->width = width*multiply;
285     buf->height = height*multiply;
286     buf->posx = posx;
287     buf->posy = posy;
288     buf->internal = (renderbuf_internal*)rfx_calloc(sizeof(renderbuf_internal));
289     i = (renderbuf_internal*)buf->internal;
290     if(antialize < 1)
291         antialize = 1;
292     i->antialize = antialize;
293     i->multiply = multiply*antialize;
294     i->height2 = antialize*buf->height;
295     i->width2 = antialize*buf->width;
296     i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
297     for(y=0;y<i->height2;y++) {
298         memset(&i->lines[y], 0, sizeof(renderline_t));
299         i->lines[y].points = swf_InsertTag(0, 0);
300         i->lines[y].num = 0;
301     }
302     i->zbuf = (int*)rfx_calloc(sizeof(int)*i->width2*i->height2);
303     i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
304     i->shapes = 0;
305     i->ymin = 0x7fffffff;
306     i->ymax = -0x80000000;
307 }
308 void swf_Render_SetBackground(RENDERBUF*buf, RGBA*img, int width, int height)
309 {
310     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
311     int x,xx,y,yy;
312     int xstep=width*65536/i->width2;
313     int ystep=height*65536/i->height2;
314     if(i->shapes) {
315         fprintf(stderr, "rfxswf: Warning: swf_Render_SetBackground() called after drawing shapes\n");
316     }
317     for(y=0,yy=0;y<i->height2;y++,yy+=ystep) {
318         RGBA*src = &img[(yy>>16) * width];
319         RGBA*line = &i->img[y * i->width2];
320         for(x=0,xx=0;x<i->width2;x++,xx+=xstep) {
321             line[x] = src[xx>>16];
322         }
323     }
324 }
325 void swf_Render_SetBackgroundColor(RENDERBUF*buf, RGBA color)
326 {
327     swf_Render_SetBackground(buf, &color, 1, 1);
328 }
329 void swf_Render_AddImage(RENDERBUF*buf, U16 id, RGBA*img, int width, int height)
330 {
331     renderbuf_internal*i = (renderbuf_internal*)buf->internal;
332
333     bitmap_t*bm = rfx_calloc(sizeof(bitmap_t));
334     bm->id = id;
335     bm->width = width;
336     bm->height = height;
337     bm->data = rfx_alloc(width*height*4);
338     memcpy(bm->data, img, width*height*4);
339
340     bm->next = i->bitmaps;
341     i->bitmaps = bm;
342 }
343 void swf_Render_ClearCanvas(RENDERBUF*dest)
344 {
345     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
346     int y;
347     for(y=0;y<i->height2;y++) {
348         swf_ClearTag(i->lines[y].points);
349     }
350     memset(i->zbuf, 0, sizeof(int)*i->width2*i->height2);
351     memset(i->img, 0, sizeof(RGBA)*i->width2*i->height2);
352 }
353 void swf_Render_Delete(RENDERBUF*dest)
354 {
355     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
356     int y;
357     bitmap_t*b = i->bitmaps;
358
359     /* delete canvas */
360     rfx_free(i->zbuf);
361     rfx_free(i->img);
362
363     /* delete line buffers */
364     for(y=0;y<i->height2;y++) {
365         swf_DeleteTag(i->lines[y].points);
366         i->lines[y].points = 0;
367     }
368
369     /* delete bitmaps */
370     while(b) {
371         bitmap_t*next = b->next;
372         free(b->data);b->data=0;
373         rfx_free(b);
374         b = next;
375     }
376
377     rfx_free(i->lines); i->lines = 0;
378     rfx_free(dest->internal); dest->internal = 0;
379 }
380
381 static SHAPE2* linestyle2fillstyle(SHAPE2*shape)
382 {
383     SHAPE2*s = rfx_calloc(sizeof(SHAPE2));
384     int t;
385     s->numfillstyles = shape->numlinestyles;
386     s->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles);
387     s->lines = (SHAPELINE*)rfx_calloc(sizeof(SHAPELINE)*shape->numlinestyles);
388     for(t=0;t<shape->numlinestyles;t++) {
389         s->lines[t].fillstyle0 = t+1;
390         s->fillstyles[t].type = FILL_SOLID;
391         s->fillstyles[t].color = shape->linestyles[t].color;
392     }
393     return s;
394 }
395
396 void swf_Process(RENDERBUF*dest, U32 clipdepth);
397
398 double matrixsize(MATRIX*m)
399 {
400     double l1 = sqrt((m->sx /65536.0) * (m->sx /65536.0) + (m->r0 /65536.0) * (m->r0/65536.0) );
401     double l2 = sqrt((m->r1 /65536.0) * (m->r1 /65536.0) + (m->sy /65536.0) * (m->sy/65536.0) );
402     return sqrt(l1*l2);
403 }
404
405 void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _depth,U16 _clipdepth)
406 {
407     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
408     
409     SHAPELINE*line;
410     int x=0,y=0;
411     MATRIX mat = *m;
412     SHAPE2* s2 = 0;
413     SHAPE2* lshape = 0;
414     renderpoint_t p, lp;
415     U32 clipdepth;
416     double widthmultiply = matrixsize(m);
417
418     memset(&p, 0, sizeof(renderpoint_t));
419     memset(&lp, 0, sizeof(renderpoint_t));
420     
421     clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0;
422     p.depth = _depth << 16;
423
424     mat.tx -= dest->posx*20;
425     mat.ty -= dest->posy*20;
426
427     s2 = swf_Shape2Clone(shape);
428     line = s2->lines;
429     if(shape->numfillstyles) {
430         int t;
431         p.s = s2;
432         /* multiply fillstyles matrices with placement matrix-
433            important for texture and gradient fill */
434         for(t=0;t<s2->numfillstyles;t++) {
435             MATRIX nm;
436             swf_MatrixJoin(&nm, &mat, &s2->fillstyles[t].m);
437             /*nm.sx *= i->multiply;
438             nm.sy *= i->multiply;
439             nm.r0 *= i->multiply;
440             nm.r1 *= i->multiply;
441             nm.tx *= i->multiply;
442             nm.ty *= i->multiply;*/
443             s2->fillstyles[t].m = nm;
444         }
445     }
446
447     if(shape->numlinestyles) {
448         lshape = linestyle2fillstyle(shape);
449         lp.s = lshape;
450         lp.depth = (_depth << 16)+1;
451     }
452
453
454     while(line)
455     {
456         int x1,y1,x2,y2,x3,y3;
457
458         if(line->type == moveTo) {
459         } else if(line->type == lineTo) {
460             transform_point(&mat, x, y, &x1, &y1);
461             transform_point(&mat, line->x, line->y, &x3, &y3);
462             
463             if(line->linestyle && ! clipdepth) {
464                 lp.shapeline = &lshape->lines[line->linestyle-1];
465                 add_solidline(dest, x1, y1, x3, y3, shape->linestyles[line->linestyle-1].width * widthmultiply, &lp);
466                 lp.depth++;
467             }
468             if(line->fillstyle0 || line->fillstyle1) {
469                 assert(shape->numfillstyles);
470                 p.shapeline = line;
471                 add_line(dest, x1, y1, x3, y3, &p);
472             }
473         } else if(line->type == splineTo) {
474             int c,t,parts,qparts;
475             double xx,yy;
476             
477             transform_point(&mat, x, y, &x1, &y1);
478             transform_point(&mat, line->sx, line->sy, &x2, &y2);
479             transform_point(&mat, line->x, line->y, &x3, &y3);
480             
481             c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
482             xx=x1;
483             yy=y1;
484
485             parts = (int)(sqrt(c)/3);
486             if(!parts) parts = 1;
487
488             for(t=1;t<=parts;t++) {
489                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
490                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
491                 
492                 if(line->linestyle && ! clipdepth) {
493                     lp.shapeline = &lshape->lines[line->linestyle-1];
494                     add_solidline(dest, xx, yy, nx, ny, shape->linestyles[line->linestyle-1].width * widthmultiply, &lp);
495                     lp.depth++;
496                 }
497                 if(line->fillstyle0 || line->fillstyle1) {
498                     assert(shape->numfillstyles);
499                     p.shapeline = line;
500                     add_line(dest, xx, yy, nx, ny, &p);
501                 }
502
503                 xx = nx;
504                 yy = ny;
505             }
506         }
507         x = line->x;
508         y = line->y;
509         line = line->next;
510     }
511     
512     swf_Process(dest, clipdepth);
513     
514     if(s2) {
515         swf_Shape2Free(s2);rfx_free(s2);s2=0;
516     }
517     if(lshape) {
518         swf_Shape2Free(lshape);rfx_free(lshape);lshape=0;
519     }
520
521 }
522
523 static RGBA color_red = {255,255,0,0};
524 static RGBA color_white = {255,255,255,255};
525 static RGBA color_black = {255,0,0,0};
526
527 static void fill_clip(RGBA*line, int*z, int y, int x1, int x2, U32 depth)
528 {
529     int x = x1;
530     if(x1>=x2)
531         return;
532     do {
533         if(depth > z[x]) {
534             z[x] = depth;
535         }
536     } while(++x<x2);
537 }
538
539
540 static void fill_solid(RGBA*line, int*z, int y, int x1, int x2, RGBA col, U32 depth)
541 {
542     int x = x1;
543
544     if(col.a!=255) {
545         int ainv = 255-col.a;
546         col.r = (col.r*col.a)>>8;
547         col.g = (col.g*col.a)>>8;
548         col.b = (col.b*col.a)>>8;
549         col.a = 255;
550         do {
551             if(depth >= z[x]) {
552                 line[x].r = ((line[x].r*ainv)>>8)+col.r;
553                 line[x].g = ((line[x].g*ainv)>>8)+col.g;
554                 line[x].b = ((line[x].b*ainv)>>8)+col.b;
555                 line[x].a = 255;
556                 z[x] = depth;
557             }
558         } while(++x<x2);
559     } else {
560         do {
561             if(depth >= z[x]) {
562                 line[x] = col;
563                 z[x] = depth;
564             }
565         } while(++x<x2);
566     }
567 }
568
569 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)
570 {
571     int x = x1;
572     
573     double m11= m->sx*fmultiply/65536.0, m21= m->r1*fmultiply/65536.0;
574     double m12= m->r0*fmultiply/65536.0, m22= m->sy*fmultiply/65536.0;
575     double rx = m->tx*fmultiply/20.0;
576     double ry = m->ty*fmultiply/20.0;
577
578     double det = m11*m22 - m12*m21;
579     if(fabs(det) < 0.0005) { 
580         /* x direction equals y direction- the image is invisible */
581         return;
582     }
583     det = 20.0/det;
584
585     if(!b->width || !b->height) {
586         fill_solid(line, z, y, x1, x2, color_red, depth);
587         return;
588     }
589
590     do {
591         if(depth >= z[x]) {
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(clipbitmap) {
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                 if(xx<0) xx += b->width;
606                 if(yy<0) yy += b->height;
607             }
608
609             col = b->data[yy*b->width+xx];
610             ainv = 255-col.a;
611
612             line[x].r = ((line[x].r*ainv)>>8)+col.r;
613             line[x].g = ((line[x].g*ainv)>>8)+col.g;
614             line[x].b = ((line[x].b*ainv)>>8)+col.b;
615             line[x].a = 255;
616             
617             z[x] = depth;
618         }
619     } while(++x<x2);
620 }
621
622 typedef struct _layer {
623     int fillid;
624     renderpoint_t*p;
625     struct _layer*next;
626     struct _layer*prev;
627 } layer_t;
628
629 typedef struct {
630     layer_t*layers;
631 } state_t;
632
633
634 static void fill(RENDERBUF*dest, RGBA*line, int*zline, int y, int x1, int x2, state_t*fillstate, U32 clipdepth)
635 {
636     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
637     int clip=1;
638
639     layer_t*l = fillstate->layers;
640
641     if(x1>=x2) //zero width? nothing to do.
642         return;
643     
644     while(l) {
645         if(l->fillid == 0) {
646             /* not filled. TODO: we should never add those in the first place */
647             if(DEBUG&2)
648                 printf("(not filled)");
649         } else if(l->fillid > l->p->s->numfillstyles) {
650             fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->s->numlinestyles);
651         } else if(clipdepth) {
652             /* filled region- not used for clipping */
653             clip = 0;
654         } else {
655             FILLSTYLE*f;
656             if(DEBUG&2) 
657                 printf("(%d -> %d style %d)", x1, x2, l->fillid);
658
659             f = &l->p->s->fillstyles[l->fillid-1];
660
661             if(f->type == FILL_SOLID) {
662                 /* plain color fill */
663                 fill_solid(line, zline, y, x1, x2, f->color, l->p->depth);
664             } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) {
665                 /* TODO: optimize (do this in add_pixel()?) */
666                 bitmap_t* b = i->bitmaps;
667                 while(b && b->id != f->id_bitmap) {
668                     b = b->next;
669                 }
670                 if(!b) {
671                     fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap);
672                     fill_solid(line, zline, y, x1, x2, color_red, l->p->depth);
673                 } else {
674                     fill_bitmap(line, zline, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0, l->p->depth, i->multiply);
675                 }
676             } else {
677                 fprintf(stderr, "Undefined fillmode: %02x\n", f->type);
678             }
679         }
680         l = l->next;
681     }
682     if(clip && clipdepth) {
683         fill_clip(line, zline, y, x1, x2, clipdepth);
684     }
685 }
686
687 static void search_layer(state_t*state, int depth, layer_t**before, layer_t**self, layer_t**after)
688 {
689     layer_t*last=0,*l = state->layers;
690     while(l && l->p->depth < depth) {
691         last = l;
692         l = l->next;
693     }
694     *before = last;
695     if(l && l->p->depth == depth)
696         *self = l;
697     else
698         *after = l;
699 }
700 static void delete_layer(state_t*state, layer_t*todel)
701 {
702     layer_t*before=todel->prev;
703     layer_t*next = todel->next;
704     rfx_free(todel);
705     if(!before) {
706         state->layers = next;
707         if(next)
708             next->prev = 0;
709     } else {
710         before->next = next;
711         if(before->next)
712             before->next->prev = before;
713     }
714 }
715 static void add_layer(state_t*state, layer_t*before, layer_t*toadd)
716 {
717     if(!before) {
718         toadd->next = state->layers;
719         toadd->prev = 0;
720         state->layers=toadd;
721     } else {
722         toadd->next = before->next;
723         toadd->prev = before;
724         before->next = toadd;
725     }
726     if(toadd->next)
727         toadd->next->prev = toadd;
728 }
729 static void free_layers(state_t* state)
730 {
731     layer_t*l = state->layers;
732     while(l) {
733         layer_t*next = l->next;
734         rfx_free(l);
735         l = next;
736     }
737 }
738
739 static void change_state(int y, state_t* state, renderpoint_t*p)
740 {
741     layer_t*before=0, *self=0, *after=0;
742
743     if(DEBUG&2) { 
744         printf("[(%d,%d)/%d/%d-%d]", p->x, y, p->depth, p->shapeline->fillstyle0, p->shapeline->fillstyle1);
745     }
746
747     search_layer(state, p->depth, &before, &self, &after);
748
749     if(self) {
750         /* shape update */
751         if(self->fillid<0/*??*/ || !p->shapeline->fillstyle0 || !p->shapeline->fillstyle1) {
752             /* filling ends */
753             if(DEBUG&2) printf("<D>");
754             
755             delete_layer(state, self);
756         } else { 
757             /*both fill0 and fill1 are set- exchange the two, updating the layer */
758             if(self->fillid == p->shapeline->fillstyle0) {
759                 self->fillid = p->shapeline->fillstyle1;
760                 self->p = p;
761                 if(DEBUG&2) printf("<X>");
762             } else if(self->fillid == p->shapeline->fillstyle1) {
763                 self->fillid = p->shapeline->fillstyle0;
764                 self->p = p;
765                 if(DEBUG&2) printf("<X>");
766             } else {
767                 /* buggy shape. keep everything as-is. */
768                 if(DEBUG&2) printf("<!>");
769                 //fprintf(stderr, "<line %d: bad swap>\n", y);
770             }
771         }
772         return;
773     } else {
774         layer_t* n = 0;
775         if(p->shapeline && p->shapeline->fillstyle0 && p->shapeline->fillstyle1) {
776             /* this is a hack- a better way would be to make sure that
777                we always get (0,32), (32, 33), (33, 0) in the right order if
778                they happen to fall on the same pixel.
779                (not: (0,32), (33, 0), (32, 33))
780             */
781             fprintf(stderr, "<line %d: both fillstyles set while not inside shape>\n", y);
782             return;
783         }
784         
785         n = rfx_calloc(sizeof(layer_t));
786
787         if(DEBUG&2) printf("<+>");
788
789         n->fillid = p->shapeline->fillstyle0 ? p->shapeline->fillstyle0 : p->shapeline->fillstyle1;
790         n->p = p;
791
792         add_layer(state, before, n);
793     }
794 }
795
796 void swf_Process(RENDERBUF*dest, U32 clipdepth)
797 {
798     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
799     int y;
800     
801     if(i->ymax < i->ymin) {
802         /* shape is empty. return. 
803            only, if it's a clipshape, remember the clipdepth */
804         if(clipdepth) {
805             for(y=0;y<i->height2;y++) {
806                 if(clipdepth > i->lines[y].pending_clipdepth)
807                     i->lines[y].pending_clipdepth = clipdepth;
808             }
809         }
810         return; //nothing (else) to do
811     }
812
813     if(clipdepth) {
814         /* lines outside the clip shape are not filled
815            immediately, only the highest clipdepth so far is
816            stored there. They will be clipfilled once there's
817            actually something about to happen in that line */
818         for(y=0;y<i->ymin;y++) {
819             if(clipdepth > i->lines[y].pending_clipdepth)
820                 i->lines[y].pending_clipdepth = clipdepth;
821         }
822         for(y=i->ymax+1;y<i->height2;y++) {
823             if(clipdepth > i->lines[y].pending_clipdepth)
824                 i->lines[y].pending_clipdepth = clipdepth;
825         }
826     }
827     
828     for(y=i->ymin;y<=i->ymax;y++) {
829         int n;
830         TAG*tag = i->lines[y].points;
831         int num = i->lines[y].num;
832         renderpoint_t*points = (renderpoint_t*)tag->data;
833         RGBA*line = &i->img[i->width2*y];
834         int*zline = &i->zbuf[i->width2*y];
835         int lastx = 0;
836         state_t fillstate;
837         memset(&fillstate, 0, sizeof(state_t));
838         qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
839
840         if(i->lines[y].pending_clipdepth && !clipdepth) {
841             fill_clip(line, zline, y, 0, i->width2, i->lines[y].pending_clipdepth);
842             i->lines[y].pending_clipdepth=0;
843         }
844
845         for(n=0;n<num;n++) {
846             renderpoint_t*p = &points[n];
847             renderpoint_t*next= n<num-1?&points[n+1]:0;
848             int startx = p->x;
849             int endx = next?next->x:i->width2;
850             if(endx > i->width2)
851                 endx = i->width2;
852             if(startx < 0)
853                 startx = 0;
854             if(endx < 0)
855                 endx = 0;
856
857             if(clipdepth) {
858                 /* for clipping, the inverse is filled 
859                    TODO: lastx!=startx only at the start of the loop, 
860                          so this might be moved up
861                  */
862                 fill_clip(line, zline, y, lastx, startx, clipdepth);
863             }
864             change_state(y, &fillstate, p);
865
866             fill(dest, line, zline, y, startx, endx, &fillstate, clipdepth);
867 /*          if(y == 0 && startx == 232 && endx == 418) {
868                 printf("ymin=%d ymax=%d\n", i->ymin, i->ymax);
869                 for(n=0;n<num;n++) {
870                     renderpoint_t*p = &points[n];
871                     printf("x=%f depth=%08x\n", p->x, p->depth);
872                 }
873             }*/
874
875             lastx = endx;
876             if(endx == i->width2)
877                 break;
878         }
879         if(clipdepth) {
880             /* TODO: is lastx *ever* != i->width2 here? */
881             fill_clip(line, zline, y, lastx, i->width2, clipdepth);
882         }
883         free_layers(&fillstate);
884         
885         i->lines[y].num = 0;
886         swf_ClearTag(i->lines[y].points);
887     }
888     i->ymin = 0x7fffffff;
889     i->ymax = -0x80000000;
890 }
891
892 RGBA* swf_Render(RENDERBUF*dest)
893 {
894     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
895     RGBA* img = (RGBA*)rfx_alloc(sizeof(RGBA)*dest->width*dest->height);
896     int y;
897     int antialize = i->antialize;
898    
899     if(antialize <= 1) /* no antializing */ {
900         for(y=0;y<i->height2;y++) {
901             RGBA*line = &i->img[y*i->width2];
902             memcpy(&img[y*dest->width], line, sizeof(RGBA)*dest->width);
903         }
904     } else {
905         RGBA**lines = (RGBA**)rfx_calloc(sizeof(RGBA*)*antialize);
906         int q = antialize*antialize;
907         int ypos = 0;
908         for(y=0;y<i->height2;y++) {
909             int n;
910             ypos = y % antialize;
911             lines[ypos] = &i->img[y*i->width2];
912             if(ypos == antialize-1) {
913                 RGBA*out = &img[(y / antialize)*dest->width];
914                 int x;
915                 int r,g,b,a;
916                 for(x=0;x<dest->width;x++) {
917                     int xpos = x*antialize;
918                     int yp;
919                     U32 r=0,g=0,b=0,a=0;
920                     for(yp=0;yp<antialize;yp++) {
921                         RGBA*lp = &lines[yp][xpos];
922                         int xp;
923                         for(xp=0;xp<antialize;xp++) {
924                             RGBA*p = &lp[xp];
925                             r += p->r;
926                             g += p->g;
927                             b += p->b;
928                             a += p->a;
929                         }
930                     }
931                     out[x].r = r / q;
932                     out[x].g = g / q;
933                     out[x].b = b / q;
934                     out[x].a = a / q;
935                 }
936             }
937         }
938         rfx_free(lines);
939     }
940     return img;
941 }
942
943 typedef struct
944 {
945     int numchars;
946     SHAPE2**glyphs;
947 } font_t;
948
949 typedef struct
950 {
951     TAG*tag;
952     SRECT*bbox;
953     enum {none_type, shape_type, image_type, text_type, font_type} type;
954     union {
955         SHAPE2*shape;
956         font_t*font;
957     } obj;
958 } character_t;
959
960 int compare_placements(const void *v1, const void *v2)
961 {
962     SWFPLACEOBJECT*p1 = (SWFPLACEOBJECT*)v1;
963     SWFPLACEOBJECT*p2 = (SWFPLACEOBJECT*)v2;
964     if(p1->depth != p2->depth)
965         return (int)p1->depth - (int)p2->depth;
966     else 
967         if(p2->clipdepth)
968             return 1; // do the clip first
969         else
970             return -1;
971
972 /*    if(!p1->clipdepth) {
973         if(!p2->clipdepth) {
974             // !p1->clipdepth && !p2->clipdepth
975             return (int)p1->depth - (int)p2->depth;
976         } else {
977             // !p1->clipdepth && p2->clipdepth
978             if(p1->depth != p2->clipdepth)
979                 return (int)p1->depth - (int)p2->clipdepth;
980             else
981                 return 1; // do the clip first
982         }
983     } else {
984         if(!p2->clipdepth) {
985             // p1->clipdepth && !p2->clipdepth
986             if(p1->clipdepth != p2->depth)
987                 return (int)p1->clipdepth - (int)p2->depth;
988             else
989                 return -1;// do the clip first
990         } else {
991             if(p1->clipdepth != p2->clipdepth)
992                 return (int)p1->clipdepth - (int)p2->clipdepth;
993             else
994                 return (int)p1->depth - (int)p2->depth;
995         }
996     }*/
997 }
998
999 typedef struct textcallbackblock
1000 {
1001     character_t*idtable;
1002     U16 depth;
1003     U16 clipdepth;
1004     CXFORM* cxform;
1005     MATRIX m;
1006     RENDERBUF*buf;
1007 } textcallbackblock_t;
1008
1009 static void textcallback(void*self, int*chars, int*xpos, int nr, int fontid, int fontsize, 
1010                     int xstart, int ystart, RGBA* color)
1011 {
1012     textcallbackblock_t * info = (textcallbackblock_t*)self;
1013     font_t*font = 0;
1014     int t;
1015     if(info->idtable[fontid].type != font_type) {
1016         fprintf(stderr, "ID %d is not a font\n", fontid);
1017         return;
1018     } else if(!info->idtable[fontid].obj.font) {
1019         fprintf(stderr, "Font %d unknown\n", fontid);
1020         return;
1021     } else {
1022         font  = info->idtable[fontid].obj.font;
1023     }
1024     for(t=0;t<nr;t++) {
1025         int x = xstart + xpos[t];
1026         int y = ystart;
1027         MATRIX m = info->m;
1028         SPOINT p;
1029         
1030         p.x = x; p.y = y; 
1031         p = swf_TurnPoint(p, &m);
1032         
1033         m.sx = (m.sx * fontsize) / 1024;
1034         m.sy = (m.sy * fontsize) / 1024;
1035         m.r0 = (m.r0 * fontsize) / 1024;
1036         m.r1 = (m.r1 * fontsize) / 1024;
1037         m.tx = p.x;
1038         m.ty = p.y;
1039
1040         if(chars[t]<0 || chars[t]>= font->numchars) {
1041             fprintf(stderr, "Character out of range: %d\n", chars[t]);
1042         } else {
1043             SHAPE2*shape = font->glyphs[chars[t]];
1044             shape->fillstyles[0].color = *color; //q&d
1045             /*printf("Rendering char %d (size %d, x:%d, y:%d) color:%02x%02x%02x%02x\n", chars[t], fontsize, x, y,
1046                     color->a, color->r, color->g, color->b);
1047             swf_DumpMatrix(stdout, &m);
1048             swf_DumpShape(shape);*/
1049             swf_RenderShape(info->buf, shape, &m, info->cxform, info->depth, info->clipdepth);
1050         }
1051     }
1052 }
1053
1054 void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
1055 {
1056     TAG*tag;
1057     int t;
1058     int numplacements;
1059     RGBA color;
1060     SWFPLACEOBJECT* placements;
1061     
1062     character_t* idtable = rfx_calloc(sizeof(character_t)*65536);            // id to character mapping
1063     SWFPLACEOBJECT** depthtable = rfx_calloc(sizeof(SWFPLACEOBJECT*)*65536); // depth to placeobject mapping
1064     
1065     tag = swf->firstTag;
1066     numplacements = 0;
1067     while(tag) {
1068         if(tag->id == ST_PLACEOBJECT || 
1069            tag->id == ST_PLACEOBJECT2) {
1070             numplacements++;
1071         }
1072         tag = tag->next;
1073     }
1074     placements = rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements);
1075     numplacements = 0;
1076
1077     /* set background color */
1078     color = swf_GetSWFBackgroundColor(swf);
1079     swf_Render_SetBackgroundColor(buf, color);
1080
1081     /* parse definitions */
1082     tag = swf->firstTag;
1083     while(tag) {
1084         if(swf_isDefiningTag(tag)) {
1085             int id = swf_GetDefineID(tag);
1086             idtable[id].tag = tag;
1087             idtable[id].bbox = rfx_alloc(sizeof(SRECT));
1088             *idtable[id].bbox = swf_GetDefineBBox(tag);
1089
1090             if(swf_isShapeTag(tag)) {
1091                 SHAPE2* shape = rfx_calloc(sizeof(SHAPE2));
1092                 swf_ParseDefineShape(tag, shape);
1093                 idtable[id].type = shape_type;
1094                 idtable[id].obj.shape = shape;
1095             } else if(swf_isImageTag(tag)) {
1096                 int width,height;
1097                 RGBA*data = swf_ExtractImage(tag, &width, &height);
1098                 idtable[id].type = image_type;
1099                 swf_Render_AddImage(buf, id, data, width, height);
1100                 free(data);
1101             } else if(tag->id == ST_DEFINEFONT ||
1102                       tag->id == ST_DEFINEFONT2) {
1103                 int t;
1104                 SWFFONT*swffont;
1105                 font_t*font = rfx_calloc(sizeof(font_t));
1106                 idtable[id].obj.font = font;
1107                 swf_FontExtract(swf,id,&swffont);
1108                 font->numchars = swffont->numchars;
1109                 font->glyphs = rfx_calloc(sizeof(SHAPE2*)*font->numchars);
1110                 for(t=0;t<font->numchars;t++) {
1111                     if(!swffont->glyph[t].shape->fillstyle.n) {
1112                         /* the actual fill color will be overwritten while rendering */
1113                         swf_ShapeAddSolidFillStyle(swffont->glyph[t].shape, &color_white);
1114                     }
1115                     font->glyphs[t] = swf_ShapeToShape2(swffont->glyph[t].shape);
1116                 }
1117                 swf_FontFree(swffont);
1118                 idtable[id].type = font_type;
1119
1120             } else if(tag->id == ST_DEFINEFONTINFO ||
1121                       tag->id == ST_DEFINEFONTINFO2) {
1122                 idtable[id].type = font_type;
1123             } else if(tag->id == ST_DEFINETEXT ||
1124                       tag->id == ST_DEFINETEXT2) {
1125                 idtable[id].type = text_type;
1126             }
1127         } else if(tag->id == ST_PLACEOBJECT || 
1128                   tag->id == ST_PLACEOBJECT2) {
1129             SWFPLACEOBJECT p;
1130             swf_GetPlaceObject(tag, &p);
1131             /* TODO: add move and deletion */
1132             placements[numplacements++] = p;
1133             swf_PlaceObjectFree(&p); //dirty! but it only frees fields we don't use
1134         }
1135         tag = tag->next;
1136     }
1137
1138     qsort(placements, numplacements, sizeof(SWFPLACEOBJECT), compare_placements);
1139       
1140     for(t=0;t<numplacements;t++) {
1141         SWFPLACEOBJECT*p = &placements[t];
1142         int id = p->id;
1143             
1144         if(!idtable[id].tag) { 
1145             fprintf(stderr, "rfxswf: Id %d is unknown\n", id);
1146             continue;
1147         }
1148
1149         if(idtable[id].type == shape_type) {
1150             //SRECT sbbox = swf_TurnRect(*idtable[id].bbox, &p->matrix);
1151             swf_RenderShape(buf, idtable[id].obj.shape, &p->matrix, &p->cxform, p->depth, p->clipdepth);
1152         } else if(idtable[id].type == text_type) {
1153             TAG* tag = idtable[id].tag;
1154             textcallbackblock_t info;
1155             MATRIX m;
1156
1157             swf_SetTagPos(tag, 0);
1158             swf_GetU16(tag);
1159             swf_GetRect(tag,0);
1160             swf_GetMatrix(tag,&m);
1161             swf_MatrixJoin(&info.m, &p->matrix, &m);
1162             /*printf("Text matrix:\n");
1163             swf_DumpMatrix(stdout, &m);
1164             printf("Placement matrix:\n");
1165             swf_DumpMatrix(stdout, &p->matrix);
1166             printf("Final matrix:\n");
1167             swf_DumpMatrix(stdout, &info.m);*/
1168
1169             info.idtable = idtable;
1170             info.depth = p->depth;
1171             info.cxform = &p->cxform;
1172             info.clipdepth = p->clipdepth;
1173             info.buf = buf;
1174             
1175             swf_ParseDefineText(tag, textcallback, &info);
1176         } else {
1177             fprintf(stderr, "Unknown/Unsupported Object Type for id %d: %s\n", id, swf_TagGetName(idtable[id].tag));
1178         }
1179     }
1180
1181     /* free id and depth tables again */
1182     for(t=0;t<65536;t++) {
1183         if(idtable[t].bbox) {
1184             free(idtable[t].bbox);
1185             idtable[t].bbox=0;
1186         }
1187         if(idtable[t].type == shape_type) {
1188             SHAPE2* shape = idtable[t].obj.shape;
1189             if(shape) {
1190                 swf_Shape2Free(shape); // FIXME
1191                 free(idtable[t].obj.shape);idtable[t].obj.shape = 0;
1192             }
1193         } else if(idtable[t].type == font_type) {
1194             font_t* font = idtable[t].obj.font;
1195             if(font) {
1196                 if(font->glyphs) {
1197                     int t;
1198                     for(t=0;t<font->numchars;t++) {
1199                         swf_Shape2Free(font->glyphs[t]);
1200                         free(font->glyphs[t]); font->glyphs[t] = 0;
1201                     }
1202                     free(font->glyphs);
1203                     font->glyphs = 0;
1204                 }
1205                 free(idtable[t].obj.font); idtable[t].obj.font = 0;
1206                 font = 0;
1207             }
1208         }
1209     }
1210     free(placements);
1211     free(idtable);
1212     free(depthtable);
1213 }
1214