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;
/*
typedef struct _renderline
{
TAG*points; //incremented in 128 byte steps
+ int num;
} renderline_t;
typedef struct _bitmap {
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
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
if(x >= i->width2 || y >= i->height2 || y<0) return;
- p->x = (int)x;
- p->fx = x;
+ p->x = x;
+ 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));
}
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);
{
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;
}
i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
for(y=0;y<i->height2;y++) {
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;
+ 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;
+ 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)
{
bm->id = id;
bm->width = width;
bm->height = height;
- bm->data = img;
+ bm->data = rfx_alloc(width*height*4);
+ memcpy(bm->data, img, width*height*4);
bm->next = i->bitmaps;
i->bitmaps = bm;
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)
{
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++) {
/* delete bitmaps */
while(b) {
bitmap_t*next = b->next;
- //free(b->data);b->data=0;
+ free(b->data);b->data=0;
rfx_free(b);
b = next;
}
return s;
}
+void swf_Process(RENDERBUF*dest);
+
void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _depth,U16 _clipdepth)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
- SHAPELINE*line = shape->lines;
+ SHAPELINE*line;
int x=0,y=0;
MATRIX mat = *m;
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;
+
memset(&p, 0, sizeof(renderpoint_t));
memset(&lp, 0, sizeof(renderpoint_t));
p.type = _clipdepth?clip_type:fill_type;
p.depth = _depth << 16;
- p.clipdepth = _clipdepth << 16;
+ p.clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0;
mat.tx -= dest->posx*20;
mat.ty -= dest->posy*20;
+
if(shape->numfillstyles) {
- dummyshape_t*fshape = rfx_calloc(sizeof(dummyshape_t));
int t;
- 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, m); //TODO: is this the right order?
+ 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;
s2->fillstyles[t].m = nm;
}
- /* add this shape to the global shape list, for deallocing */
- swf_Render_AddShape(dest, fshape);
}
if(shape->numlinestyles) {
}
if(p.clipdepth) {
- /* reverse shape */
+ /* invert shape */
p.shapeline = 0;
add_line(dest, -20, 0, -20, i->height2*20, &p);
}
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);
}
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;
y = line->y;
line = line->next;
}
+ swf_Process(dest);
}
-typedef struct _layer {
- int fillid;
- U32 clipdepth;
- renderpoint_t*p;
- struct _layer*next;
- struct _layer*prev;
-} layer_t;
-
-typedef struct {
- layer_t*layers;
-} state_t;
-
static RGBA color_red = {255,255,0,0};
static RGBA color_white = {255,255,255,255};
-static void fill_plain(RGBA*line, int x1, int x2, RGBA col)
+static void fill_clip(RGBA*line, int*z, int x1, int x2, int depth)
+{
+ int x = x1;
+ do {
+ if(depth > z[x]) {
+ z[x] = depth;
+ }
+ } while(++x<x2);
+}
+
+static void fill_plain(RGBA*line, int*z, int x1, int x2, RGBA col, int depth)
{
int x = x1;
if(col.a!=255) {
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, int depth)
{
int x = x1;
double m11=m->sx/65536.0, m21=m->r1/65536.0;
det = 20.0/det;
if(!b->width || !b->height) {
- fill_plain(line, x1, x2, color_red);
+ fill_plain(line, z, x1, x2, color_red, depth);
return;
}
do {
- int xx = (int)(( (x - rx) * m22 - (y - ry) * m21)*det);
- int yy = (int)((- (x - rx) * m12 + (y - ry) * m11)*det);
-
- 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;
+ }
- 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;
- 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*state)
+typedef struct _layer {
+ int fillid;
+ U32 clipdepth;
+ 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*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(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);
f = &l->p->s->shape->fillstyles[l->fillid-1];
- if(f->type == FILL_SOLID) {
+ if(l->p->clipdepth) {
+ fill_clip(line, zline, x1, x2, l->p->clipdepth);
+ } else if(f->type == FILL_SOLID) {
/* plain color fill */
- fill_plain(line, x1, x2, f->color);
+ fill_plain(line, zline, 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_plain(line, zline, x1, x2, color_red, l->p->depth);
} else {
//done in swf_RenderShape now
//MATRIX m = f->m;
//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);
}
}
}
- l = l->next;
}
}
}
}
-RGBA* swf_Render(RENDERBUF*dest)
+void swf_Process(RENDERBUF*dest)
{
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);
- for(y=0;y<i->height2;y++) {
- TAG*tag = i->lines[y].points;
+ for(y=i->ymin;y<i->ymax;y++) {
int n;
- int size = sizeof(renderpoint_t);
- int num = tag->len / size;
- RGBA*line = line1;
- if((y&1) && i->antialize)
- line = line2;
-
- state_t state;
- memset(&state, 0, sizeof(state_t));
+ 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;
+ state_t fillstate;
+ memset(&clipstate, 0, sizeof(state_t));
+ memset(&fillstate, 0, sizeof(state_t));
+ qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
- 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];
- }
- }
- memory += tag->memsize;
- qsort(tag->data, num, size, 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, zline, y, startx, endx, &clipstate, &fillstate);
if(endx == i->width2)
break;
}
- free_layers(&state);
- if(DEBUG&2) printf("\n");
+ free_layers(&clipstate);
+ free_layers(&fillstate);
+
+ i->lines[y].num = 0;
+ swf_ClearTag(i->lines[y].points);
+ }
+ 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;
+ RGBA*line2=0;
+
+ swf_Process(dest);
+
+ for(y=0;y<i->height2;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;x<dest->width;x++) {
RGBA*p1 = &line1[x*2];
}
}
}
+ line2=line;
}
- free(line1);
- free(line2);
+
+ return img;
+}
+
+typedef struct
+{
+ TAG*tag;
+ SRECT*bbox;
+ enum {none_type, shape_type, image_type, text_type, font_type} type;
+ union {
+ SHAPE2*shape;
+ SWFFONT*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)
+ (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;
+ }
+ }*/
+}
+
+void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
+{
+ TAG*tag;
+ int t;
+ int numplacements;
- 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
+ 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;
+ }
+ SWFPLACEOBJECT* placements = rfx_calloc(sizeof(SWFPLACEOBJECT)*numplacements);
+ numplacements = 0;
+
+ /* set background color */
+ RGBA color = swf_GetSWFBackgroundColor(swf);
+ swf_Render_SetBackgroundColor(buf, color);
+
+ /* parse definitions */
+ tag = swf->firstTag;
+ while(tag) {
+ if(swf_isDefiningTag(tag)) {
+ int id = swf_GetDefineID(tag);
+ idtable[id].tag = tag;
+ idtable[id].bbox = rfx_alloc(sizeof(SRECT));
+ *idtable[id].bbox = swf_GetDefineBBox(tag);
+
+ if(swf_isShapeTag(tag)) {
+ SHAPE2* shape = rfx_calloc(sizeof(SHAPE2));
+ swf_ParseDefineShape(tag, shape);
+ idtable[id].type = shape_type;
+ idtable[id].obj.shape = shape;
+ } else if(swf_isImageTag(tag)) {
+ int width,height;
+ RGBA*data = swf_ExtractImage(tag, &width, &height);
+ idtable[id].type = image_type;
+ swf_Render_AddImage(buf, id, data, width, height);
+ free(data);
+ } else if(tag->id == ST_DEFINEFONT ||
+ tag->id == ST_DEFINEFONT2) {
+ //swf_FontExtract(swf,id,&idtable[id].font);
+ idtable[id].obj.font = 0;
+ } 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;t<numplacements;t++) {
+ SWFPLACEOBJECT*p = &placements[t];
+ int id = p->id;
+
+ if(!idtable[id].tag) {
+ fprintf(stderr, "rfxswf: Id %d is unknown\n", id);
+ continue;
+ }
- return img;
+ 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));
+ }
+ }
+
+ /* free id and depth tables again */
+ for(t=0;t<65536;t++) {
+ if(idtable[t].bbox) {
+ free(idtable[t].bbox);
+ idtable[t].bbox=0;
+ }
+ if(idtable[t].type == shape_type) {
+ SHAPE2* shape = idtable[t].obj.shape;
+ if(shape) {
+ swf_Shape2Free(shape); // FIXME
+ free(idtable[t].obj.shape);idtable[t].obj.shape = 0;
+ }
+ }
+ }
+ free(idtable);
+ free(depthtable);
}
+
git.asbjorn.biz / swftools.git / blobdiff