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