#include <assert.h>
-typedef struct _dummyshape
-{
- SHAPE2*shape;
- //CXFORM //TODO
- struct _dummyshape*next;
-} dummyshape_t;
-
/* one bit flag: */
#define clip_type 0
#define fill_type 1
typedef struct _renderpoint
{
- char type;
float x;
U32 depth;
SHAPELINE*shapeline;
-
- U32 clipdepth;
- dummyshape_t*s;
+ SHAPE2*s;
} renderpoint_t;
typedef struct _renderline
{
TAG*points; //incremented in 128 byte steps
+ int num;
+ U32 pending_clipdepth;
} renderline_t;
typedef struct _bitmap {
{
renderline_t*lines;
bitmap_t*bitmaps;
- char antialize;
+ int antialize;
int multiply;
int width2,height2;
- dummyshape_t*dshapes;
- dummyshape_t*dshapes_next;
- RGBA*background;
- int background_width, background_height;
+ int shapes;
+ int ymin, ymax;
+
+ RGBA* img;
+ int* zbuf;
} renderbuf_internal;
#define DEBUG 0
-static void renderpoint_write(TAG*tag, renderpoint_t*p)
-{
- if(tag->len == 0) {
- swf_SetU32(tag, 1);
- } else {
- int num = GET32(tag->data);
- PUT32(tag->data, num+1);
- }
-
- swf_SetBits(tag, p->type, 1);
- swf_SetBits(tag, *(U32*)&p->x, 32);
- if(p->depth & 0xffff) {
- swf_SetBits(tag, 1, 1);
- swf_SetBits(tag, p->depth, 32);
- } else {
- swf_SetBits(tag, 0, 1);
- swf_SetBits(tag, p->depth >> 16, 16);
- }
- if(p->shapeline) {
- swf_SetBits(tag, 1, 1);
- swf_SetBits(tag, *(U32*)&p->shapeline, 32);
- } else {
- swf_SetBits(tag, 0, 1);
- }
-
- if(p->type == clip_type) {
- //printf("type=%d x=%f, depth=%08x, shapeline=%08x, clipdepth=%08x\n", p->type, p->x, p->depth, p->shapeline, p->clipdepth);
- assert((p->clipdepth & 0xffff) == 0xffff);
- swf_SetBits(tag, p->clipdepth >> 16, 16);
- /* don't set s */
- } else {
- //printf("type=%d x=%f, depth=%08x, shapeline=%08x, s=%08x\n", p->type, p->x, p->depth, p->shapeline, p->s);
- swf_SetBits(tag, *(U32*)&p->s, 32);
- /* don't set clipdepth */
- }
-}
-static renderpoint_t renderpoint_read(TAG*tag, int num)
-{
- renderpoint_t p;
- U8 flag = 0;
- U32 dummy = 0;
-
- p.type = swf_GetBits(tag, 1);
-
- dummy = swf_GetBits(tag, 32);p.x = *(float*)&dummy;
- flag = swf_GetBits(tag, 1);
- if(flag) {
- p.depth = swf_GetBits(tag, 32);
- } else {
- p.depth = swf_GetBits(tag, 16) << 16;
- }
- flag = swf_GetBits(tag, 1);
- if(flag) {
- dummy = swf_GetBits(tag, 32);p.shapeline = *(SHAPELINE**)&dummy;
- } else {
- p.shapeline = 0;
- }
-
- if(p.type == clip_type) {
- p.clipdepth = swf_GetBits(tag, 16) << 16 | 0xffff;
- p.s = 0;
- } else {
- dummy = swf_GetBits(tag, 32);p.s = *(dummyshape_t**)&dummy;
- p.clipdepth = 0;
- }
-
- return p;
-}
-
-static int renderpoint_num(TAG*tag)
-{
- if(tag->len == 0)
- return 0;
- return GET32(tag->data);
-}
-
-static renderpoint_t* renderpoint_readall(TAG*tag)
-{
- int num;
- int t;
- renderpoint_t*p;
- swf_SetTagPos(tag, 0);
- if(tag->len == 0)
- num = 0;
- else
- num = swf_GetU32(tag);
- p = (renderpoint_t*)rfx_alloc(num*sizeof(renderpoint_t));
- for(t=0;t<num;t++)
- p[t] = renderpoint_read(tag,t);
- return p;
-}
-
static inline void add_pixel(RENDERBUF*dest, float x, int y, renderpoint_t*p)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
if(x >= i->width2 || y >= i->height2 || y<0) return;
p->x = x;
- if(y<10)
- renderpoint_write(i->lines[y].points, p);
- else
- renderpoint_write(i->lines[y].points, p);
+ if(y<i->ymin) i->ymin = y;
+ if(y>i->ymax) i->ymax = y;
+
+ i->lines[y].num++;
+ swf_SetBlock(i->lines[y].points, (U8*)p, sizeof(renderpoint_t));
}
/* 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 INT(x) ((int)((x)+16)-16)
+
static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p)
{
renderbuf_internal*i = (renderbuf_internal*)buf->internal;
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;
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)
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;
}
}
#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;
#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;
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;
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;y<i->height2;y++) {
+ memset(&i->lines[y], 0, sizeof(renderline_t));
i->lines[y].points = swf_InsertTag(0, 0);
+ i->lines[y].num = 0;
}
+ i->zbuf = (int*)rfx_calloc(sizeof(int)*i->width2*i->height2);
+ i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
+ i->shapes = 0;
+ i->ymin = 0x7fffffff;
+ i->ymax = -0x80000000;
}
void swf_Render_SetBackground(RENDERBUF*buf, RGBA*img, int width, int height)
{
renderbuf_internal*i = (renderbuf_internal*)buf->internal;
- RGBA*bck = (RGBA*)rfx_alloc(sizeof(RGBA)*width*height);
- memcpy(bck, img, sizeof(RGBA)*width*height);
- i->background = bck;
- i->background_width = width;
- i->background_height = height;
+ 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;y<i->height2;y++,yy+=ystep) {
+ RGBA*src = &img[(yy>>16) * width];
+ RGBA*line = &i->img[y * i->width2];
+ for(x=0,xx=0;x<i->width2;x++,xx+=xstep) {
+ line[x] = src[xx>>16];
+ }
+ }
}
void swf_Render_SetBackgroundColor(RENDERBUF*buf, RGBA color)
{
for(y=0;y<i->height2;y++) {
swf_ClearTag(i->lines[y].points);
}
+ memset(i->zbuf, 0, sizeof(int)*i->width2*i->height2);
+ memset(i->img, 0, sizeof(RGBA)*i->width2*i->height2);
}
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;
- if(i->background) {
- free(i->background);i->background=0;
- }
+ /* delete canvas */
+ rfx_free(i->zbuf);
+ rfx_free(i->img);
/* delete line buffers */
for(y=0;y<i->height2;y++) {
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;
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));
return s;
}
+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)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
SHAPELINE*line;
int x=0,y=0;
MATRIX mat = *m;
+ SHAPE2* s2 = 0;
SHAPE2* lshape = 0;
-
- 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;
-
renderpoint_t p, lp;
+ 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;t<s2->numfillstyles;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;
parts = (int)(sqrt(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;
}
-}
-
-typedef struct _layer {
- int fillid;
- U32 clipdepth;
- renderpoint_t*p;
- struct _layer*next;
- struct _layer*prev;
-} layer_t;
+
+ swf_Process(dest, clipdepth);
+
+ if(s2) {
+ swf_Shape2Free(s2);rfx_free(s2);s2=0;
+ }
+ if(lshape) {
+ swf_Shape2Free(lshape);rfx_free(lshape);lshape=0;
+ }
-typedef struct {
- layer_t*layers;
-} state_t;
+}
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 y, int x1, int x2, U32 depth)
+{
+ int x = x1;
+ if(x1>=x2)
+ return;
+ do {
+ if(depth > z[x]) {
+ z[x] = depth;
+ }
+ } while(++x<x2);
+}
+
-static void fill_plain(RGBA*line, int x1, int x2, RGBA col)
+static void fill_solid(RGBA*line, int*z, int y, int x1, int x2, RGBA col, U32 depth)
{
int x = x1;
+
if(col.a!=255) {
int ainv = 255-col.a;
col.r = (col.r*col.a)>>8;
col.b = (col.b*col.a)>>8;
col.a = 255;
do {
- 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].a = 255;
+ 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;
+ line[x].a = 255;
+ z[x] = depth;
+ }
} while(++x<x2);
} else {
do {
- line[x] = col;
+ if(depth >= z[x]) {
+ line[x] = col;
+ z[x] = depth;
+ }
} while(++x<x2);
}
}
-static void fill_bitmap(RGBA*line, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clip)
+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, x1, x2, color_red);
+ fill_solid(line, z, y, x1, x2, color_red, depth);
return;
}
do {
- 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(clip) {
- if(xx<0) xx=0;
- if(xx>=b->width) xx = b->width-1;
- if(yy<0) yy=0;
- if(yy>=b->height) yy = b->height-1;
- } else {
- xx %= b->width;
- yy %= b->height;
- }
+ 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;
+ if(yy<0) yy=0;
+ if(yy>=b->height) yy = b->height-1;
+ } 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;
+ 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].a = 255;
+ 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].a = 255;
+
+ z[x] = depth;
+ }
} while(++x<x2);
}
-static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*clipstate, state_t*fillstate)
+typedef struct _layer {
+ int fillid;
+ renderpoint_t*p;
+ struct _layer*next;
+ struct _layer*prev;
+} layer_t;
+
+typedef struct {
+ layer_t*layers;
+} state_t;
+
+
+static void fill(RENDERBUF*dest, RGBA*line, int*zline, int y, int x1, int x2, state_t*fillstate, U32 clipdepth)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
- 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(f->type == FILL_SOLID) {
+ if(f->type == FILL_SOLID) {
/* plain color fill */
- fill_plain(line, x1, x2, f->color);
+ fill_solid(line, zline, y, x1, x2, f->color, l->p->depth);
} else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) {
/* TODO: optimize (do this in add_pixel()?) */
bitmap_t* b = i->bitmaps;
}
if(!b) {
fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap);
- fill_plain(line, x1, x2, color_red);
+ 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, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0);
+ fill_bitmap(line, zline, y, x1, x2, &f->m, b, FILL_CLIPPED?1:0, 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);
}
}
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("[(%d,%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("<D>");
delete_layer(state, self);
/*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("<X>");
} else if(self->fillid == p->shapeline->fillstyle1) {
self->fillid = p->shapeline->fillstyle0;
- self->clipdepth = 0;
self->p = p;
if(DEBUG&2) printf("<X>");
} else {
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);
}
}
-RGBA* swf_Render(RENDERBUF*dest)
+void swf_Process(RENDERBUF*dest, U32 clipdepth)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
- RGBA* img = (RGBA*)rfx_alloc(sizeof(RGBA)*dest->width*dest->height);
int y;
- long memory = 0;
- RGBA * line1 = rfx_alloc(sizeof(RGBA)*i->width2);
- RGBA * line2 = rfx_alloc(sizeof(RGBA)*i->width2);
+
+ if(i->ymax < i->ymin) {
+ /* shape is empty. return.
+ only, if it's a clipshape, remember the clipdepth */
+ if(clipdepth) {
+ for(y=0;y<i->height2;y++) {
+ if(clipdepth > i->lines[y].pending_clipdepth)
+ i->lines[y].pending_clipdepth = clipdepth;
+ }
+ }
+ return; //nothing (else) to do
+ }
- for(y=0;y<i->height2;y++) {
- TAG*tag = i->lines[y].points;
+ 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;y<i->ymin;y++) {
+ if(clipdepth > i->lines[y].pending_clipdepth)
+ i->lines[y].pending_clipdepth = clipdepth;
+ }
+ for(y=i->ymax+1;y<i->height2;y++) {
+ if(clipdepth > i->lines[y].pending_clipdepth)
+ i->lines[y].pending_clipdepth = clipdepth;
+ }
+ }
+
+ for(y=i->ymin;y<=i->ymax;y++) {
int n;
- int num = renderpoint_num(tag);
- renderpoint_t*points = renderpoint_readall(tag);
- RGBA*line = line1;
- state_t clipstate;
+ 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];
+ 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);
- if((y&1) && i->antialize)
- line = line2;
-
- if(!i->background) {
- memset(line, 0, sizeof(RGBA)*i->width2);
- } else {
- int x,xx;
- int xstep=i->background_width*65536/i->width2;
- RGBA*src = &i->background[(i->background_height*y/i->height2)*i->background_width];
- for(x=0,xx=0;x<i->width2;x++,xx+=xstep) {
- line[x] = src[xx>>16];
- }
+ 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;
}
- memory += tag->memsize;
- qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
+
for(n=0;n<num;n++) {
renderpoint_t*p = &points[n];
renderpoint_t*next= n<num-1?&points[n+1]:0;
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, 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;n<num;n++) {
+ renderpoint_t*p = &points[n];
+ printf("x=%f depth=%08x\n", p->x, 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);
- if(DEBUG&2) printf("\n");
-
- if(!i->antialize) {
- memcpy(&img[y*dest->width], line, sizeof(RGBA)*dest->width);
- } else {
- if(y&1) {
- int x;
- RGBA* p = &img[(y/2)*dest->width];
- for(x=0;x<dest->width;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;
- }
- }
- }
- free(points);
+
+ i->lines[y].num = 0;
+ swf_ClearTag(i->lines[y].points);
}
- free(line1);
- free(line2);
-
-#define MEMORY
-
- if(DEBUG) printf("\nMemory used: %d\n", memory);
-#ifdef STATISTICS
- if(DEBUG) printf("Statistics:\n");
- if(DEBUG) printf("Average layer depth: %f\n", (double)layers/layernum);
-#endif
-
+ i->ymin = 0x7fffffff;
+ i->ymax = -0x80000000;
+}
+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;
+ int antialize = i->antialize;
+
+ if(antialize <= 1) /* no antializing */ {
+ for(y=0;y<i->height2;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;y<i->height2;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;x<dest->width;x++) {
+ int xpos = x*antialize;
+ int yp;
+ U32 r=0,g=0,b=0,a=0;
+ for(yp=0;yp<antialize;yp++) {
+ RGBA*lp = &lines[yp][xpos];
+ int xp;
+ for(xp=0;xp<antialize;xp++) {
+ RGBA*p = &lp[xp];
+ r += p->r;
+ 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;
+
+typedef struct
+{
TAG*tag;
SRECT*bbox;
enum {none_type, shape_type, image_type, text_type, font_type} type;
union {
SHAPE2*shape;
- SWFFONT*font;
- };
+ font_t*font;
+ } obj;
} character_t;
+int compare_placements(const void *v1, const void *v2)
+{
+ SWFPLACEOBJECT*p1 = (SWFPLACEOBJECT*)v1;
+ SWFPLACEOBJECT*p2 = (SWFPLACEOBJECT*)v2;
+ if(p1->depth != p2->depth)
+ return (int)p1->depth - (int)p2->depth;
+ else
+ if(p2->clipdepth)
+ return 1; // do the clip first
+ else
+ return -1;
+
+/* if(!p1->clipdepth) {
+ if(!p2->clipdepth) {
+ // !p1->clipdepth && !p2->clipdepth
+ return (int)p1->depth - (int)p2->depth;
+ } else {
+ // !p1->clipdepth && p2->clipdepth
+ if(p1->depth != p2->clipdepth)
+ return (int)p1->depth - (int)p2->clipdepth;
+ else
+ return 1; // do the clip first
+ }
+ } else {
+ if(!p2->clipdepth) {
+ // p1->clipdepth && !p2->clipdepth
+ if(p1->clipdepth != p2->depth)
+ return (int)p1->clipdepth - (int)p2->depth;
+ else
+ return -1;// do the clip first
+ } else {
+ if(p1->clipdepth != p2->clipdepth)
+ return (int)p1->clipdepth - (int)p2->clipdepth;
+ else
+ return (int)p1->depth - (int)p2->depth;
+ }
+ }*/
+}
+
+typedef struct textcallbackblock
+{
+ 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;
+ 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;t<nr;t++) {
+ int x = xstart + xpos[t];
+ int y = ystart;
+ MATRIX m = info->m;
+ 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);
+ }
+ }
+}
+
void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
{
TAG*tag;
int t;
-
+ int numplacements;
+ RGBA color;
+ SWFPLACEOBJECT* placements;
+
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;
+ numplacements = 0;
+ while(tag) {
+ if(tag->id == ST_PLACEOBJECT ||
+ tag->id == ST_PLACEOBJECT2) {
+ numplacements++;
+ }
+ tag = tag->next;
+ }
+ placements = rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements);
+ numplacements = 0;
/* set background color */
- RGBA color = swf_GetSWFBackgroundColor(swf);
+ color = swf_GetSWFBackgroundColor(swf);
swf_Render_SetBackgroundColor(buf, color);
/* parse definitions */
SHAPE2* shape = rfx_calloc(sizeof(SHAPE2));
swf_ParseDefineShape(tag, shape);
idtable[id].type = shape_type;
- idtable[id].shape = shape;
+ idtable[id].obj.shape = shape;
} else if(swf_isImageTag(tag)) {
int width,height;
RGBA*data = swf_ExtractImage(tag, &width, &height);
free(data);
} else if(tag->id == ST_DEFINEFONT ||
tag->id == ST_DEFINEFONT2) {
- //swf_FontExtract(swf,id,&idtable[id].font);
- idtable[id].font = 0;
+ int t;
+ SWFFONT*swffont;
+ font_t*font = rfx_calloc(sizeof(font_t));
+ idtable[id].obj.font = font;
+ swf_FontExtract(swf,id,&swffont);
+ font->numchars = swffont->numchars;
+ font->glyphs = rfx_calloc(sizeof(SHAPE2*)*font->numchars);
+ for(t=0;t<font->numchars;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_PLACEOBJECT ||
tag->id == ST_PLACEOBJECT2) {
- SWFPLACEOBJECT* p = rfx_calloc(sizeof(SWFPLACEOBJECT));
- swf_GetPlaceObject(tag, p);
+ SWFPLACEOBJECT p;
+ swf_GetPlaceObject(tag, &p);
/* TODO: add move and deletion */
- depthtable[p->depth] = p;
+ placements[numplacements++] = p;
+ swf_PlaceObjectFree(&p); //dirty! but it only frees fields we don't use
}
tag = tag->next;
}
+
+ qsort(placements, numplacements, sizeof(SWFPLACEOBJECT), compare_placements);
- for(t=65535;t>=0;t--) if(depthtable[t]) {
- SWFPLACEOBJECT*p = depthtable[t];
+ for(t=0;t<numplacements;t++) {
+ SWFPLACEOBJECT*p = &placements[t];
int id = p->id;
if(!idtable[id].tag) {
}
if(idtable[id].type == shape_type) {
- SRECT sbbox = swf_TurnRect(*idtable[id].bbox, &p->matrix);
- swf_RenderShape(buf, idtable[id].shape, &p->matrix, &p->cxform, p->depth, p->clipdepth);
+ //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 */
+ TAG* tag = idtable[id].tag;
+ textcallbackblock_t info;
+ MATRIX m;
+
+ swf_SetTagPos(tag, 0);
+ swf_GetU16(tag);
+ swf_GetRect(tag,0);
+ swf_GetMatrix(tag,&m);
+ swf_MatrixJoin(&info.m, &p->matrix, &m);
+ /*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 {
fprintf(stderr, "Unknown/Unsupported Object Type for id %d: %s\n", id, swf_TagGetName(idtable[id].tag));
}
idtable[t].bbox=0;
}
if(idtable[t].type == shape_type) {
- SHAPE2* shape = idtable[t].shape;
+ SHAPE2* shape = idtable[t].obj.shape;
if(shape) {
swf_Shape2Free(shape); // FIXME
- free(idtable[t].shape);idtable[t].shape = 0;
+ free(idtable[t].obj.shape);idtable[t].obj.shape = 0;
}
- }
- if(depthtable[t]) {
- swf_PlaceObjectFree(depthtable[t]);
- free(depthtable[t]);depthtable[t] = 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;t<font->numchars;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(placements);
free(idtable);
free(depthtable);
}