Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "../rfxswf.h"
/* one bit flag: */
#define clip_type 0
{
renderline_t*lines;
bitmap_t*bitmaps;
- char antialize;
+ int antialize;
int multiply;
int width2,height2;
int shapes;
/* 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)
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);
}
}
#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;
vy = (-dx/d);
}
- segments = width/2;
+ segments = (int)(width/2);
if(segments < 2)
segments = 2;
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));
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;y<i->height2;y++,yy+=ystep) {
RGBA*src = &img[(yy>>16) * width];
RGBA*line = &i->img[y * i->width2];
{
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;
/* delete line buffers */
for(y=0;y<i->height2;y++) {
- swf_DeleteTag(i->lines[y].points);
+ swf_DeleteTag(0, i->lines[y].points);
i->lines[y].points = 0;
}
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);
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;
SHAPE2* lshape = 0;
renderpoint_t p, lp;
U32 clipdepth;
+ double widthmultiply = matrixsize(m);
memset(&p, 0, sizeof(renderpoint_t));
memset(&lp, 0, sizeof(renderpoint_t));
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;
}
}
lp.depth = (_depth << 16)+1;
}
+
while(line)
{
int x1,y1,x2,y2,x3,y3;
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) {
xx=x1;
yy=y1;
- parts = (int)(sqrt(c)/3);
+ parts = (int)(sqrt((float)c)/3);
if(!parts) parts = 1;
for(t=1;t<=parts;t++) {
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) {
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)
{
} while(++x<x2);
}
+
static void fill_solid(RGBA*line, int*z, int y, int x1, int x2, RGBA col, U32 depth)
{
int x = x1;
}
}
-static void fill_bitmap(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, bitmap_t*b, int clipbitmap, U32 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_solid(line, z, y, x1, x2, color_red, depth);
return;
} 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(++x<x2);
+}
+
+static void fill_gradient(RGBA*line, int*z, int y, int x1, int x2, MATRIX*m, GRADIENT*g, int type, U32 depth, double fmultiply)
+{
+ int x = x1;
+
+ double m11= m->sx*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;t<r0;t++)
+ palette[t] = oldcol;
+ for(t=1;t<g->num;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;
if(f->type == FILL_SOLID) {
/* plain color fill */
fill_solid(line, zline, y, x1, x2, f->color, l->p->depth);
- } else if(f->type == FILL_TILED || f->type == FILL_CLIPPED) {
+ } 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) {
fprintf(stderr, "Shape references unknown bitmap %d\n", f->id_bitmap);
fill_solid(line, zline, y, x1, x2, color_red, l->p->depth);
} else {
- 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);
}
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, "<line %d: both fillstyles set while not inside shape>\n", y);
return;
}
- n = rfx_calloc(sizeof(layer_t));
+ n = (layer_t*)rfx_calloc(sizeof(layer_t));
if(DEBUG&2) printf("<+>");
state_t fillstate;
memset(&fillstate, 0, sizeof(state_t));
qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
+ /* resort points */
+ /*if(y==884) {
+ for(n=0;n<num;n++) {
+ printf("%f (%d/%d) %d\n", points[n].x,
+ points[n].shapeline->fillstyle0,
+ 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);
for(n=0;n<num;n++) {
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;
+ 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(endx < 0)
+ endx = 0;
if(clipdepth) {
- /* for clipping, the inverse is filled */
+ /* 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);
break;
}
if(clipdepth) {
+ /* TODO: is lastx *ever* != i->width2 here? */
fill_clip(line, zline, y, lastx, i->width2, clipdepth);
}
free_layers(&fillstate);
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
RGBA* img = (RGBA*)rfx_alloc(sizeof(RGBA)*dest->width*dest->height);
int y;
- RGBA*line2=0;
-
- 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];
- 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;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;
+
+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;
}*/
}
-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;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);
+ }
+ }
+}
+
+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;t<numplacements;t++) {
+ SWFPLACEOBJECT*p = &placements[t];
+ int id = p->id;
+ 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_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 */
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;
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;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_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;
- swf_PlaceObjectFree(&p); //dirty! but it only removes items we don't need
- }
- 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;
- }
-
- 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) {
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;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);
}
-
+