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;
- float fx; //for sorting
- int x;
+ char type;
+ float x;
U32 depth;
- U32 clipdepth;
+
SHAPELINE*shapeline;
-
+
+ U32 clipdepth;
dummyshape_t*s;
+
} renderpoint_t;
/*
#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"
double xx,yy;
/* Make sure the line is always at least one pixel wide */
-#define LINEMODE1
#ifdef LINEMODE1
/* That's what Macromedia's Player does at least at zoom level >= 1. */
width += 20;
{
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;
}
} 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(l) {
+ 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)");
- l = l->next;
- continue;
+ continue;
}
if(l->fillid < 0 /*clip*/) {
if(DEBUG&2) printf("(add clip %d)", l->clipdepth);
}
}
}
- 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 state;
- memset(&state, 0, sizeof(state_t));
+ 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;
-
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);
git.asbjorn.biz / swftools.git / blobdiff