X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fmodules%2Fswfrender.c;h=9df996fb5cfdefb51a37ecb3e43e358691aab86f;hp=ff63d9215e3e5e2501debe716eee5fa7f0ce6fad;hb=2391d7ae5d8a145a250a8b80ab8c93ba74eba030;hpb=d7a2cdb739838d43891d01b9e0fc1d12d4fd9984 diff --git a/lib/modules/swfrender.c b/lib/modules/swfrender.c index ff63d92..9df996f 100644 --- a/lib/modules/swfrender.c +++ b/lib/modules/swfrender.c @@ -23,13 +23,9 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include - -typedef struct _dummyshape -{ - SHAPE2*shape; - //CXFORM //TODO - struct _dummyshape*next; -} dummyshape_t; +#include +#include +#include "../rfxswf.h" /* one bit flag: */ #define clip_type 0 @@ -37,14 +33,11 @@ typedef struct _dummyshape typedef struct _renderpoint { - char type; float x; U32 depth; SHAPELINE*shapeline; - - U32 clipdepth; - dummyshape_t*s; + SHAPE2*s; } renderpoint_t; @@ -74,6 +67,7 @@ typedef struct _renderline { TAG*points; //incremented in 128 byte steps int num; + U32 pending_clipdepth; } renderline_t; typedef struct _bitmap { @@ -88,11 +82,9 @@ typedef struct _renderbuf_internal { renderline_t*lines; bitmap_t*bitmaps; - char antialize; + int antialize; int multiply; int width2,height2; - dummyshape_t*dshapes; - dummyshape_t*dshapes_next; int shapes; int ymin, ymax; @@ -116,7 +108,9 @@ static inline void add_pixel(RENDERBUF*dest, float x, int y, renderpoint_t*p) /* set this to 0.777777 or something if the "both fillstyles set while not inside shape" problem appears to often */ -#define CUT 0.5 +#define CUT 0.77887789 + +#define INT(x) ((int)((x)+16)-16) static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p) { @@ -125,8 +119,9 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, double ny1, ny2, stepx; /* if(DEBUG&4) { int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)); - printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0); + printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]\n", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0); }*/ + assert(p->shapeline); y1=y1*i->multiply; y2=y2*i->multiply; @@ -148,14 +143,14 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, diffx = x2 - x1; diffy = y2 - y1; - ny1 = (int)(y1)+CUT; - ny2 = (int)(y2)+CUT; + ny1 = INT(y1)+CUT; + ny2 = INT(y2)+CUT; if(ny1 < y1) { - ny1 = (int)(y1) + 1.0 + CUT; + ny1 = INT(y1) + 1.0 + CUT; } if(ny2 >= y2) { - ny2 = (int)(y2) - 1.0 + CUT; + ny2 = INT(y2) - 1.0 + CUT; } if(ny1 > ny2) @@ -166,8 +161,8 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, x2 = x2 + (ny2-y2)*stepx; { - int posy=(int)ny1; - int endy=(int)ny2; + int posy=INT(ny1); + int endy=INT(ny2); double posx=0; double startx = x1; @@ -180,7 +175,7 @@ static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, } } #define PI 3.14159265358979 -static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double y2, int width, renderpoint_t*p) +static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double y2, double width, renderpoint_t*p) { renderbuf_internal*i = (renderbuf_internal*)buf->internal; @@ -202,8 +197,10 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double #else /* That's what Macromedia's Player seems to do at zoom level 0. */ /* TODO: needs testing */ - if(width<20) - width = 20; + + /* TODO: how does this interact with scaling? */ + if(width * i->multiply < 20) + width = 20 / i->multiply; #endif sd = (double)dx*(double)dx+(double)dy*(double)dy; @@ -217,7 +214,7 @@ static void add_solidline(RENDERBUF*buf, double x1, double y1, double x2, double vy = (-dx/d); } - segments = width/2; + segments = (int)(width/2); if(segments < 2) segments = 2; @@ -282,7 +279,7 @@ static int compare_renderpoints(const void * _a, const void * _b) return 0; } -void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, char antialize, int multiply) +void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, int antialize, int multiply) { renderbuf_internal*i; int y; @@ -293,12 +290,15 @@ void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, c buf->posy = posy; buf->internal = (renderbuf_internal*)rfx_calloc(sizeof(renderbuf_internal)); i = (renderbuf_internal*)buf->internal; - i->antialize = !!antialize; - i->multiply = antialize?multiply*2:multiply; - i->height2 = antialize?2*buf->height:buf->height; - i->width2 = antialize?2*buf->width:buf->width; + if(antialize < 1) + antialize = 1; + i->antialize = antialize; + i->multiply = multiply*antialize; + i->height2 = antialize*buf->height; + i->width2 = antialize*buf->width; i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t)); for(y=0;yheight2;y++) { + memset(&i->lines[y], 0, sizeof(renderline_t)); i->lines[y].points = swf_InsertTag(0, 0); i->lines[y].num = 0; } @@ -311,12 +311,12 @@ void swf_Render_Init(RENDERBUF*buf, int posx, int posy, int width, int height, c void swf_Render_SetBackground(RENDERBUF*buf, RGBA*img, int width, int height) { renderbuf_internal*i = (renderbuf_internal*)buf->internal; - if(i->shapes) { - fprintf(stderr, "rfxswf: Warning: swf_Render_SetBackground() called after drawing shapes\n"); - } int x,xx,y,yy; int xstep=width*65536/i->width2; int ystep=height*65536/i->height2; + if(i->shapes) { + fprintf(stderr, "rfxswf: Warning: swf_Render_SetBackground() called after drawing shapes\n"); + } for(y=0,yy=0;yheight2;y++,yy+=ystep) { RGBA*src = &img[(yy>>16) * width]; RGBA*line = &i->img[y * i->width2]; @@ -333,11 +333,11 @@ void swf_Render_AddImage(RENDERBUF*buf, U16 id, RGBA*img, int width, int height) { renderbuf_internal*i = (renderbuf_internal*)buf->internal; - bitmap_t*bm = rfx_calloc(sizeof(bitmap_t)); + bitmap_t*bm = (bitmap_t*)rfx_calloc(sizeof(bitmap_t)); bm->id = id; bm->width = width; bm->height = height; - bm->data = rfx_alloc(width*height*4); + bm->data = (RGBA*)rfx_alloc(width*height*4); memcpy(bm->data, img, width*height*4); bm->next = i->bitmaps; @@ -358,7 +358,6 @@ void swf_Render_Delete(RENDERBUF*dest) renderbuf_internal*i = (renderbuf_internal*)dest->internal; int y; bitmap_t*b = i->bitmaps; - dummyshape_t*d = i->dshapes; /* delete canvas */ rfx_free(i->zbuf); @@ -366,19 +365,10 @@ void swf_Render_Delete(RENDERBUF*dest) /* delete line buffers */ for(y=0;yheight2;y++) { - swf_DeleteTag(i->lines[y].points); + swf_DeleteTag(0, i->lines[y].points); i->lines[y].points = 0; } - while(d) { - dummyshape_t*next = d->next; - swf_Shape2Free(d->shape); - free(d->shape);d->shape=0; - free(d); - d=next; - } - i->dshapes = 0; - /* delete bitmaps */ while(b) { bitmap_t*next = b->next; @@ -391,22 +381,9 @@ void swf_Render_Delete(RENDERBUF*dest) rfx_free(dest->internal); dest->internal = 0; } -static void swf_Render_AddShape(RENDERBUF*dest,dummyshape_t*s) -{ - renderbuf_internal*i = (renderbuf_internal*)dest->internal; - - s->next = 0; - if(i->dshapes_next) - i->dshapes_next->next = s; - i->dshapes_next = s; - if(!i->dshapes) { - i->dshapes = s; - } -} - static SHAPE2* linestyle2fillstyle(SHAPE2*shape) { - SHAPE2*s = rfx_calloc(sizeof(SHAPE2)); + SHAPE2*s = (SHAPE2*)rfx_calloc(sizeof(SHAPE2)); int t; s->numfillstyles = shape->numlinestyles; s->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles); @@ -419,7 +396,14 @@ static SHAPE2* linestyle2fillstyle(SHAPE2*shape) return s; } -void swf_Process(RENDERBUF*dest); +void swf_Process(RENDERBUF*dest, U32 clipdepth); + +double matrixsize(MATRIX*m) +{ + double l1 = sqrt((m->sx /65536.0) * (m->sx /65536.0) + (m->r0 /65536.0) * (m->r0/65536.0) ); + double l2 = sqrt((m->r1 /65536.0) * (m->r1 /65536.0) + (m->sy /65536.0) * (m->sy/65536.0) ); + return sqrt(l1*l2); +} void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _depth,U16 _clipdepth) { @@ -428,100 +412,67 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept SHAPELINE*line; int x=0,y=0; MATRIX mat = *m; + SHAPE2* s2 = 0; SHAPE2* lshape = 0; renderpoint_t p, lp; - - SHAPE2* s2 = swf_Shape2Clone(shape); - /* add this shape to the global shape list, for deallocing */ - dummyshape_t*fshape = rfx_calloc(sizeof(dummyshape_t)); - fshape->shape = s2; - swf_Render_AddShape(dest, fshape); - - line = s2->lines; + U32 clipdepth; + double widthmultiply = matrixsize(m); memset(&p, 0, sizeof(renderpoint_t)); memset(&lp, 0, sizeof(renderpoint_t)); - p.type = _clipdepth?clip_type:fill_type; + clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0; p.depth = _depth << 16; - p.clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0; mat.tx -= dest->posx*20; mat.ty -= dest->posy*20; - + s2 = swf_Shape2Clone(shape); + line = s2->lines; if(shape->numfillstyles) { int t; - p.s = fshape; + p.s = s2; /* multiply fillstyles matrices with placement matrix- important for texture and gradient fill */ for(t=0;tnumfillstyles;t++) { MATRIX nm; - swf_MatrixJoin(&nm, &s2->fillstyles[t].m, &mat); //TODO: is this the right order? - nm.sx *= i->multiply; + swf_MatrixJoin(&nm, &mat, &s2->fillstyles[t].m); + /*nm.sx *= i->multiply; nm.sy *= i->multiply; nm.r0 *= i->multiply; nm.r1 *= i->multiply; nm.tx *= i->multiply; - nm.ty *= i->multiply; + nm.ty *= i->multiply;*/ s2->fillstyles[t].m = nm; } - } if(shape->numlinestyles) { - dummyshape_t*dshape = rfx_calloc(sizeof(dummyshape_t)); - lshape = linestyle2fillstyle(shape); - - lp.type = fill_type; - lp.s = dshape; + lp.s = lshape; lp.depth = (_depth << 16)+1; - - dshape->shape = lshape; - - /* add this shape to the global shape list, for deallocing */ - swf_Render_AddShape(dest, dshape); } - if(p.clipdepth) { - /* invert shape */ - p.shapeline = 0; - add_line(dest, -20, 0, -20, i->height2*20, &p); - } while(line) { int x1,y1,x2,y2,x3,y3; - p.shapeline = line; - if(line->type == moveTo) { } else if(line->type == lineTo) { - if(DEBUG&4) { - int l; - x1 = x; - y1 = y; - x2 = line->x; - y2 = line->y; - l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)); - printf("%d - %.2f/%.2f -> %.2f/%.2f ", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0); - } - transform_point(&mat, x, y, &x1, &y1); transform_point(&mat, line->x, line->y, &x3, &y3); - if(line->linestyle && ! p.clipdepth) { + if(line->linestyle && ! clipdepth) { lp.shapeline = &lshape->lines[line->linestyle-1]; - add_solidline(dest, x1, y1, x3, y3, shape->linestyles[line->linestyle-1].width, &lp); + add_solidline(dest, x1, y1, x3, y3, shape->linestyles[line->linestyle-1].width * widthmultiply, &lp); lp.depth++; } if(line->fillstyle0 || line->fillstyle1) { assert(shape->numfillstyles); + p.shapeline = line; add_line(dest, x1, y1, x3, y3, &p); } - - if(DEBUG&4) printf("\n"); } else if(line->type == splineTo) { int c,t,parts,qparts; double xx,yy; @@ -534,50 +485,53 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept xx=x1; yy=y1; - parts = (int)(sqrt(c)/3); + parts = (int)(sqrt((float)c)/3); if(!parts) parts = 1; - if(DEBUG&4) - { - printf("spline %.2f/%.2f -(%.2f/%.2f)-> %.2f/%.2f (c=%d, %d parts)", - x1/20.0, y1/20.0, - x2/20.0, y2/20.0, - x3/20.0, y3/20.0, c, parts); - } - for(t=1;t<=parts;t++) { double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts); double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts); - if(line->linestyle && ! p.clipdepth) { + if(line->linestyle && ! clipdepth) { lp.shapeline = &lshape->lines[line->linestyle-1]; - add_solidline(dest, xx, yy, nx, ny, shape->linestyles[line->linestyle-1].width, &lp); + add_solidline(dest, xx, yy, nx, ny, shape->linestyles[line->linestyle-1].width * widthmultiply, &lp); lp.depth++; } if(line->fillstyle0 || line->fillstyle1) { assert(shape->numfillstyles); - add_line(dest, (int)xx, (int)yy, (int)nx, (int)ny, &p); + p.shapeline = line; + add_line(dest, xx, yy, nx, ny, &p); } xx = nx; yy = ny; } - if(DEBUG&4) - printf("\n"); } x = line->x; y = line->y; line = line->next; } - swf_Process(dest); + + swf_Process(dest, clipdepth); + + if(s2) { + swf_Shape2Free(s2);rfx_free(s2);s2=0; + } + if(lshape) { + swf_Shape2Free(lshape);rfx_free(lshape);lshape=0; + } + } static RGBA color_red = {255,255,0,0}; static RGBA color_white = {255,255,255,255}; +static RGBA color_black = {255,0,0,0}; -static void fill_clip(RGBA*line, int*z, int x1, int x2, int depth) +static void fill_clip(RGBA*line, int*z, int y, int x1, int x2, U32 depth) { int x = x1; + if(x1>=x2) + return; do { if(depth > z[x]) { z[x] = depth; @@ -585,9 +539,11 @@ static void fill_clip(RGBA*line, int*z, int x1, int x2, int depth) } while(++x>8; @@ -595,7 +551,7 @@ static void fill_plain(RGBA*line, int*z, int x1, int x2, RGBA col, int depth) col.b = (col.b*col.a)>>8; col.a = 255; do { - if(depth > z[x]) { + if(depth >= z[x]) { line[x].r = ((line[x].r*ainv)>>8)+col.r; line[x].g = ((line[x].g*ainv)>>8)+col.g; line[x].b = ((line[x].b*ainv)>>8)+col.b; @@ -605,7 +561,7 @@ static void fill_plain(RGBA*line, int*z, int x1, int x2, RGBA col, int depth) } while(++x z[x]) { + if(depth >= z[x]) { line[x] = col; z[x] = depth; } @@ -613,32 +569,40 @@ static void fill_plain(RGBA*line, int*z, int x1, int x2, RGBA col, int depth) } } -static void fill_bitmap(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clipbitmap, int depth) +static int inline clamp(int v) +{ + if(v>255) return 255; + else return v; +} + +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) { int x = x1; - double m11=m->sx/65536.0, m21=m->r1/65536.0; - double m12=m->r0/65536.0, m22=m->sy/65536.0; - double rx = m->tx/20.0; - double ry = m->ty/20.0; + + double m11= m->sx*fmultiply/65536.0, m21= m->r1*fmultiply/65536.0; + double m12= m->r0*fmultiply/65536.0, m22= m->sy*fmultiply/65536.0; + double rx = m->tx*fmultiply/20.0; + double ry = m->ty*fmultiply/20.0; + double det = m11*m22 - m12*m21; if(fabs(det) < 0.0005) { /* x direction equals y direction- the image is invisible */ return; } det = 20.0/det; - + if(!b->width || !b->height) { - fill_plain(line, z, x1, x2, color_red, depth); + fill_solid(line, z, y, x1, x2, color_red, depth); return; } do { - if(depth > z[x]) { + if(depth >= z[x]) { RGBA col; int xx = (int)(( (x - rx) * m22 - (y - ry) * m21)*det); int yy = (int)((- (x - rx) * m12 + (y - ry) * m11)*det); int ainv; - + if(clipbitmap) { if(xx<0) xx=0; if(xx>=b->width) xx = b->width-1; @@ -647,15 +611,99 @@ static void fill_bitmap(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, bitma } else { xx %= b->width; yy %= b->height; + if(xx<0) xx += b->width; + if(yy<0) yy += b->height; } col = b->data[yy*b->width+xx]; ainv = 255-col.a; - line[x].r = ((line[x].r*ainv)>>8)+col.r; - line[x].g = ((line[x].g*ainv)>>8)+col.g; - line[x].b = ((line[x].b*ainv)>>8)+col.b; + line[x].r = clamp(((line[x].r*ainv)>>8)+col.r); + line[x].g = clamp(((line[x].g*ainv)>>8)+col.g); + line[x].b = clamp(((line[x].b*ainv)>>8)+col.b); + line[x].a = 255; + + z[x] = depth; + } + } while(++xsx*fmultiply/80, m21= m->r1*fmultiply/80; + double m12= m->r0*fmultiply/80, m22= m->sy*fmultiply/80; + double rx = m->tx*fmultiply/20.0; + double ry = m->ty*fmultiply/20.0; + + double det = m11*m22 - m12*m21; + if(fabs(det) < 0.0005) { + /* x direction equals y direction- the image is invisible */ + return; + } + det = 1.0/det; + + RGBA palette[512]; + RGBA oldcol = g->rgba[0]; + int r0 = g->ratios[0]*2; + int t; + for(t=0;tnum;t++) { + int r1 = g->ratios[t]*2; + RGBA newcol = g->rgba[t]; + if(r0 == r1) + continue; + //printf("%d %d->%d %02x%02x%02x%02x->%02x%02x%02x%02x\n", + // t, r0, r1, oldcol.r,oldcol.g,oldcol.b,oldcol.a, + // newcol.r,newcol.g,newcol.b,newcol.a); + double f = 1.0 / (r1-r0); + double p0 = 1; + double p1 = 0; + int s; + for(;r0<=r1;r0++) { + palette[r0].r = oldcol.r*p0 + newcol.r*p1; + palette[r0].g = oldcol.g*p0 + newcol.g*p1; + palette[r0].b = oldcol.b*p0 + newcol.b*p1; + palette[r0].a = oldcol.a*p0 + newcol.a*p1; + p0 -= f; + p1 += f; + } + oldcol = newcol; + } + for(t=r0;t<512;t++) + palette[t] = oldcol; + + do { + if(depth >= z[x]) { + RGBA col; + double xx = ( (x - rx) * m22 - (y - ry) * m21)*det; + double yy = (- (x - rx) * m12 + (y - ry) * m11)*det; + int ainv; + ainv = 255-col.a; + + if(type == FILL_LINEAR) { + int xr = xx*256; + if(xr<-256) + xr = -256; + if(xr>255) + xr = 255; + col = palette[xr+256]; + } else { + int xr = sqrt(xx*xx+yy*yy)*511; + if(xr<0) + xr = 0; + if(xr>511) + xr = 511; + col = palette[xr]; + } + + line[x].r = clamp(((line[x].r*ainv)>>8)+col.r); + line[x].g = clamp(((line[x].g*ainv)>>8)+col.g); + line[x].b = clamp(((line[x].b*ainv)>>8)+col.b); line[x].a = 255; + z[x] = depth; } } while(++xinternal; - U32 clipdepth; + int clip=1; - layer_t*lc = clipstate->layers; - layer_t*lf = fillstate->layers; - layer_t*l = 0; + layer_t*l = fillstate->layers; if(x1>=x2) //zero width? nothing to do. return; - clipdepth = 0; - while(lf) { - if(lc && (!lf || lc->p->depth < lf->p->depth)) { - l = lc; - lc = lc->next; - } else if(lf && (!lc || lf->p->depth < lc->p->depth)) { - l = lf; - lf = lf->next; - } else if(lf && lc && lf->p->depth == lc->p->depth) { - /* A clipshape and a fillshape at the same depth. Yuck. - Bug in the SWF file */ - fprintf(stderr, "Error: Multiple use of depth %d in SWF\n", lf->p->depth); - l = lc; - lc = lc->next; - } else { - fprintf(stderr, "Internal error: %08x %08x\n", lc, lf); - if(lc) fprintf(stderr, " lc->depth = %08x\n", lc->p->depth); - if(lf) fprintf(stderr, " lf->depth = %08x\n", lf->p->depth); - } - - if(l->p->depth <= clipdepth) { - if(DEBUG&2) printf("(clipped)"); - continue; - } - if(l->fillid < 0 /*clip*/) { - if(DEBUG&2) printf("(add clip %d)", l->clipdepth); - if(l->clipdepth > clipdepth) - clipdepth = l->clipdepth; - } else if(l->fillid == 0) { + while(l) { + if(l->fillid == 0) { /* not filled. TODO: we should never add those in the first place */ if(DEBUG&2) printf("(not filled)"); - } else if(l->fillid > l->p->s->shape->numfillstyles) { - fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->s->shape->numlinestyles); - } else { + } else if(l->fillid > l->p->s->numfillstyles) { + fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->s->numlinestyles); + } else if(clipdepth) { + /* filled region- not used for clipping */ + clip = 0; + } else { FILLSTYLE*f; if(DEBUG&2) printf("(%d -> %d style %d)", x1, x2, l->fillid); - f = &l->p->s->shape->fillstyles[l->fillid-1]; + f = &l->p->s->fillstyles[l->fillid-1]; - if(l->p->clipdepth) { - fill_clip(line, zline, x1, x2, l->p->clipdepth); - } else if(f->type == FILL_SOLID) { + if(f->type == FILL_SOLID) { /* plain color fill */ - fill_plain(line, zline, x1, x2, f->color, l->p->depth); - } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) { + fill_solid(line, zline, y, x1, x2, f->color, l->p->depth); + } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED || f->type == (FILL_TILED|2) || f->type == (FILL_CLIPPED|2)) { /* TODO: optimize (do this in add_pixel()?) */ bitmap_t* b = i->bitmaps; while(b && b->id != f->id_bitmap) { @@ -740,22 +759,20 @@ static void fill(RENDERBUF*dest, RGBA*line, int*zline, int y, int x1, int x2, st } if(!b) { fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap); - fill_plain(line, zline, x1, x2, color_red, l->p->depth); + fill_solid(line, zline, y, x1, x2, color_red, l->p->depth); } else { - //done in swf_RenderShape now - //MATRIX m = f->m; - //m.tx -= dest->posx*20; - //m.ty -= dest->posy*20; - //m.sx *= i->multiply; - //m.sy *= i->multiply; - //m.r0 *= i->multiply; - //m.r1 *= i->multiply; - //m.tx *= i->multiply; - //m.ty *= i->multiply; - fill_bitmap(line, zline, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0, l->p->depth); + fill_bitmap(line, zline, y, x1, x2, &f->m, b, /*clipped?*/f->type&1, l->p->depth, i->multiply); } - } + } else if(f->type == FILL_LINEAR || f->type == FILL_RADIAL) { + fill_gradient(line, zline, y, x1, x2, &f->m, &f->gradient, f->type, l->p->depth, i->multiply); + } else { + fprintf(stderr, "Undefined fillmode: %02x\n", f->type); + } } + l = l->next; + } + if(clip && clipdepth) { + fill_clip(line, zline, y, x1, x2, clipdepth); } } @@ -816,15 +833,15 @@ static void change_state(int y, state_t* state, renderpoint_t*p) layer_t*before=0, *self=0, *after=0; if(DEBUG&2) { - printf("[%s(%d,%d)/%d/%d-%d]", p->type==clip_type?"C":"F", p->x, y, p->depth, p->shapeline->fillstyle0, p->shapeline->fillstyle1); + printf("[(%f,%d)/%d/%d-%d]", p->x, y, p->depth, p->shapeline->fillstyle0, p->shapeline->fillstyle1); } search_layer(state, p->depth, &before, &self, &after); if(self) { /* shape update */ - if(self->fillid<0 || !p->shapeline->fillstyle0 || !p->shapeline->fillstyle1) { - /* filling/clipping ends */ + if(self->fillid<0/*??*/ || !p->shapeline->fillstyle0 || !p->shapeline->fillstyle1) { + /* filling ends */ if(DEBUG&2) printf(""); delete_layer(state, self); @@ -832,12 +849,10 @@ static void change_state(int y, state_t* state, renderpoint_t*p) /*both fill0 and fill1 are set- exchange the two, updating the layer */ if(self->fillid == p->shapeline->fillstyle0) { self->fillid = p->shapeline->fillstyle1; - self->clipdepth = 0; self->p = p; if(DEBUG&2) printf(""); } else if(self->fillid == p->shapeline->fillstyle1) { self->fillid = p->shapeline->fillstyle0; - self->clipdepth = 0; self->p = p; if(DEBUG&2) printf(""); } else { @@ -854,68 +869,119 @@ static void change_state(int y, state_t* state, renderpoint_t*p) we always get (0,32), (32, 33), (33, 0) in the right order if they happen to fall on the same pixel. (not: (0,32), (33, 0), (32, 33)) + Notice: Weird fill styles appear if linestyles are involved, too. */ fprintf(stderr, "\n", y); return; } - n = rfx_calloc(sizeof(layer_t)); + n = (layer_t*)rfx_calloc(sizeof(layer_t)); if(DEBUG&2) printf("<+>"); - if(p->type == clip_type) { - /* add clipping */ - n->fillid = -1; - n->clipdepth = p->clipdepth; - n->p = p; - } else { - n->fillid = p->shapeline->fillstyle0 ? p->shapeline->fillstyle0 : p->shapeline->fillstyle1; - n->clipdepth = 0; - n->p = p; - } + n->fillid = p->shapeline->fillstyle0 ? p->shapeline->fillstyle0 : p->shapeline->fillstyle1; + n->p = p; add_layer(state, before, n); } } -void swf_Process(RENDERBUF*dest) +void swf_Process(RENDERBUF*dest, U32 clipdepth) { renderbuf_internal*i = (renderbuf_internal*)dest->internal; int y; + + if(i->ymax < i->ymin) { + /* shape is empty. return. + only, if it's a clipshape, remember the clipdepth */ + if(clipdepth) { + for(y=0;yheight2;y++) { + if(clipdepth > i->lines[y].pending_clipdepth) + i->lines[y].pending_clipdepth = clipdepth; + } + } + return; //nothing (else) to do + } - for(y=i->ymin;yymax;y++) { + if(clipdepth) { + /* lines outside the clip shape are not filled + immediately, only the highest clipdepth so far is + stored there. They will be clipfilled once there's + actually something about to happen in that line */ + for(y=0;yymin;y++) { + if(clipdepth > i->lines[y].pending_clipdepth) + i->lines[y].pending_clipdepth = clipdepth; + } + for(y=i->ymax+1;yheight2;y++) { + if(clipdepth > i->lines[y].pending_clipdepth) + i->lines[y].pending_clipdepth = clipdepth; + } + } + + for(y=i->ymin;y<=i->ymax;y++) { int n; TAG*tag = i->lines[y].points; int num = i->lines[y].num; renderpoint_t*points = (renderpoint_t*)tag->data; RGBA*line = &i->img[i->width2*y]; int*zline = &i->zbuf[i->width2*y]; - state_t clipstate; + int lastx = 0; state_t fillstate; - memset(&clipstate, 0, sizeof(state_t)); memset(&fillstate, 0, sizeof(state_t)); qsort(points, num, sizeof(renderpoint_t), compare_renderpoints); + /* resort points */ + /*if(y==884) { + for(n=0;nfillstyle0, + points[n].shapeline->fillstyle1, + points[n].shapeline->linestyle); + } + }*/ + + if(i->lines[y].pending_clipdepth && !clipdepth) { + fill_clip(line, zline, y, 0, i->width2, i->lines[y].pending_clipdepth); + i->lines[y].pending_clipdepth=0; + } for(n=0;nx; - int endx = next?next->x:i->width2; + int startx = (int)p->x; + int endx = (int)(next?next->x:i->width2); if(endx > i->width2) endx = i->width2; if(startx < 0) startx = 0; - - if(p->type == clip_type) - change_state(y, &clipstate, p); - else - change_state(y, &fillstate, p); - - fill(dest, line, zline, y, startx, endx, &clipstate, &fillstate); + if(endx < 0) + endx = 0; + + if(clipdepth) { + /* for clipping, the inverse is filled + TODO: lastx!=startx only at the start of the loop, + so this might be moved up + */ + fill_clip(line, zline, y, lastx, startx, clipdepth); + } + change_state(y, &fillstate, p); + + fill(dest, line, zline, y, startx, endx, &fillstate, clipdepth); +/* if(y == 0 && startx == 232 && endx == 418) { + printf("ymin=%d ymax=%d\n", i->ymin, i->ymax); + for(n=0;nx, p->depth); + } + }*/ + + lastx = endx; if(endx == i->width2) break; } - free_layers(&clipstate); + if(clipdepth) { + /* TODO: is lastx *ever* != i->width2 here? */ + fill_clip(line, zline, y, lastx, i->width2, clipdepth); + } free_layers(&fillstate); i->lines[y].num = 0; @@ -930,49 +996,67 @@ RGBA* swf_Render(RENDERBUF*dest) renderbuf_internal*i = (renderbuf_internal*)dest->internal; RGBA* img = (RGBA*)rfx_alloc(sizeof(RGBA)*dest->width*dest->height); int y; - RGBA*line2=0; - - swf_Process(dest); - - for(y=0;yheight2;y++) { - int n; - RGBA*line = &i->img[y*i->width2]; - - if(!i->antialize) { - memcpy(&img[y*dest->width], line, sizeof(RGBA)*dest->width); - } else { - if(y&1) { - int x; - RGBA*line1=line; - if(!line2) - line2=line1; - RGBA* p = &img[(y/2)*dest->width]; - for(x=0;xwidth;x++) { - RGBA*p1 = &line1[x*2]; - RGBA*p2 = &line1[x*2+1]; - RGBA*p3 = &line2[x*2]; - RGBA*p4 = &line2[x*2+1]; - p[x].r = (p1->r + p2->r + p3->r + p4->r)/4; - p[x].g = (p1->g + p2->g + p3->g + p4->g)/4; - p[x].b = (p1->b + p2->b + p3->b + p4->b)/4; - p[x].a = (p1->a + p2->a + p3->a + p4->a)/4; - } - } - } - line2=line; + int antialize = i->antialize; + + if(antialize <= 1) /* no antializing */ { + for(y=0;yheight2;y++) { + RGBA*line = &i->img[y*i->width2]; + memcpy(&img[y*dest->width], line, sizeof(RGBA)*dest->width); + } + } else { + RGBA**lines = (RGBA**)rfx_calloc(sizeof(RGBA*)*antialize); + int q = antialize*antialize; + int ypos = 0; + for(y=0;yheight2;y++) { + int n; + ypos = y % antialize; + lines[ypos] = &i->img[y*i->width2]; + if(ypos == antialize-1) { + RGBA*out = &img[(y / antialize)*dest->width]; + int x; + int r,g,b,a; + for(x=0;xwidth;x++) { + int xpos = x*antialize; + int yp; + U32 r=0,g=0,b=0,a=0; + for(yp=0;ypr; + g += p->g; + b += p->b; + a += p->a; + } + } + out[x].r = r / q; + out[x].g = g / q; + out[x].b = b / q; + out[x].a = a / q; + } + } + } + rfx_free(lines); } - return img; } typedef struct { + int numchars; + SHAPE2**glyphs; +} font_t; + +enum CHARACTER_TYPE {none_type, shape_type, image_type, text_type, edittext_type, font_type, sprite_type}; +typedef struct +{ TAG*tag; SRECT*bbox; - enum {none_type, shape_type, image_type, text_type, font_type} type; + enum CHARACTER_TYPE type; union { SHAPE2*shape; - SWFFONT*font; + font_t*font; } obj; } character_t; @@ -981,7 +1065,7 @@ int compare_placements(const void *v1, const void *v2) SWFPLACEOBJECT*p1 = (SWFPLACEOBJECT*)v1; SWFPLACEOBJECT*p2 = (SWFPLACEOBJECT*)v2; if(p1->depth != p2->depth) - (int)p1->depth - (int)p2->depth; + return (int)p1->depth - (int)p2->depth; else if(p2->clipdepth) return 1; // do the clip first @@ -1015,29 +1099,167 @@ int compare_placements(const void *v1, const void *v2) }*/ } -void swf_RenderSWF(RENDERBUF*buf, SWF*swf) +typedef struct textcallbackblock { - TAG*tag; + character_t*idtable; + U16 depth; + U16 clipdepth; + CXFORM* cxform; + MATRIX m; + RENDERBUF*buf; +} textcallbackblock_t; + +static void textcallback(void*self, int*chars, int*xpos, int nr, int fontid, int fontsize, + int xstart, int ystart, RGBA* color) +{ + textcallbackblock_t * info = (textcallbackblock_t*)self; + font_t*font = 0; int t; - int numplacements; - - character_t* idtable = rfx_calloc(sizeof(character_t)*65536); // id to character mapping - SWFPLACEOBJECT** depthtable = rfx_calloc(sizeof(SWFPLACEOBJECT*)*65536); // depth to placeobject mapping - - tag = swf->firstTag; + if(info->idtable[fontid].type != font_type) { + fprintf(stderr, "ID %d is not a font\n", fontid); + return; + } else if(!info->idtable[fontid].obj.font) { + fprintf(stderr, "Font %d unknown\n", fontid); + return; + } else { + font = info->idtable[fontid].obj.font; + } + for(t=0;tm; + SPOINT p; + + p.x = x; p.y = y; + p = swf_TurnPoint(p, &m); + + m.sx = (m.sx * fontsize) / 1024; + m.sy = (m.sy * fontsize) / 1024; + m.r0 = (m.r0 * fontsize) / 1024; + m.r1 = (m.r1 * fontsize) / 1024; + m.tx = p.x; + m.ty = p.y; + + if(chars[t]<0 || chars[t]>= font->numchars) { + fprintf(stderr, "Character out of range: %d\n", chars[t]); + } else { + SHAPE2*shape = font->glyphs[chars[t]]; + shape->fillstyles[0].color = *color; //q&d + /*printf("Rendering char %d (size %d, x:%d, y:%d) color:%02x%02x%02x%02x\n", chars[t], fontsize, x, y, + color->a, color->r, color->g, color->b); + swf_DumpMatrix(stdout, &m); + swf_DumpShape(shape);*/ + swf_RenderShape(info->buf, shape, &m, info->cxform, info->depth, info->clipdepth); + } + } +} + +static void renderFromTag(RENDERBUF*buf, character_t*idtable, TAG*firstTag, MATRIX*m) +{ + TAG*tag = 0; + int numplacements = 0; + SWFPLACEOBJECT* placements; + + tag = firstTag; numplacements = 0; while(tag) { if(tag->id == ST_PLACEOBJECT || tag->id == ST_PLACEOBJECT2) { numplacements++; } + if(tag->id == ST_SHOWFRAME || tag->id == ST_END) + break; tag = tag->next; } - SWFPLACEOBJECT* placements = rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements); + placements = (SWFPLACEOBJECT*)rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements); numplacements = 0; + tag = firstTag; + while(tag) { + if(swf_isPlaceTag(tag)) { + SWFPLACEOBJECT p; + swf_GetPlaceObject(tag, &p); + /* TODO: add move and deletion */ + placements[numplacements++] = p; + swf_PlaceObjectFree(&p); //dirty! but it only frees fields we don't use + } + if(tag->id == ST_SHOWFRAME || tag->id == ST_END) + break; + tag = tag->next; + } + + qsort(placements, numplacements, sizeof(SWFPLACEOBJECT), compare_placements); + + int t; + for(t=0;tid; + MATRIX m2; + swf_MatrixJoin(&m2, m, &p->matrix); + + if(!idtable[id].tag) { + fprintf(stderr, "rfxswf: Id %d is unknown\n", id); + continue; + } + + if(idtable[id].type == shape_type) { + //SRECT sbbox = swf_TurnRect(*idtable[id].bbox, &p->matrix); + swf_RenderShape(buf, idtable[id].obj.shape, &m2, &p->cxform, p->depth, p->clipdepth); + } else if(idtable[id].type == sprite_type) { + swf_UnFoldSprite(idtable[id].tag); + renderFromTag(buf, idtable, idtable[id].tag->next, &m2); + swf_FoldSprite(idtable[id].tag); + } else if(idtable[id].type == text_type) { + TAG* tag = idtable[id].tag; + textcallbackblock_t info; + MATRIX mt; + + swf_SetTagPos(tag, 0); + swf_GetU16(tag); + swf_GetRect(tag,0); + swf_GetMatrix(tag,&mt); + swf_MatrixJoin(&info.m, &m2, &mt); + /*printf("Text matrix:\n"); + swf_DumpMatrix(stdout, &m); + printf("Placement matrix:\n"); + swf_DumpMatrix(stdout, &p->matrix); + printf("Final matrix:\n"); + swf_DumpMatrix(stdout, &info.m);*/ + + info.idtable = idtable; + info.depth = p->depth; + info.cxform = &p->cxform; + info.clipdepth = p->clipdepth; + info.buf = buf; + + swf_ParseDefineText(tag, textcallback, &info); + } else if(idtable[id].type == edittext_type) { + TAG* tag = idtable[id].tag; + U16 flags = swf_GetBits(tag, 16); + if(flags & ET_HASTEXT) { + fprintf(stderr, "edittext not supported yet (id %d)\n", id); + } + } else { + fprintf(stderr, "Unknown/Unsupported Object Type for id %d: %s\n", id, swf_TagGetName(idtable[id].tag)); + } + } + + free(placements); +} + +void swf_RenderSWF(RENDERBUF*buf, SWF*swf) +{ + TAG*tag; + int t; + RGBA color; + + swf_OptimizeTagOrder(swf); + swf_FoldAll(swf); + + character_t* idtable = (character_t*)rfx_calloc(sizeof(character_t)*65536); // id to character mapping + /* set background color */ - RGBA color = swf_GetSWFBackgroundColor(swf); + color = swf_GetSWFBackgroundColor(swf); swf_Render_SetBackgroundColor(buf, color); /* parse definitions */ @@ -1046,11 +1268,11 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf) if(swf_isDefiningTag(tag)) { int id = swf_GetDefineID(tag); idtable[id].tag = tag; - idtable[id].bbox = rfx_alloc(sizeof(SRECT)); + idtable[id].bbox = (SRECT*)rfx_alloc(sizeof(SRECT)); *idtable[id].bbox = swf_GetDefineBBox(tag); if(swf_isShapeTag(tag)) { - SHAPE2* shape = rfx_calloc(sizeof(SHAPE2)); + SHAPE2* shape = (SHAPE2*)rfx_calloc(sizeof(SHAPE2)); swf_ParseDefineShape(tag, shape); idtable[id].type = shape_type; idtable[id].obj.shape = shape; @@ -1062,46 +1284,41 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf) free(data); } else if(tag->id == ST_DEFINEFONT || tag->id == ST_DEFINEFONT2) { - //swf_FontExtract(swf,id,&idtable[id].font); - idtable[id].obj.font = 0; + int t; + SWFFONT*swffont; + font_t*font = (font_t*)rfx_calloc(sizeof(font_t)); + idtable[id].obj.font = font; + swf_FontExtract(swf,id,&swffont); + font->numchars = swffont->numchars; + font->glyphs = (SHAPE2**)rfx_calloc(sizeof(SHAPE2*)*font->numchars); + for(t=0;tnumchars;t++) { + if(!swffont->glyph[t].shape->fillstyle.n) { + /* the actual fill color will be overwritten while rendering */ + swf_ShapeAddSolidFillStyle(swffont->glyph[t].shape, &color_white); + } + font->glyphs[t] = swf_ShapeToShape2(swffont->glyph[t].shape); + } + swf_FontFree(swffont); + idtable[id].type = font_type; + } else if(tag->id == ST_DEFINEFONTINFO || tag->id == ST_DEFINEFONTINFO2) { idtable[id].type = font_type; } else if(tag->id == ST_DEFINETEXT || tag->id == ST_DEFINETEXT2) { idtable[id].type = text_type; - } - } else if(tag->id == ST_PLACEOBJECT || - tag->id == ST_PLACEOBJECT2) { - SWFPLACEOBJECT p; - swf_GetPlaceObject(tag, &p); - /* TODO: add move and deletion */ - placements[numplacements++] = p; - } - tag = tag->next; - } - - qsort(placements, numplacements, sizeof(SWFPLACEOBJECT), compare_placements); - - for(t=0;tid; - - if(!idtable[id].tag) { - fprintf(stderr, "rfxswf: Id %d is unknown\n", id); - continue; - } - - if(idtable[id].type == shape_type) { - SRECT sbbox = swf_TurnRect(*idtable[id].bbox, &p->matrix); - swf_RenderShape(buf, idtable[id].obj.shape, &p->matrix, &p->cxform, p->depth, p->clipdepth); - } else if(idtable[id].type == text_type) { - /* TODO */ - } else { - fprintf(stderr, "Unknown/Unsupported Object Type for id %d: %s\n", id, swf_TagGetName(idtable[id].tag)); + } else if(tag->id == ST_DEFINESPRITE) { + idtable[id].type = sprite_type; + } else if(tag->id == ST_DEFINEEDITTEXT) { + idtable[id].type = edittext_type; + } } + tag = tag->next; } - + MATRIX m; + swf_GetMatrix(0, &m); + renderFromTag(buf, idtable, swf->firstTag, &m); + /* free id and depth tables again */ for(t=0;t<65536;t++) { if(idtable[t].bbox) { @@ -1114,9 +1331,23 @@ void swf_RenderSWF(RENDERBUF*buf, SWF*swf) swf_Shape2Free(shape); // FIXME free(idtable[t].obj.shape);idtable[t].obj.shape = 0; } - } + } else if(idtable[t].type == font_type) { + font_t* font = idtable[t].obj.font; + if(font) { + if(font->glyphs) { + int t; + for(t=0;tnumchars;t++) { + swf_Shape2Free(font->glyphs[t]); + free(font->glyphs[t]); font->glyphs[t] = 0; + } + free(font->glyphs); + font->glyphs = 0; + } + free(idtable[t].obj.font); idtable[t].obj.font = 0; + font = 0; + } + } } free(idtable); - free(depthtable); } - +