along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#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
{
- enum {clip_type, fill_type} type;
+ char type;
+ float x;
+ U32 depth;
+
+ SHAPELINE*shapeline;
+
+ U32 clipdepth;
+ dummyshape_t*s;
+
+} renderpoint_t;
+
+/*
+ enum {clip_type, solidfill_type, texturefill_type, gradientfill_type} type;
float fx;
int x;
U32 depth;
U32 clipdepth;
- SHAPE2*shape;
- SHAPELINE*shapeline;
- //CXFORM?
-} renderpoint_t;
+
+ // solidfill;
+ RGBA color;
+
+ // texturefill
+ bitmap_t* bitmap;
+
+ // gradientfill
+ gradient_t* gradient;
+
+ // texture- & gradientfill;
+ U32 x,y;
+ U32 dx,dy;
+
+*/
typedef struct _renderline
{
struct _bitmap*next;
} bitmap_t;
-typedef struct _dummyshape
-{
- SHAPE2*shape;
- struct _dummyshape*next;
-} dummyshape_t;
-
typedef struct _renderbuf_internal
{
renderline_t*lines;
#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);
+ }
+ swf_SetBits(tag, *(U32*)&p->shapeline, 32);
+ if(p->type == clip_type) {
+ if(p->clipdepth & 0xffff) {
+ swf_SetBits(tag, 1, 1);
+ swf_SetBits(tag, p->clipdepth, 32);
+ } else {
+ swf_SetBits(tag, 0, 1);
+ swf_SetBits(tag, p->clipdepth >> 16, 16);
+ }
+ /* don't set s */
+ } else {
+ 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;
+ }
+ dummy = swf_GetBits(tag, 32);p.shapeline = *(SHAPELINE**)&dummy;
+ if(p.type == clip_type) {
+ flag = swf_GetBits(tag, 1);
+ if(flag) {
+ p.clipdepth = swf_GetBits(tag, 32);
+ } else {
+ p.clipdepth = swf_GetBits(tag, 16) << 16;
+ }
+ 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 = (int)x;
- p->fx = x;
- swf_SetBlock(i->lines[y].points, (U8*)p, sizeof(renderpoint_t));
+ p->x = x;
+ if(y<10)
+ renderpoint_write(i->lines[y].points, p);
+ else
+ renderpoint_write(i->lines[y].points, 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
-static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p, char thin)
+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 diffx, diffy;
+ 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);
x2 = x2/20.0;
if(y2 < y1) {
- double x = x1;x1 = x2;x2=x;
- double y = y1;y1 = y2;y2=y;
+ double x;
+ double y;
+ x = x1;x1 = x2;x2=x;
+ y = y1;y1 = y2;y2=y;
}
- double diffx = x2 - x1;
- double diffy = y2 - y1;
+ diffx = x2 - x1;
+ diffy = y2 - y1;
- double ny1 = (int)(y1)+CUT;
- double ny2 = (int)(y2)+CUT;
+ ny1 = (int)(y1)+CUT;
+ ny2 = (int)(y2)+CUT;
if(ny1 < y1) {
ny1 = (int)(y1) + 1.0 + CUT;
if(ny1 > ny2)
return;
- double stepx = diffx/diffy;
+ stepx = diffx/diffy;
x1 = x1 + (ny1-y1)*stepx;
x2 = x2 + (ny2-y2)*stepx;
- int posy=(int)ny1;
- int endy=(int)ny2;
- double posx=0;
- double startx = x1;
-
- while(posy<=endy) {
- float xx = (float)(startx + posx);
- add_pixel(buf, xx ,posy, p);
- posx+=stepx;
- posy++;
+ {
+ int posy=(int)ny1;
+ int endy=(int)ny2;
+ double posx=0;
+ double startx = x1;
+
+ while(posy<=endy) {
+ float xx = (float)(startx + posx);
+ add_pixel(buf, xx ,posy, p);
+ posx+=stepx;
+ posy++;
+ }
}
}
#define PI 3.14159265358979
double lastx,lasty;
double vx,vy;
double xx,yy;
-
- /* The Flash Player does this, too. This means every line is always at least
- one pixel wide */
+
+ /* Make sure the line is always at least one pixel wide */
+#ifdef LINEMODE1
+ /* That's what Macromedia's Player does at least at zoom level >= 1. */
width += 20;
+#else
+ /* That's what Macromedia's Player seems to do at zoom level 0. */
+ /* TODO: needs testing */
+ if(width<20)
+ width = 20;
+#endif
sd = (double)dx*(double)dx+(double)dy*(double)dy;
d = sqrt(sd);
xx = x2+vx;
yy = y2+vy;
- add_line(buf, x1+vx, y1+vy, xx, yy, p, 0);
+ add_line(buf, x1+vx, y1+vy, xx, yy, p);
lastx = xx;
lasty = yy;
for(t=1;t<segments;t++) {
double c = cos(t*PI/segments);
xx = (x2 + vx*c - vy*s);
yy = (y2 + vx*s + vy*c);
- add_line(buf, lastx, lasty, xx, yy, p, 0);
+ add_line(buf, lastx, lasty, xx, yy, p);
lastx = xx;
lasty = yy;
}
xx = (x2-vx);
yy = (y2-vy);
- add_line(buf, lastx, lasty, xx, yy, p, 0);
+ add_line(buf, lastx, lasty, xx, yy, p);
lastx = xx;
lasty = yy;
xx = (x1-vx);
yy = (y1-vy);
- add_line(buf, lastx, lasty, xx, yy, p, 0);
+ add_line(buf, lastx, lasty, xx, yy, p);
lastx = xx;
lasty = yy;
for(t=1;t<segments;t++) {
double c = cos(t*PI/segments);
xx = (x1 - vx*c + vy*s);
yy = (y1 - vx*s - vy*c);
- add_line(buf, lastx, lasty, xx, yy, p, 0);
+ add_line(buf, lastx, lasty, xx, yy, p);
lastx = xx;
lasty = yy;
}
- add_line(buf, lastx, lasty, (x1+vx), (y1+vy), p, 0);
+ add_line(buf, lastx, lasty, (x1+vx), (y1+vy), p);
}
static inline void transform_point(MATRIX*m, int x, int y, int*dx, int*dy)
{
renderpoint_t*a = (renderpoint_t*)_a;
renderpoint_t*b = (renderpoint_t*)_b;
- if(a->fx < b->fx) return -1;
- if(a->fx > b->fx) return 1;
+ if(a->x < b->x) return -1;
+ if(a->x > b->x) return 1;
return 0;
}
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));
+ int t;
+ s->numfillstyles = shape->numlinestyles;
+ s->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles);
+ s->lines = (SHAPELINE*)rfx_calloc(sizeof(SHAPELINE)*shape->numlinestyles);
+ for(t=0;t<shape->numlinestyles;t++) {
+ s->lines[t].fillstyle0 = t+1;
+ s->fillstyles[t].type = FILL_SOLID;
+ s->fillstyles[t].color = shape->linestyles[t].color;
+ }
+ return s;
+}
+
void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _depth,U16 _clipdepth)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
renderpoint_t p, lp;
memset(&p, 0, sizeof(renderpoint_t));
memset(&lp, 0, sizeof(renderpoint_t));
+
p.type = _clipdepth?clip_type:fill_type;
- p.shape = shape;
p.depth = _depth << 16;
p.clipdepth = _clipdepth << 16;
+
mat.tx -= dest->posx*20;
mat.ty -= dest->posy*20;
- if(shape->numlinestyles) {
- dummyshape_t*dshape = rfx_calloc(sizeof(dummyshape_t));
- lshape = rfx_calloc(sizeof(SHAPE2));
+ if(shape->numfillstyles) {
+ dummyshape_t*fshape = rfx_calloc(sizeof(dummyshape_t));
int t;
- lshape->numfillstyles = shape->numlinestyles;
- lshape->fillstyles = (FILLSTYLE*)rfx_calloc(sizeof(FILLSTYLE)*shape->numlinestyles);
- lshape->lines = (SHAPELINE*)rfx_calloc(sizeof(SHAPELINE)*shape->numlinestyles);
- for(t=0;t<shape->numlinestyles;t++) {
- lshape->lines[t].fillstyle0 = t+1;
- lshape->fillstyles[t].type = FILL_SOLID;
- lshape->fillstyles[t].color = shape->linestyles[t].color;
+ SHAPE2* s2 = swf_Shape2Clone(shape);
+
+ fshape->shape = s2;
+
+ p.s = fshape;
+
+ /* 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;
+ nm.sy *= i->multiply;
+ nm.r0 *= i->multiply;
+ nm.r1 *= i->multiply;
+ nm.tx *= i->multiply;
+ nm.ty *= i->multiply;
+ s2->fillstyles[t].m = nm;
}
- lp.type = fill_type;
- lp.shape = lshape;
- lp.depth = p.depth+1;
/* add this shape to the global shape list, for deallocing */
+ swf_Render_AddShape(dest, fshape);
+ }
+
+ if(shape->numlinestyles) {
+ dummyshape_t*dshape = rfx_calloc(sizeof(dummyshape_t));
+
+ lshape = linestyle2fillstyle(shape);
+
+ lp.type = fill_type;
+ lp.s = dshape;
+ lp.depth = (_depth << 16)+1;
+
dshape->shape = lshape;
- i->dshapes_next = dshape;
- if(!i->dshapes) {
- i->dshapes = dshape;
- }
+
+ /* add this shape to the global shape list, for deallocing */
+ swf_Render_AddShape(dest, dshape);
}
if(p.clipdepth) {
/* reverse shape */
p.shapeline = 0;
- add_line(dest, -20, 0, -20, i->height2*20, &p, 0);
+ add_line(dest, -20, 0, -20, i->height2*20, &p);
}
while(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;
- int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
+ 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);
}
add_solidline(dest, x1, y1, x3, y3, shape->linestyles[line->linestyle-1].width, &lp);
lp.depth++;
}
- if(line->fillstyle0 || line->fillstyle1)
- add_line(dest, x1, y1, x3, y3, &p, 0);
+ if(line->fillstyle0 || line->fillstyle1) {
+ assert(shape->numfillstyles);
+ 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;
transform_point(&mat, x, y, &x1, &y1);
transform_point(&mat, line->sx, line->sy, &x2, &y2);
transform_point(&mat, line->x, line->y, &x3, &y3);
- int c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
- int parts,qparts;
- int t;
- double xx=x1,yy=y1;
+ c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
+ xx=x1;
+ yy=y1;
parts = (int)(sqrt(c)/3);
if(!parts) parts = 1;
add_solidline(dest, xx, yy, nx, ny, shape->linestyles[line->linestyle-1].width, &lp);
lp.depth++;
}
- if(line->fillstyle0 || line->fillstyle1)
- add_line(dest, (int)xx, (int)yy, (int)nx, (int)ny, &p, 0);
+ if(line->fillstyle0 || line->fillstyle1) {
+ assert(shape->numfillstyles);
+ add_line(dest, (int)xx, (int)yy, (int)nx, (int)ny, &p);
+ }
xx = nx;
yy = ny;
}
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;
yy %= b->height;
}
- RGBA col = b->data[yy*b->width+xx];
- int 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;
} while(++x<x2);
}
-static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*state)
+static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*clipstate, state_t*fillstate)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
+ U32 clipdepth;
- layer_t*l = state->layers;
+ layer_t*lc = clipstate->layers;
+ layer_t*lf = fillstate->layers;
+ layer_t*l = 0;
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);
+ }
- U32 clipdepth = 0;
- while(l) {
if(l->p->depth < clipdepth) {
if(DEBUG&2) printf("(clipped)");
- l = l->next;
- continue;
+ continue;
}
if(l->fillid < 0 /*clip*/) {
if(DEBUG&2) printf("(add clip %d)", l->clipdepth);
/* not filled. TODO: we should never add those in the first place */
if(DEBUG&2)
printf("(not filled)");
- } else if(l->fillid > l->p->shape->numfillstyles) {
- fprintf(stderr, "Fill style out of bounds (%d>%d)", l->fillid, l->p->shape->numlinestyles);
+ } 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 {
FILLSTYLE*f;
if(DEBUG&2)
printf("(%d -> %d style %d)", x1, x2, l->fillid);
- f = &l->p->shape->fillstyles[l->fillid-1];
+ f = &l->p->s->shape->fillstyles[l->fillid-1];
if(f->type == FILL_SOLID) {
/* plain color fill */
fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap);
fill_plain(line, x1, x2, color_red);
} else {
- 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, &m, b, FILL_CLIPPED?1:0);
+ //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);
}
}
}
- l = l->next;
}
}
RGBA * line1 = rfx_alloc(sizeof(RGBA)*i->width2);
RGBA * line2 = rfx_alloc(sizeof(RGBA)*i->width2);
+ printf("%d\n", sizeof(renderpoint_t));
+
for(y=0;y<i->height2;y++) {
TAG*tag = i->lines[y].points;
int n;
- int size = sizeof(renderpoint_t);
- int num = tag->len / size;
+ int num = renderpoint_num(tag);
+ renderpoint_t*points = renderpoint_readall(tag);
RGBA*line = line1;
+ state_t clipstate;
+ state_t fillstate;
+ memset(&clipstate, 0, sizeof(state_t));
+ memset(&fillstate, 0, sizeof(state_t));
+
if((y&1) && i->antialize)
line = line2;
- state_t state;
- memset(&state, 0, sizeof(state_t));
-
if(!i->background) {
memset(line, 0, sizeof(RGBA)*i->width2);
} else {
}
}
memory += tag->memsize;
- qsort(tag->data, num, size, compare_renderpoints);
+ qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
for(n=0;n<num;n++) {
- renderpoint_t*p = (renderpoint_t*)&tag->data[size*n];
- renderpoint_t*next= n<num-1?(renderpoint_t*)&tag->data[size*(n+1)]:0;
+ renderpoint_t*p = &points[n];
+ renderpoint_t*next= n<num-1?&points[n+1]:0;
int startx = p->x;
int endx = next?next->x:i->width2;
if(endx > i->width2)
if(startx < 0)
startx = 0;
- change_state(y, &state, p);
+ if(p->type == clip_type)
+ change_state(y, &clipstate, p);
+ else
+ change_state(y, &fillstate, p);
- fill(dest, line, y, startx, endx, &state);
+ fill(dest, line, y, startx, endx, &clipstate, &fillstate);
if(endx == i->width2)
break;
}
- free_layers(&state);
+ free_layers(&clipstate);
+ free_layers(&fillstate);
if(DEBUG&2) printf("\n");
if(!i->antialize) {
}
}
}
+ free(points);
}
free(line1);
free(line2);