lib/modules/swfrender.c

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