X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=pdf2swf%2Fswfoutput.cc;h=0bb93c91246afd17381da975105f44e6ac5c0ab5;hb=ef496df11f68c372d0888f102d53da008ce81f7c;hp=2161d9e3fed2e074857df4a99a4204a7030207d0;hpb=602d0f0a1c8ad614029f235cc6ff38bfe26334e8;p=swftools.git diff --git a/pdf2swf/swfoutput.cc b/pdf2swf/swfoutput.cc index 2161d9e..0bb93c9 100644 --- a/pdf2swf/swfoutput.cc +++ b/pdf2swf/swfoutput.cc @@ -18,66 +18,189 @@ along with swftools; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include +#include #include +#include "../config.h" #include #include +#ifdef HAVE_ASSERT_H +#include +#else +#define assert(a) +#endif +#include #include "swfoutput.h" #include "spline.h" extern "C" { #include "../lib/log.h" #include "../lib/rfxswf.h" +#include "../lib/gfxdevice.h" +#include "../lib/gfxtools.h" } -#define standardEncodingSize 335 -extern char *standardEncodingNames[standardEncodingSize]; - -int opennewwindow=0; -int ignoredraworder=0; -int drawonlyshapes=0; -int jpegquality=85; -int storeallcharacters=0; -int enablezlib=0; -static int flag_protected = 0; - -typedef unsigned char u8; -typedef unsigned short int u16; -typedef unsigned long int u32; - -static int fi; -static char* filename = 0; -static SWF swf; -static TAG *tag; -static int currentswfid = 0; -static int depth = 1; -static int startdepth = 1; - -static SHAPE* shape; -static int shapeid = -1; -static int textid = -1; - -static int drawmode = -1; -static char storefont = 0; -static int fillstyleid; -static int linestyleid; -static int swflastx=0; -static int swflasty=0; -static int lastwasfill = 0; -static char fill = 0; -static int sizex; -static int sizey; -TAG* cliptags[128]; -int clipshapes[128]; -u32 clipdepths[128]; -int clippos = 0; - -int CHARMIDX = 0; -int CHARMIDY = 0; - -char fillstylechanged = 0; +#include "../lib/art/libart.h" + +#define CHARDATAMAX 8192 +#define CHARMIDX 0 +#define CHARMIDY 0 + +typedef struct _chardata { + int charid; + int fontid; /* TODO: use a SWFFONT instead */ + int x; + int y; + int size; + RGBA color; +} chardata_t; + +struct fontlist_t +{ + SWFFONT *swffont; + fontlist_t*next; +}; + +double config_ppmsubpixels=0; +double config_jpegsubpixels=0; +int config_opennewwindow=0; +int config_ignoredraworder=0; +int config_drawonlyshapes=0; +int config_jpegquality=85; +int config_storeallcharacters=0; +int config_enablezlib=0; +int config_insertstoptag=0; +int config_flashversion=5; +int config_splinemaxerror=1; +int config_fontsplinemaxerror=1; +int config_filloverlap=0; +int config_protect=0; +float config_minlinewidth=0.05; +double config_caplinewidth=1; + +typedef struct _swfoutput_internal +{ + swfoutput*obj; // the swfoutput object where this internal struct resides + + SWF swf; + + fontlist_t* fontlist; + + char storefont; + + MATRIX page_matrix; + + TAG *tag; + int currentswfid; + int depth; + int startdepth; + int linewidth; + + SHAPE* shape; + int shapeid; + int textid; + + int fillstyleid; + int linestyleid; + int swflastx; + int swflasty; + int lastwasfill; + int shapeisempty; + char fill; + int min_x,max_x; + int min_y,max_y; + TAG* cliptags[128]; + int clipshapes[128]; + U32 clipdepths[128]; + int clippos; + + /* image cache */ + int pic_xids[1024]; + int pic_yids[1024]; + int pic_ids[1024]; + int pic_width[1024]; + int pic_height[1024]; + int picpos; + + int frameno; + int lastframeno; + + char fillstylechanged; + + int jpeg; //next image type + + int bboxrectpos; + SRECT bboxrect; + + TAG*cliptag; + + chardata_t chardata[CHARDATAMAX]; + int chardatapos; + int firstpage; + char pagefinished; + + /* during the transition to the gfxdevice interface: + a device which uses this swfoutput as target */ + gfxdevice_t device; + +} swfoutput_internal; + +void swf_fillbitmap(gfxdevice_t*driver, gfxline_t*line, gfximage_t*img, gfxmatrix_t*move, gfxcxform_t*cxform); +int swf_setparameter(gfxdevice_t*driver, const char*key, const char*value); +void swf_drawstroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit); +void swf_startclip(gfxdevice_t*dev, gfxline_t*line); +void swf_endclip(gfxdevice_t*dev); +void swf_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit); +void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color); +void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform); +void swf_fillgradient(gfxdevice_t*dev, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix); + +static swfoutput_internal* init_internal_struct() +{ + swfoutput_internal*i = (swfoutput_internal*)malloc(sizeof(swfoutput_internal)); + memset(i, 0, sizeof(swfoutput_internal)); + + i->storefont = 0; + i->currentswfid = 0; + i->depth = 1; + i->startdepth = 1; + i->linewidth = 0; + i->shapeid = -1; + i->textid = -1; + i->frameno = 0; + i->lastframeno = 0; + + i->fillstyleid; + i->linestyleid; + i->swflastx=0; + i->swflasty=0; + i->lastwasfill = 0; + i->shapeisempty = 1; + i->fill = 0; + i->clippos = 0; + + i->fillstylechanged = 0; + + i->bboxrectpos = -1; + i->chardatapos = 0; + i->firstpage = 1; + i->pagefinished = 1; + + i->device.internal = (void*)i; + i->device.fillbitmap = swf_fillbitmap; + i->device.setparameter = swf_setparameter; + i->device.stroke = swf_stroke; + i->device.startclip = swf_startclip; + i->device.endclip = swf_endclip; + i->device.fill = swf_fill; + i->device.fillbitmap = swf_fillbitmap; + i->device.fillgradient = swf_fillgradient; + + return i; +}; static void startshape(struct swfoutput* obj); static void starttext(struct swfoutput* obj); -static void endshape(); -static void endtext(); +static void endshape(struct swfoutput* obj); +static void endtext(struct swfoutput* obj); // matrix multiplication. changes p0 static void transform (plotxy*p0,struct swfmatrix*m) @@ -90,91 +213,172 @@ static void transform (plotxy*p0,struct swfmatrix*m) } // write a move-to command into the swf -static void moveto(TAG*tag, plotxy p0) +static int moveto(struct swfoutput*obj, TAG*tag, plotxy p0) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; int rx = (int)(p0.x*20); int ry = (int)(p0.y*20); - if(rx!=swflastx || ry!=swflasty || fillstylechanged) { - swf_ShapeSetMove (tag, shape, rx,ry); - fillstylechanged = 0; + if(rx!=i->swflastx || ry!=i->swflasty || i->fillstylechanged) { + swf_ShapeSetMove (tag, i->shape, rx,ry); + i->fillstylechanged = 0; + i->swflastx=rx; + i->swflasty=ry; + return 1; + } + return 0; +} +static int moveto(struct swfoutput*obj, TAG*tag, float x, float y) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + plotxy p; + p.x = x; + p.y = y; + return moveto(obj, tag, p); +} +static void addPointToBBox(struct swfoutput*obj, int px, int py) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + + SPOINT p; + p.x = px; + p.y = py; + if(i->fill) { + swf_ExpandRect(&i->bboxrect, p); + } else { + swf_ExpandRect3(&i->bboxrect, p, i->linewidth*3/2); } - swflastx=rx; - swflasty=ry; } +/*static void plot(struct swfoutput*obj, int x, int y, TAG*tag) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + int width = i->linewidth/4; + if(width > 5) + width = 5; + ////square + //swf_ShapeSetLine(tag, i->shape,-width,-width); + //swf_ShapeSetLine(tag, i->shape,width*2,0); + //swf_ShapeSetLine(tag, i->shape,0,width*2); + //swf_ShapeSetLine(tag, i->shape,-width*2,0); + //swf_ShapeSetLine(tag, i->shape,0,-width*2); + //swf_ShapeSetLine(tag, i->shape,width,width); + + // diamond + swf_ShapeSetLine(tag, i->shape,-width,0); + swf_ShapeSetLine(tag, i->shape,width,-width); + swf_ShapeSetLine(tag, i->shape,width,width); + swf_ShapeSetLine(tag, i->shape,-width,width); + swf_ShapeSetLine(tag, i->shape,-width,-width); + swf_ShapeSetLine(tag, i->shape,width,0); + + addPointToBBox(obj, x-width ,y-width); + addPointToBBox(obj, x+width ,y+width); +}*/ + // write a line-to command into the swf -static void lineto(TAG*tag, plotxy p0) +static void lineto(struct swfoutput*obj, TAG*tag, plotxy p0) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + int px = (int)(p0.x*20); + int py = (int)(p0.y*20); + int rx = (px-i->swflastx); + int ry = (py-i->swflasty); + if(rx|ry) { + swf_ShapeSetLine (tag, i->shape, rx,ry); + addPointToBBox(obj, i->swflastx,i->swflasty); + addPointToBBox(obj, px,py); + }/* else if(!i->fill) { + // treat lines of length 0 as plots, making them + // at least 1 twip wide so Flash will display them + plot(obj, i->swflastx, i->swflasty, tag); + }*/ + + i->shapeisempty = 0; + i->swflastx+=rx; + i->swflasty+=ry; +} +static void lineto(struct swfoutput*obj, TAG*tag, double x, double y) { - int rx = ((int)(p0.x*20)-swflastx); - int ry = ((int)(p0.y*20)-swflasty); - /* we can't skip this for rx=0,ry=0, those - are plots */ - swf_ShapeSetLine (tag, shape, rx,ry); - swflastx+=rx; - swflasty+=ry; + plotxy p; + p.x = x; + p.y = y; + lineto(obj,tag, p); } // write a spline-to command into the swf -static void splineto(TAG*tag, plotxy control,plotxy end) +static void splineto(struct swfoutput*obj, TAG*tag, plotxy control,plotxy end) { - int cx = ((int)(control.x*20)-swflastx); - int cy = ((int)(control.y*20)-swflasty); - swflastx += cx; - swflasty += cy; - int ex = ((int)(end.x*20)-swflastx); - int ey = ((int)(end.y*20)-swflasty); - swflastx += ex; - swflasty += ey; - if(cx || cy || ex || ey) - swf_ShapeSetCurve(tag, shape, cx,cy,ex,ey); + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + int lastlastx = i->swflastx; + int lastlasty = i->swflasty; + + int cx = ((int)(control.x*20)-i->swflastx); + int cy = ((int)(control.y*20)-i->swflasty); + i->swflastx += cx; + i->swflasty += cy; + int ex = ((int)(end.x*20)-i->swflastx); + int ey = ((int)(end.y*20)-i->swflasty); + i->swflastx += ex; + i->swflasty += ey; + + if(cx || cy || ex || ey) { + swf_ShapeSetCurve(tag, i->shape, cx,cy,ex,ey); + addPointToBBox(obj, lastlastx ,lastlasty ); + addPointToBBox(obj, lastlastx+cx,lastlasty+cy); + addPointToBBox(obj, lastlastx+cx+ex,lastlasty+cy+ey); + }/* else if(!i->fill) { + // treat splines of length 0 as plots + plot(obj, lastlastx, lastlasty, tag); + }*/ + i->shapeisempty = 0; } /* write a line, given two points and the transformation matrix. */ -static void line(TAG*tag, plotxy p0, plotxy p1, struct swfmatrix*m) +/*static void line(struct swfoutput*obj, TAG*tag, plotxy p0, plotxy p1) { - transform(&p0,m); - transform(&p1,m); - moveto(tag, p0); - lineto(tag, p1); -} + moveto(obj, tag, p0); + lineto(obj, tag, p1); +}*/ -/* write a cubic (!) spline. This involves calling the approximate() - function out of spline.cc to convert it to a quadratic spline. */ -static void spline(TAG*tag,plotxy p0,plotxy p1,plotxy p2,plotxy p3,struct swfmatrix*m) +void resetdrawer(struct swfoutput*obj) { - double d; - struct qspline q[16]; - int num; - int t; - transform(&p0,m); - transform(&p1,m); - transform(&p2,m); - transform(&p3,m); + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + i->swflastx = 0; + i->swflasty = 0; +} - num = approximate(p0,p1,p2,p3,q); - for(t=0;tinternal; + if(i->lastwasfill) + { + swf_ShapeSetStyle(i->tag,i->shape,i->linestyleid,0x8000,0); + i->fillstylechanged = 1; + i->lastwasfill = 0; } } - -void resetdrawer() +static void startFill(struct swfoutput*obj) { - swflastx = 0; - swflasty = 0; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(!i->lastwasfill) + { + swf_ShapeSetStyle(i->tag,i->shape,0x8000,i->fillstyleid,0); + i->fillstylechanged = 1; + i->lastwasfill = 1; + } } -/* draw a T1 outline. These are generated by pdf2swf and by t1lib. - (representing characters) */ -void drawpath(TAG*tag, T1_OUTLINE*outline, struct swfmatrix*m, int log) +/* draw an outline. These are generated by pdf2swf and by t1lib + (representing characters). */ +/*void drawpath(struct swfoutput*obj, SWF_OUTLINE*outline, struct swfmatrix*m, int log) { - if(tag->id != ST_DEFINEFONT && - tag->id != ST_DEFINESHAPE && - tag->id != ST_DEFINESHAPE2 && - tag->id != ST_DEFINESHAPE3) + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if( i->tag->id != ST_DEFINESHAPE && + i->tag->id != ST_DEFINESHAPE2 && + i->tag->id != ST_DEFINESHAPE3) { - logf(" internal error: drawpath needs a shape tag, not %d\n",tag->id); + msg(" internal error: drawpath needs a shape tag, not %d\n",i->tag->id); exit(1); } double x=0,y=0; @@ -186,11 +390,23 @@ void drawpath(TAG*tag, T1_OUTLINE*outline, struct swfmatrix*m, int log) { x += (outline->dest.x/(float)0xffff); y += (outline->dest.y/(float)0xffff); - if(outline->type == T1_PATHTYPE_MOVE) + if(outline->type == SWF_PATHTYPE_MOVE) { + //if(!init && fill && obj->drawmode != DRAWMODE_EOFILL && !ignoredraworder) + if(config_filloverlap && !init && i->fill && obj->drawmode != DRAWMODE_EOFILL) { + // drawmode=FILL (not EOFILL) means that + // seperate shapes do not cancel each other out. + // On SWF side, we need to start a new shape for each + // closed polygon, because SWF only knows EOFILL. + // + endshape(obj); + startshape(obj); + startFill(obj); + } + if(((int)(lastx*20) != (int)(firstx*20) || (int)(lasty*20) != (int)(firsty*20)) && - fill && !init) + i->fill && !init) { plotxy p0; plotxy p1; @@ -199,13 +415,13 @@ void drawpath(TAG*tag, T1_OUTLINE*outline, struct swfmatrix*m, int log) p1.x=firstx; p1.y=firsty; if(log) printf("fix: %f,%f -> %f,%f\n",p0.x,p0.y,p1.x,p1.y); - line(tag, p0, p1, m); + line(obj,i->tag, p0, p1); } firstx=x; firsty=y; init = 0; } - else if(outline->type == T1_PATHTYPE_LINE) + else if(outline->type == SWF_PATHTYPE_LINE) { plotxy p0; plotxy p1; @@ -214,28 +430,10 @@ void drawpath(TAG*tag, T1_OUTLINE*outline, struct swfmatrix*m, int log) p1.x=x; p1.y=y; if(log) printf("line: %f,%f -> %f,%f\n",p0.x,p0.y,p1.x,p1.y); - line(tag, p0,p1,m); + line(obj,i->tag, p0,p1); } - else if(outline->type == T1_PATHTYPE_BEZIER) - { - plotxy p0; - plotxy p1; - plotxy p2; - plotxy p3; - T1_BEZIERSEGMENT*o2 = (T1_BEZIERSEGMENT*)outline; - p0.x=x; - p0.y=y; - p1.x=o2->C.x/(float)0xffff+lastx; - p1.y=o2->C.y/(float)0xffff+lasty; - p2.x=o2->B.x/(float)0xffff+lastx; - p2.y=o2->B.y/(float)0xffff+lasty; - p3.x=lastx; - p3.y=lasty; - if(log) printf("spline: %f,%f -> %f,%f\n",p3.x,p3.y,p0.x,p0.y); - spline(tag,p0,p1,p2,p3,m); - } else { - logf(" drawpath: unknown outline type:%d\n", outline->type); + msg(" drawpath: unknown outline type:%d\n", outline->type); } lastx=x; lasty=y; @@ -243,7 +441,7 @@ void drawpath(TAG*tag, T1_OUTLINE*outline, struct swfmatrix*m, int log) } if(((int)(lastx*20) != (int)(firstx*20) || (int)(lasty*20) != (int)(firsty*20)) && - fill) + i->fill) { plotxy p0; plotxy p1; @@ -252,11 +450,11 @@ void drawpath(TAG*tag, T1_OUTLINE*outline, struct swfmatrix*m, int log) p1.x=firstx; p1.y=firsty; if(log) printf("fix: %f,%f -> %f,%f\n",p0.x,p0.y,p1.x,p1.y); - line(tag, p0, p1, m); + line(obj, i->tag, p0, p1); } -} +}*/ -static inline int colorcompare(RGBA*a,RGBA*b) +static inline int colorcompare(struct swfoutput*obj, RGBA*a,RGBA*b) { if(a->r!=b->r || @@ -268,23 +466,72 @@ static inline int colorcompare(RGBA*a,RGBA*b) return 1; } -static const int CHARDATAMAX = 1024; -struct chardata { - int charid; - int fontid; - int x; - int y; - int size; - RGBA color; -} chardata[CHARDATAMAX]; -int chardatapos = 0; +static SRECT getcharacterbbox(struct swfoutput*obj, SWFFONT*font) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + SRECT r; + char debug = 0; + memset(&r, 0, sizeof(r)); -static void putcharacters(TAG*tag) + int t; + if(debug) printf("\n"); + for(t=0;tchardatapos;t++) + { + if(i->chardata[t].fontid != font->id) { + msg(" Internal error: fontid %d != fontid %d", i->chardata[t].fontid, font->id); + exit(1); + } + SRECT b = font->layout->bounds[i->chardata[t].charid]; + b.xmin *= i->chardata[t].size; + b.ymin *= i->chardata[t].size; + b.xmax *= i->chardata[t].size; + b.ymax *= i->chardata[t].size; + b.xmin /= 1024; + b.ymin /= 1024; + b.xmax /= 1024; + b.ymax /= 1024; + b.xmin += i->chardata[t].x; + b.ymin += i->chardata[t].y; + b.xmax += i->chardata[t].x; + b.ymax += i->chardata[t].y; + + /* until we solve the INTERNAL_SCALING problem (see below) + make sure the bounding box is big enough */ + b.xmin -= 20; + b.ymin -= 20; + b.xmax += 20; + b.ymax += 20; + + if(debug) printf("(%f,%f,%f,%f) -> (%f,%f,%f,%f) [font %d/%d, char %d]\n", + font->layout->bounds[i->chardata[t].charid].xmin/20.0, + font->layout->bounds[i->chardata[t].charid].ymin/20.0, + font->layout->bounds[i->chardata[t].charid].xmax/20.0, + font->layout->bounds[i->chardata[t].charid].ymax/20.0, + b.xmin/20.0, + b.ymin/20.0, + b.xmax/20.0, + b.ymax/20.0, + i->chardata[t].fontid, + font->id, + i->chardata[t].charid + ); + swf_ExpandRect2(&r, &b); + } + if(debug) printf("-----> (%f,%f,%f,%f)\n", + r.xmin/20.0, + r.ymin/20.0, + r.xmax/20.0, + r.ymax/20.0); + return r; +} + +static void putcharacters(struct swfoutput*obj, TAG*tag) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; int t; SWFFONT font; RGBA color; - color.r = chardata[0].color.r^255; + color.r = i->chardata[0].color.r^255; color.g = 0; color.b = 0; color.a = 0; @@ -301,11 +548,11 @@ static void putcharacters(TAG*tag) if(tag->id != ST_DEFINETEXT && tag->id != ST_DEFINETEXT2) { - logf(" internal error: putcharacters needs an text tag, not %d\n",tag->id); + msg(" internal error: putcharacters needs an text tag, not %d\n",tag->id); exit(1); } - if(!chardatapos) { - logf(" putcharacters called with zero characters"); + if(!i->chardatapos) { + msg(" putcharacters called with zero characters"); } for(pass = 0; pass < 2; pass++) @@ -323,15 +570,15 @@ static void putcharacters(TAG*tag) swf_SetU8(tag, advancebits); } - for(t=0;t<=chardatapos;t++) + for(t=0;t<=i->chardatapos;t++) { - if(lastfontid != chardata[t].fontid || - lastx!=chardata[t].x || - lasty!=chardata[t].y || - !colorcompare(&color, &chardata[t].color) || + if(lastfontid != i->chardata[t].fontid || + lastx!=i->chardata[t].x || + lasty!=i->chardata[t].y || + !colorcompare(obj,&color, &i->chardata[t].color) || charstorepos==127 || - lastsize != chardata[t].size || - t == chardatapos) + lastsize != i->chardata[t].size || + t == i->chardatapos) { if(charstorepos && pass==0) { @@ -358,104 +605,134 @@ static void putcharacters(TAG*tag) } charstorepos = 0; - if(pass == 1 && tchardatapos) { RGBA*newcolor=0; SWFFONT*newfont=0; int newx = 0; int newy = 0; - if(lastx != chardata[t].x || - lasty != chardata[t].y) + if(lastx != i->chardata[t].x || + lasty != i->chardata[t].y) { - newx=chardata[t].x; - newy=chardata[t].y; + newx = i->chardata[t].x; + newy = i->chardata[t].y; + if(newx == 0) + newx = SET_TO_ZERO; + if(newy == 0) + newy = SET_TO_ZERO; } - if(!colorcompare(&color, &chardata[t].color)) + if(!colorcompare(obj,&color, &i->chardata[t].color)) { - color = chardata[t].color; + color = i->chardata[t].color; newcolor = &color; } - font.id = chardata[t].fontid; - if(lastfontid != chardata[t].fontid || lastsize != chardata[t].size) + font.id = i->chardata[t].fontid; + if(lastfontid != i->chardata[t].fontid || lastsize != i->chardata[t].size) newfont = &font; tag->writeBit = 0; // Q&D - swf_TextSetInfoRecord(tag, newfont, chardata[t].size, newcolor, newx,newy); + swf_TextSetInfoRecord(tag, newfont, i->chardata[t].size, newcolor, newx,newy); } - lastfontid = chardata[t].fontid; - lastx = chardata[t].x; - lasty = chardata[t].y; - lastsize = chardata[t].size; + lastfontid = i->chardata[t].fontid; + lastx = i->chardata[t].x; + lasty = i->chardata[t].y; + lastsize = i->chardata[t].size; } - if(t==chardatapos) + if(t==i->chardatapos) break; int advance; - int nextt = t==chardatapos-1?t:t+1; - int rel = chardata[nextt].x-chardata[t].x; + int nextt = t==i->chardatapos-1?t:t+1; + int rel = i->chardata[nextt].x-i->chardata[t].x; if(rel>=0 && (rel<(1<<(advancebits-1)) || pass==0)) { advance = rel; - lastx=chardata[nextt].x; + lastx=i->chardata[nextt].x; } else { advance = 0; - lastx=chardata[t].x; + lastx=i->chardata[t].x; } - charids[charstorepos] = chardata[t].charid; + charids[charstorepos] = i->chardata[t].charid; charadvance[charstorepos] = advance; charstorepos ++; } } - chardatapos = 0; + i->chardatapos = 0; } -static void putcharacter(struct swfoutput*obj, int fontid, int charid, - int x,int y, int size) +static void putcharacter(struct swfoutput*obj, int fontid, int charid, int x,int y, int size, RGBA color) { - if(chardatapos == CHARDATAMAX) + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(i->chardatapos == CHARDATAMAX) { - endtext(); + msg(" Character buffer too small. SWF will be slightly bigger"); + endtext(obj); starttext(obj); } - chardata[chardatapos].fontid = fontid; - chardata[chardatapos].charid = charid; - chardata[chardatapos].x = x; - chardata[chardatapos].y = y; - chardata[chardatapos].color = obj->fillrgb; - chardata[chardatapos].size = size; - chardatapos++; + i->chardata[i->chardatapos].fontid = fontid; + i->chardata[i->chardatapos].charid = charid; + i->chardata[i->chardatapos].x = x; + i->chardata[i->chardatapos].y = y; + i->chardata[i->chardatapos].color = color; + i->chardata[i->chardatapos].size = size; + i->chardatapos++; } +/* Notice: we can only put chars in the range -1639,1638 (-32768/20,32768/20). + So if we set this value to high, the char coordinates will overflow. + If we set it to low, however, the char positions will be inaccurate */ +#define FONT_INTERNAL_SIZE 4 /* process a character. */ -static void drawchar(struct swfoutput*obj, SWFFont*font, char*character, int charnr, swfmatrix*m) +static int drawchar(struct swfoutput*obj, SWFFONT *swffont, char*character, int charnr, int u, swfmatrix*m, gfxcolor_t*col) { - int usefonts=1; - if(m->m12!=0 || m->m21!=0) - usefonts=0; - if(m->m11 != m->m22) - usefonts=0; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(!swffont) { + msg(" Font is NULL"); + return 0; + } - if(usefonts && ! drawonlyshapes) - { - int charid = font->getSWFCharID(character, charnr); - if(shapeid>=0) - endshape(); - if(textid<0) - starttext(obj); - putcharacter(obj, font->swfid, charid,(int)(m->m13*20),(int)(m->m23*20), - (int)(m->m11*20/2+0.5)); //where does the /2 come from? + int charid = getCharID(swffont, charnr, character, u); + + if(charid<0) { + msg(" Didn't find character '%s' (c=%d,u=%d) in current charset (%s, %d characters)", + FIXNULL(character),charnr, u, FIXNULL((char*)swffont->name), swffont->numchars); + return 0; } - else + + if(i->shapeid>=0) + endshape(obj); + if(i->textid<0) + starttext(obj); + + float x = m->m13; + float y = m->m23; + float det = ((m->m11*m->m22)-(m->m21*m->m12)); + if(fabs(det) < 0.0005) { + /* x direction equals y direction- the text is invisible */ + return 1; + } + det = 20*FONT_INTERNAL_SIZE / det; + + SPOINT p; + p.x = (SCOORD)(( x * m->m22 - y * m->m12)*det); + p.y = (SCOORD)((- x * m->m21 + y * m->m11)*det); + + RGBA rgba = *(RGBA*)col; + putcharacter(obj, swffont->id, charid,p.x,p.y,FONT_INTERNAL_SIZE, rgba); + swf_FontUseGlyph(swffont, charid); + return 1; + + /*else { - T1_OUTLINE*outline = font->getOutline(character); + SWF_OUTLINE*outline = font->getOutline(character, charnr); char* charname = character; if(!outline) { - logf(" Didn't find %s in current charset (%s)", - FIXNULL(character),FIXNULL(font->getName())); + msg(" Didn't find character '%s' (%d) in current charset (%s)", + FIXNULL(character),charnr,FIXNULL(font->getName())); return; } @@ -466,340 +743,205 @@ static void drawchar(struct swfoutput*obj, SWFFont*font, char*character, int cha m2.m22/=100; if(textid>=0) - endtext(); + endtext(obj); if(shapeid<0) startshape(obj); - if(!lastwasfill) { - swf_ShapeSetStyle(tag,shape,0x8000,fillstyleid,0); - fillstylechanged = 1; - } - lastwasfill = 1; + startFill(obj); int lf = fill; fill = 1; drawpath(tag, outline, &m2, 0); fill = lf; - } + }*/ } -/* draw a curved polygon. */ -void swfoutput_drawpath(swfoutput*output, T1_OUTLINE*outline, - struct swfmatrix*m) +static void endtext(swfoutput*obj) { - if(textid>=0) - endtext(); - - /* Multiple polygons in one shape don't overlap correctly, - so we better start a new shape here if the polygon is filled - */ - if(shapeid>=0 && fill && !ignoredraworder) { - endshape(); - } - - if(shapeid<0) - startshape(output); - - if(lastwasfill && !fill) - { - swf_ShapeSetStyle(tag,shape,linestyleid,0x8000,0); - fillstylechanged = 1; - lastwasfill = 0; - } - if(!lastwasfill && fill) - { - swf_ShapeSetStyle(tag,shape,0x8000,fillstyleid,0); - fillstylechanged = 1; - lastwasfill = 1; - } - - drawpath(tag, outline,m, 0); -} - -/* SWFFont: copy all t1 font outlines to a local - array. */ -SWFFont::SWFFont(char*name, int id, char*filename) -{ - if(!T1_GetFontName(id)) - T1_LoadFont(id); - - this->name = strdup(T1_GetFontFileName(id)); - this->fontid = strdup(name); - this->t1id = id; - - char**a= T1_GetAllCharNames(id); - int t, outlinepos=0; - char*map[256]; - - t=0; - while(a[t]) - t++; - this->charnum = t; - - if(!charnum) + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(i->textid<0) return; - logf(" Font %s(%d): Storing %d outlines.\n", FIXNULL(name), id, charnum); - this->standardtablesize = 256; - if(this->charnum < this->standardtablesize) - this->standardtablesize = this->charnum; - this->standardtable = (char**)malloc(standardtablesize*sizeof(char*)); + i->tag = swf_InsertTag(i->tag,ST_DEFINETEXT); + swf_SetU16(i->tag, i->textid); - for(t = 0; t < this->standardtablesize; t++) { - char*name = T1_GetCharName(id,t); - if(!name) - name = ""; - standardtable[t] = strdup(name); - } - - outline = (T1_OUTLINE**)malloc(charnum*sizeof(T1_OUTLINE*)); - charname = (char**)malloc(charnum*sizeof(char*)); - width = (int*)malloc(charnum*sizeof(int)); - memset(width, 0, charnum*sizeof(int)); - memset(charname, 0, charnum*sizeof(char*)); - used = (char*)malloc(charnum*sizeof(char)); - char2swfcharid = (U16*)malloc(charnum*2); - swfcharid2char = (U16*)malloc(charnum*2); - swfcharpos = 0; - - memset(used,0,charnum*sizeof(char)); - - this->swfid = ++currentswfid; + SRECT r; + r = getcharacterbbox(obj, obj->swffont); - t=0; - while(*a) - { - map[t] = *a; - a++; - t++; - if(t==256 || !*a) { - int s; - for(s=t;s<256;s++) - map[s] = ".notdef"; - - int ret = T1_ReencodeFont(id, map); - if(ret) { - T1_DeleteFont(id); - T1_LoadFont(id); - int ret = T1_ReencodeFont(id, map); - if(ret) - fprintf(stderr,"Can't reencode font: (%s) ret:%d\n",filename, ret); - } + swf_SetRect(i->tag,&r); - // parsecharacters - for(s=0;soutline[outlinepos] = T1_CopyOutline(T1_GetCharOutline(id, s, 100.0, 0)); - this->width[outlinepos] = T1_GetCharWidth(id, s); - this->charname[outlinepos] = strdup(name); - outlinepos++; - } - t=0; - } - } + MATRIX m; + swf_GetMatrix(0, &m); /* set unit matrix- the real matrix is in the placeobject */ + swf_SetMatrix(i->tag,&m); + + putcharacters(obj, i->tag); + swf_SetU8(i->tag,0); + i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2); + //swf_ObjectPlace(i->tag,i->textid,/*depth*/i->depth++,&i->page_matrix,NULL,NULL); + MATRIX m2; + swf_MatrixJoin(&m2,&obj->fontmatrix, &i->page_matrix); + + swf_ObjectPlace(i->tag,i->textid,/*depth*/i->depth++,&m2,NULL,NULL); + i->textid = -1; } -/* free all tables, write out definefont tags */ -SWFFont::~SWFFont() +int getCharID(SWFFONT *font, int charnr, char *charname, int u) { - int t,usednum=0; - int*ptr; - - if(storeallcharacters) - { - int t; - for(t=0;tcharnum;t++) - { - if(this->charname[t]) - getSWFCharID(this->charname[t], -1); - } - } - - ptr = (int*)malloc(swfcharpos*sizeof(int)); - - for(t=0;t Font %s has %d used characters",FIXNULL(fontid), usednum); - TAG*ftag = swf_InsertTag(swf.firstTag,ST_DEFINEFONT); - swf_SetU16(ftag, this->swfid); - int initpos = swf_GetTagLen(ftag); - swfmatrix m; - m.m11 = m.m22 = 1; - m.m21 = m.m12 = 0; - m.m13 = CHARMIDX; - m.m23 = CHARMIDY; - - for(t=0;tdata[ptr[t]] = - SWAP16(swf_GetTagLen(ftag)-initpos); - - swflastx=0; - swflasty=0; - swf_SetU8(ftag,0x10); //1 fill bits, 0 linestyle bits - SHAPE s; - s.bits.fill = 1; - s.bits.line = 0; - swf_ShapeSetStyle(ftag,&s,0,1,0); - fillstylechanged = 1; - int lastfill = fill; - fill = 1; - storefont = 1; - drawpath(ftag, outline[swfcharid2char[t]],&m, 0); - storefont = 0; - fill = lastfill; - swf_ShapeSetEnd(ftag); - } - ftag = swf_InsertTag(ftag,ST_DEFINEFONTINFO); - swf_SetU16(ftag, this->swfid); - if(this->fontid) { - swf_SetU8(ftag, strlen(this->fontid)); - swf_SetBlock(ftag, (U8*)this->fontid, strlen(this->fontid)); - } else { - swf_SetU8(ftag, 0); + int t; + if(charname && font->glyphnames) { + for(t=0;tnumchars;t++) { + if(font->glyphnames[t] && !strcmp(font->glyphnames[t],charname)) { + msg(" Char [%d,>%s<,%d] maps to %d\n", charnr, charname, u, t); + return t; + } } - swf_SetU8(ftag, 0); //flags - for(t=0;tcharname[this->swfcharid2char[t]]; - for(s=0;s<256;s++) { - if(standardEncodingNames[s] && - !strcmp(name,standardEncodingNames[s])) - break; + /* if we didn't find the character, maybe + we can find the capitalized version */ + for(t=0;tnumchars;t++) { + if(font->glyphnames[t] && !strcasecmp(font->glyphnames[t],charname)) { + msg(" Char [%d,>>%s<<,%d] maps to %d\n", charnr, charname, u, t); + return t; } - swf_SetU8(ftag, (U8)s); } } - free(ptr); - free(outline); - for(t=0;t0 && font->encoding != 255) { + /* try to use the unicode id */ + if(u>=0 && umaxascii && font->ascii2glyph[u]>=0) { + msg(" Char [%d,%s,>%d<] maps to %d\n", charnr, charname, u, font->ascii2glyph[u]); + return font->ascii2glyph[u]; } - free(standardtable); - free(charname); - free(width); - free(used); - free(swfcharid2char); - free(char2swfcharid); -} - -T1_OUTLINE*SWFFont::getOutline(char*name) -{ - int t; - for(t=0;tcharnum;t++) { - if(!strcmp(this->charname[t],name)) { - if(!used[t]) - { - swfcharid2char[swfcharpos] = t; - char2swfcharid[t] = swfcharpos; - swfcharpos++; - used[t] = 1; - } - return outline[t]; - } - } - return 0; -} - -int SWFFont::getWidth(char*name) -{ - int t; - for(t=0;tcharnum;t++) { - if(!strcmp(this->charname[t],name)) { - return this->width[t]; - } } - return 0; -} -int SWFFont::getSWFCharID(char*name, int charnr) -{ - int t; - for(t=0;tcharnum;t++) { - if(!strcmp(this->charname[t],name)) { - if(!used[t]) - { - swfcharid2char[swfcharpos] = t; - char2swfcharid[t] = swfcharpos++; - used[t] = 1; - } - return char2swfcharid[t]; - } - } - if(this->standardtable && charnr>=0 && charnr < this->standardtablesize) { - return getSWFCharID(this->standardtable[charnr], -1); + if(font->encoding != FONT_ENCODING_UNICODE) { + /* the following only works if the font encoding + is US-ASCII based. It's needed for fonts which return broken unicode + indices */ + if(charnr>=0 && charnrmaxascii && font->ascii2glyph[charnr]>=0) { + msg(" Char [>%d<,%s,%d] maps to %d\n", charnr, charname, u, font->ascii2glyph[charnr]); + return font->ascii2glyph[charnr]; + } + } + + if(charnr>=0 && charnrnumchars) { + msg(" Char [>%d<,%s,%d] maps to %d\n", charnr, charname, u, charnr); + return charnr; } - logf(" Didn't find character '%s' in font '%s'", FIXNULL(name), this->name); - return 0; -} - -char*SWFFont::getName() -{ - return this->name; + + return -1; } -struct fontlist_t -{ - SWFFont * font; - fontlist_t*next; -} *fontlist = 0; /* set's the t1 font index of the font to use for swfoutput_drawchar(). */ -void swfoutput_setfont(struct swfoutput*obj, char*fontid, int t1id, char*filename) +void swfoutput_setfont(struct swfoutput*obj, char*fontid, char*filename) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; fontlist_t*last=0,*iterator; - if(obj->font && !strcmp(obj->font->fontid,fontid)) + if(!fontid) { + msg(" No fontid"); + return; + } + + if(obj->swffont && obj->swffont->name && !strcmp((char*)obj->swffont->name,fontid)) return; - iterator = fontlist; + /* TODO: remove the need for this (enhance getcharacterbbox so that it can cope + with multiple fonts */ + endtext(obj); + + iterator = i->fontlist; while(iterator) { - if(!strcmp(iterator->font->fontid,fontid)) - break; + if(!strcmp((char*)iterator->swffont->name,fontid)) { + obj->swffont = iterator->swffont; + return; + } last = iterator; iterator = iterator->next; } - if(iterator) - { - obj->font = iterator->font; - return ; + + if(!filename) { + msg(" No filename given for font- internal error?"); + return; } - if(t1id<0) { - logf(" internal error: t1id:%d, fontid:%s\n", t1id,FIXNULL(fontid)); + swf_SetLoadFontParameters(64,/*skip unused*/0,/*full unicode*/1); + SWFFONT*swffont = swf_LoadFont(filename); + + if(swffont == 0) { + msg(" Couldn't load font %s (%s)", fontid, filename); + swffont = swf_LoadFont(0); + } + + if(swffont->glyph2ascii) { + int t; + int bad = 0; + /* check whether the Unicode indices look o.k. + If they don't, disable the unicode lookup by setting + the encoding to 255 */ + for(t=0;tnumchars;t++) { + int c = swffont->glyph2ascii[t]; + if(c && c < 32 && swffont->glyph[t].shape->bitlen > 16) { + // the character maps into the unicode control character range + // between 0001-001f. Yet it is not empty. Treat the one + // mapping as broken, and look how many of those we find. + bad ++; + } + } + if(bad>5) { + msg(" Font %s has bad unicode mapping", fontid); + swffont->encoding = 255; + } } + + swf_FontSetID(swffont, ++i->currentswfid); - SWFFont*font = new SWFFont(fontid, t1id, filename); + if(getScreenLogLevel() >= LOGLEVEL_DEBUG) { + // print font information + msg(" Font %s (%s)",swffont->name, filename); + msg(" | ID: %d", swffont->id); + msg(" | Version: %d", swffont->version); + msg(" | Name: %s", fontid); + msg(" | Numchars: %d", swffont->numchars); + msg(" | Maxascii: %d", swffont->maxascii); + msg(" | Style: %d", swffont->style); + msg(" | Encoding: %d", swffont->encoding); + for(int iii=0; iiinumchars;iii++) { + msg(" | Glyph %d) name=%s, unicode=%d size=%d bbox=(%.2f,%.2f,%.2f,%.2f)\n", iii, swffont->glyphnames?swffont->glyphnames[iii]:"", swffont->glyph2ascii[iii], swffont->glyph[iii].shape->bitlen, + swffont->layout->bounds[iii].xmin/20.0, + swffont->layout->bounds[iii].ymin/20.0, + swffont->layout->bounds[iii].xmax/20.0, + swffont->layout->bounds[iii].ymax/20.0 + ); + int t; + for(t=0;tmaxascii;t++) { + if(swffont->ascii2glyph[t] == iii) + msg(" | - maps to %d",t); + } + } + } + + /* set the font name to the ID we use here */ + if(swffont->name) free(swffont->name); + swffont->name = (U8*)strdup(fontid); + iterator = new fontlist_t; - iterator->font = font; + iterator->swffont = swffont; iterator->next = 0; if(last) last->next = iterator; else - fontlist = iterator; - obj->font = font; + i->fontlist = iterator; + + obj->swffont = swffont; } int swfoutput_queryfont(struct swfoutput*obj, char*fontid) { - fontlist_t *iterator = fontlist; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + fontlist_t *iterator = i->fontlist; while(iterator) { - if(!strcmp(iterator->font->fontid,fontid)) + if(!strcmp((char*)iterator->swffont->name,fontid)) return 1; iterator = iterator->next; } @@ -811,22 +953,31 @@ int swfoutput_queryfont(struct swfoutput*obj, char*fontid) void swfoutput_setfontmatrix(struct swfoutput*obj,double m11,double m12, double m21,double m22) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; if(obj->fontm11 == m11 && obj->fontm12 == m12 && obj->fontm21 == m21 && obj->fontm22 == m22) return; -// if(textid>=0) -// endtext(); + if(i->textid>=0) + endtext(obj); obj->fontm11 = m11; obj->fontm12 = m12; obj->fontm21 = m21; obj->fontm22 = m22; + + MATRIX m; + m.sx = (U32)(((obj->fontm11)*65536)/FONT_INTERNAL_SIZE); m.r1 = (U32)(((obj->fontm12)*65536)/FONT_INTERNAL_SIZE); + m.r0 = (U32)(((obj->fontm21)*65536)/FONT_INTERNAL_SIZE); m.sy = (U32)(((obj->fontm22)*65536)/FONT_INTERNAL_SIZE); + m.tx = 0; + m.ty = 0; + obj->fontmatrix = m; } /* draws a character at x,y. */ -void swfoutput_drawchar(struct swfoutput* obj,double x,double y,char*character, int charnr) +int swfoutput_drawchar(struct swfoutput* obj,double x,double y,char*character, int charnr, int u, gfxcolor_t* color) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; swfmatrix m; m.m11 = obj->fontm11; m.m12 = obj->fontm12; @@ -834,222 +985,476 @@ void swfoutput_drawchar(struct swfoutput* obj,double x,double y,char*character, m.m22 = obj->fontm22; m.m13 = x; m.m23 = y; - drawchar(obj, obj->font, character, charnr, &m); + return drawchar(obj, obj->swffont, character, charnr, u, &m, color); } -/* initialize the swf writer */ -void swfoutput_init(struct swfoutput* obj, char*_filename, int _sizex, int _sizey) +static void endpage(struct swfoutput*obj) { - GLYPH *glyph; - RGBA rgb; - SRECT r; - memset(obj, 0, sizeof(struct swfoutput)); - filename = _filename; - sizex = _sizex; - sizey = _sizey; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(i->shapeid>=0) + endshape(obj); + if(i->textid>=0) + endtext(obj); + while(i->clippos) + swfoutput_endclip(obj); + i->pagefinished = 1; +} - logf(" initializing swf output for size %d*%d\n", sizex,sizey); +void swfoutput_pagefeed(struct swfoutput*obj) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + + if(!i->pagefinished) + endpage(obj); + + if(config_insertstoptag) { + ActionTAG*atag=0; + atag = action_Stop(atag); + atag = action_End(atag); + i->tag = swf_InsertTag(i->tag,ST_DOACTION); + swf_ActionSet(i->tag,atag); + } + i->tag = swf_InsertTag(i->tag,ST_SHOWFRAME); + i->frameno ++; + + for(i->depth--;i->depth>=i->startdepth;i->depth--) { + i->tag = swf_InsertTag(i->tag,ST_REMOVEOBJECT2); + swf_SetU16(i->tag,i->depth); + } + i->depth = i->startdepth; +} - obj->font = 0; - - memset(&swf,0x00,sizeof(SWF)); +static void setBackground(struct swfoutput*obj, int x1, int y1, int x2, int y2) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + RGBA rgb; + rgb.a = rgb.r = rgb.g = rgb.b = 0xff; + SRECT r; + SHAPE* s; + int ls1=0,fs1=0; + int shapeid = ++i->currentswfid; + r.xmin = x1; + r.ymin = y1; + r.xmax = x2; + r.ymax = y2; + i->tag = swf_InsertTag(i->tag, ST_DEFINESHAPE); + swf_ShapeNew(&s); + fs1 = swf_ShapeAddSolidFillStyle(s, &rgb); + swf_SetU16(i->tag,shapeid); + swf_SetRect(i->tag,&r); + swf_SetShapeHeader(i->tag,s); + swf_ShapeSetAll(i->tag,s,x1,y1,ls1,fs1,0); + swf_ShapeSetLine(i->tag,s,(x2-x1),0); + swf_ShapeSetLine(i->tag,s,0,(y2-y1)); + swf_ShapeSetLine(i->tag,s,(x1-x2),0); + swf_ShapeSetLine(i->tag,s,0,(y1-y2)); + swf_ShapeSetEnd(i->tag); + swf_ShapeFree(s); + i->tag = swf_InsertTag(i->tag, ST_PLACEOBJECT2); + swf_ObjectPlace(i->tag,shapeid,i->depth++,0,0,0); + i->tag = swf_InsertTag(i->tag, ST_PLACEOBJECT2); + swf_ObjectPlaceClip(i->tag,shapeid,i->depth++,0,0,0,65535); + i->cliptag = i->tag; +} - swf.fileVersion = 4; - swf.frameRate = 0x0040; // 1 frame per 4 seconds - swf.movieSize.xmax = 20*sizex; - swf.movieSize.ymax = 20*sizey; - - swf.firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR); - tag = swf.firstTag; - rgb.r = 0xff; - rgb.g = 0xff; - rgb.b = 0xff; - swf_SetRGB(tag,&rgb); - if(flag_protected) // good practice! /r - tag = swf_InsertTag(tag, ST_PROTECT); - depth = 1; - startdepth = depth; +void swfoutput_newpage(struct swfoutput*obj, int pageNum, int movex, int movey, int x1, int y1, int x2, int y2) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(!i->firstpage && !i->pagefinished) + endpage(obj); + + swf_GetMatrix(0, &i->page_matrix); + i->page_matrix.tx = movex*20; + i->page_matrix.ty = movey*20; + + if(i->cliptag && i->frameno == i->lastframeno) { + SWFPLACEOBJECT obj; + swf_GetPlaceObject(i->cliptag, &obj); + obj.clipdepth = i->depth++; + swf_ResetTag(i->cliptag, i->cliptag->id); + swf_SetPlaceObject(i->cliptag, &obj); + swf_PlaceObjectFree(&obj); + } + + i->min_x = x1; + i->min_y = y1; + i->max_x = x2; + i->max_y = y2; + + msg(" processing page %d (%dx%d:%d:%d)", pageNum,x2-x1,y2-y1, x1, y1); + + x1*=20;y1*=20;x2*=20;y2*=20; + + /* set clipping/background rectangle */ + /* TODO: this should all be done in SWFOutputDev */ + setBackground(obj, x1, y1, x2, y2); + + /* increase SWF's bounding box */ + SRECT r; + r.xmin = x1; + r.ymin = y1; + r.xmax = x2; + r.ymax = y2; + swf_ExpandRect2(&i->swf.movieSize, &r); + + i->lastframeno = i->frameno; + i->firstpage = 0; + i->pagefinished = 0; } -void swfoutput_setprotected() //write PROTECT tag +/* initialize the swf writer */ +void swfoutput_init(struct swfoutput* obj) { - flag_protected = 1; + memset(obj, 0, sizeof(struct swfoutput)); + obj->internal = init_internal_struct(); + ((swfoutput_internal*)obj->internal)->obj = obj; + + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + + SRECT r; + RGBA rgb; + + msg(" initializing swf output for size %d*%d\n", i->max_x,i->max_y); + + obj->swffont = 0; + + memset(&i->swf,0x00,sizeof(SWF)); + + i->swf.fileVersion = config_flashversion; + i->swf.frameRate = 0x0040; // 1 frame per 4 seconds + i->swf.movieSize.xmin = 0; + i->swf.movieSize.ymin = 0; + i->swf.movieSize.xmax = 0; + i->swf.movieSize.ymax = 0; + + i->swf.firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR); + i->tag = i->swf.firstTag; + rgb.a = rgb.r = rgb.g = rgb.b = 0xff; + swf_SetRGB(i->tag,&rgb); + + i->startdepth = i->depth = 3; /* leave room for clip and background rectangle */ + + if(config_protect) + i->tag = swf_InsertTag(i->tag, ST_PROTECT); } static void startshape(struct swfoutput*obj) { - RGBA rgb; - SRECT r; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + SRECT r; - if(textid>=0) - endtext(); + if(i->shapeid>=0) + return; - tag = swf_InsertTag(tag,ST_DEFINESHAPE); + if(i->textid>=0) + endtext(obj); - swf_ShapeNew(&shape); - linestyleid = swf_ShapeAddLineStyle(shape,obj->linewidth,&obj->strokergb); - rgb.r = obj->fillrgb.r; - rgb.g = obj->fillrgb.g; - rgb.b = obj->fillrgb.b; - fillstyleid = swf_ShapeAddSolidFillStyle(shape,&obj->fillrgb); + i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE); - shapeid = ++currentswfid; - swf_SetU16(tag,shapeid); // ID + swf_ShapeNew(&i->shape); + i->linestyleid = swf_ShapeAddLineStyle(i->shape,i->linewidth,&obj->strokergb); + i->fillstyleid = swf_ShapeAddSolidFillStyle(i->shape,&obj->fillrgb); - r.xmin = 0; - r.ymin = 0; - r.xmax = 20*sizex; - r.ymax = 20*sizey; - - swf_SetRect(tag,&r); + i->shapeid = ++i->currentswfid; + + msg(" Using shape id %d", i->shapeid); + + swf_SetU16(i->tag,i->shapeid); // ID + + i->bboxrectpos = i->tag->len; + /* changed later */ + r.xmin = 0; + r.ymin = 0; + r.xmax = 20*i->max_x; + r.ymax = 20*i->max_y; + swf_SetRect(i->tag,&r); + + memset(&i->bboxrect, 0, sizeof(i->bboxrect)); - swf_SetShapeStyles(tag,shape); - swf_ShapeCountBits(shape,NULL,NULL); - swf_SetShapeBits(tag,shape); + swf_SetShapeStyles(i->tag,i->shape); + swf_ShapeCountBits(i->shape,NULL,NULL); + swf_SetShapeBits(i->tag,i->shape); - swf_ShapeSetAll(tag,shape,/*x*/0,/*y*/0,linestyleid,0,0); - swflastx=swflasty=0; - lastwasfill = 0; + /* TODO: do we really need this? */ + swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,i->linestyleid,0,0); + i->swflastx=i->swflasty=0; + i->lastwasfill = 0; + i->shapeisempty = 1; } static void starttext(struct swfoutput*obj) { - SRECT r; - MATRIX m; - if(shapeid>=0) - endshape(); - tag = swf_InsertTag(tag,ST_DEFINETEXT); - textid = ++currentswfid; - swf_SetU16(tag, textid); - - r.xmin = 0; - r.ymin = 0; - r.xmax = 20*sizex; - r.ymax = 20*sizey; - - swf_SetRect(tag,&r); - - m.sx = 65536; - m.sy = 65536; - m.r0 = 0; - m.r1 = 0; - m.tx = 0; - m.ty = 0; - - swf_SetMatrix(tag,&m); - swflastx=swflasty=0; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(i->shapeid>=0) + endshape(obj); + + i->textid = ++i->currentswfid; + + i->swflastx=i->swflasty=0; } + -static void endshape() +/* TODO: move to ../lib/rfxswf */ +void changeRect(struct swfoutput*obj, TAG*tag, int pos, SRECT*newrect) { - if(shapeid<0) - return; - swf_ShapeSetEnd(tag); - tag = swf_InsertTag(tag,ST_PLACEOBJECT2); - swf_ObjectPlace(tag,shapeid,/*depth*/depth++,NULL,NULL,NULL); - shapeid = -1; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + /* determine length of old rect */ + tag->pos = pos; + tag->readBit = 0; + SRECT old; + swf_GetRect(tag, &old); + swf_ResetReadBits(tag); + int pos_end = tag->pos; + + int len = tag->len - pos_end; + U8*data = (U8*)malloc(len); + memcpy(data, &tag->data[pos_end], len); + tag->writeBit = 0; + tag->len = pos; + swf_SetRect(tag, newrect); + swf_SetBlock(tag, data, len); + free(data); + tag->pos = tag->readBit = 0; } -static void endtext() +void cancelshape(swfoutput*obj) { - if(textid<0) - return; - putcharacters(tag); - swf_SetU8(tag,0); - tag = swf_InsertTag(tag,ST_PLACEOBJECT2); - swf_ObjectPlace(tag,textid,/*depth*/depth++,NULL,NULL,NULL); - textid = -1; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + /* delete old shape tag */ + TAG*todel = i->tag; + i->tag = i->tag->prev; + swf_DeleteTag(todel); + if(i->shape) {swf_ShapeFree(i->shape);i->shape=0;} + i->shapeid = -1; + i->bboxrectpos = -1; } -static void endpage(struct swfoutput*obj) +void fixAreas(swfoutput*obj) { - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); - while(clippos) - swfoutput_endclip(obj); - tag = swf_InsertTag(tag,ST_SHOWFRAME); + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(!i->shapeisempty && i->fill && + (i->bboxrect.xmin == i->bboxrect.xmax || + i->bboxrect.ymin == i->bboxrect.ymax) && + config_minlinewidth >= 0.001 + ) { + msg(" Shape has size 0: width=%.2f height=%.2f", + (i->bboxrect.xmax-i->bboxrect.xmin)/20.0, + (i->bboxrect.ymax-i->bboxrect.ymin)/20.0 + ); + + SRECT r = i->bboxrect; + + if(r.xmin == r.xmax && r.ymin == r.ymax) { + /* this thing comes down to a single dot- nothing to fix here */ + return; + } + + cancelshape(obj); + + RGBA save_col = obj->strokergb; + int save_width = i->linewidth; + + obj->strokergb = obj->fillrgb; + i->linewidth = (int)(config_minlinewidth*20); + if(i->linewidth==0) i->linewidth = 1; + + startshape(obj); + + moveto(obj, i->tag, r.xmin/20.0,r.ymin/20.0); + lineto(obj, i->tag, r.xmax/20.0,r.ymax/20.0); + + obj->strokergb = save_col; + i->linewidth = save_width; + } + } -void swfoutput_newpage(struct swfoutput*obj) +static void endshape_noput(swfoutput*obj) { - endpage(obj); - - for(depth--;depth>=startdepth;depth--) { - tag = swf_InsertTag(tag,ST_REMOVEOBJECT2); - swf_SetU16(tag,depth); + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(i->shapeid<0) + return; + //changeRect(obj, i->tag, i->bboxrectpos, &i->bboxrect); + i->shapeid = -1; + if(i->shape) { + swf_ShapeFree(i->shape); + i->shape=0; } + i->fill=0; +} + +static void endshape(swfoutput*obj) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(i->shapeid<0) + return; - depth = 1; - startdepth = depth; + fixAreas(obj); + + if(i->shapeisempty || + /*bbox empty?*/ + (i->bboxrect.xmin == i->bboxrect.xmax && + i->bboxrect.ymin == i->bboxrect.ymax)) + { + // delete the shape again, we didn't do anything + msg(" cancelling shape: bbox is (%f,%f,%f,%f)", + i->bboxrect.xmin /20.0, + i->bboxrect.ymin /20.0, + i->bboxrect.xmax /20.0, + i->bboxrect.ymax /20.0 + ); + cancelshape(obj); + return; + } + + swf_ShapeSetEnd(i->tag); + + changeRect(obj, i->tag, i->bboxrectpos, &i->bboxrect); + + msg(" Placing shape id %d", i->shapeid); + + i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2); + swf_ObjectPlace(i->tag,i->shapeid,/*depth*/i->depth++,&i->page_matrix,NULL,NULL); + + swf_ShapeFree(i->shape); + i->shape = 0; + i->shapeid = -1; + i->bboxrectpos = -1; + i->fill=0; + + /*int debug = 1; + if(debug) { + char text[80]; + sprintf(text, "id%d", i->shapeid); + swfcoord points[4]; + points[0].x = i->bboxrect.xmin; + points[0].y = i->bboxrect.ymin; + points[1].x = i->bboxrect.xmax; + points[1].y = i->bboxrect.ymin; + points[2].x = i->bboxrect.xmax; + points[2].y = i->bboxrect.ymax; + points[3].x = i->bboxrect.xmin; + points[3].y = i->bboxrect.ymax; + swfoutput_namedlink(obj,text,points); + }*/ } -/* "destroy" like in (oo-terminology) "destructor". Perform cleaning - up, complete the swf, and write it out. */ -void swfoutput_destroy(struct swfoutput* obj) +void swfoutput_finalize(struct swfoutput*obj) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + + if(i->tag && i->tag->id == ST_END) + return; //already done + + if(i->frameno == i->lastframeno) // fix: add missing pagefeed + swfoutput_pagefeed(obj); + endpage(obj); - fontlist_t *tmp,*iterator = fontlist; + fontlist_t *tmp,*iterator = i->fontlist; while(iterator) { - delete iterator->font; - iterator->font = 0; - tmp = iterator; + TAG*mtag = i->swf.firstTag; + if(iterator->swffont) { + mtag = swf_InsertTag(mtag, ST_DEFINEFONT2); + /*if(!storeallcharacters) + swf_FontReduce(iterator->swffont);*/ + swf_FontSetDefine2(mtag, iterator->swffont); + } + iterator = iterator->next; - delete tmp; } + i->tag = swf_InsertTag(i->tag,ST_END); + TAG* tag = i->tag->prev; + + /* remove the removeobject2 tags between the last ST_SHOWFRAME + and the ST_END- they confuse the flash player */ + while(tag->id == ST_REMOVEOBJECT2) { + TAG* prev = tag->prev; + swf_DeleteTag(tag); + tag = prev; + } +} - T1_CloseLib(); - if(!filename) - return; +SWF* swfoutput_get(struct swfoutput*obj) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + + swfoutput_finalize(obj); + + return swf_CopySWF(&i->swf); +} + +void swfoutput_getdimensions(struct swfoutput*obj, int*x1, int*y1, int*x2, int*y2) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(x1) *x1 = i->swf.movieSize.xmin/20; + if(y1) *y1 = i->swf.movieSize.ymin/20; + if(x2) *x2 = i->swf.movieSize.xmax/20; + if(y2) *y2 = i->swf.movieSize.ymax/20; +} + +int swfoutput_save(struct swfoutput* obj, char*filename) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + swfoutput_finalize(obj); + + int fi; if(filename) - fi = open(filename, O_CREAT|O_TRUNC|O_WRONLY, 0777); + fi = open(filename, O_BINARY|O_CREAT|O_TRUNC|O_WRONLY, 0777); else fi = 1; // stdout if(fi<=0) { - logf(" Could not create \"%s\". ", FIXNULL(filename)); - exit(1); + msg(" Could not create \"%s\". ", FIXNULL(filename)); + return 0; } - - tag = swf_InsertTag(tag,ST_END); - - if(enablezlib) { - if FAILED(swf_WriteSWC(fi,&swf)) - logf(" WriteSWC() failed.\n"); + + if(config_enablezlib || config_flashversion>=6) { + if FAILED(swf_WriteSWC(fi,&i->swf)) + msg(" WriteSWC() failed.\n"); } else { - if FAILED(swf_WriteSWF(fi,&swf)) - logf(" WriteSWF() failed.\n"); + if FAILED(swf_WriteSWF(fi,&i->swf)) + msg(" WriteSWF() failed.\n"); } if(filename) close(fi); - logf(" SWF written\n"); + msg(" SWF written\n"); + return 1; } -void swfoutput_setdrawmode(swfoutput* obj, int mode) +/* Perform cleaning up, complete the swf, and write it out. */ +void swfoutput_destroy(struct swfoutput* obj) { - drawmode = mode; - if(mode == DRAWMODE_FILL) - fill = 1; - else if(mode == DRAWMODE_EOFILL) - fill = 1; - else if(mode == DRAWMODE_STROKE) - fill = 0; - else if(mode == DRAWMODE_CLIP) - fill = 1; - else if(mode == DRAWMODE_EOCLIP) - fill = 1; + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(!i) { + /* not initialized yet- nothing to destroy */ + return; + } + + fontlist_t *tmp,*iterator = i->fontlist; + while(iterator) { + if(iterator->swffont) { + swf_FontFree(iterator->swffont);iterator->swffont=0; + } + tmp = iterator; + iterator = iterator->next; + delete tmp; + } + swf_FreeTags(&i->swf); + + free(i);i=0; + memset(obj, 0, sizeof(swfoutput)); } -void swfoutput_setfillcolor(swfoutput* obj, u8 r, u8 g, u8 b, u8 a) +static void swfoutput_setfillcolor(swfoutput* obj, U8 r, U8 g, U8 b, U8 a) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; if(obj->fillrgb.r == r && obj->fillrgb.g == g && obj->fillrgb.b == b && obj->fillrgb.a == a) return; - if(shapeid>=0) - endshape(); + if(i->shapeid>=0) + endshape(obj); obj->fillrgb.r = r; obj->fillrgb.g = g; @@ -1057,87 +1462,56 @@ void swfoutput_setfillcolor(swfoutput* obj, u8 r, u8 g, u8 b, u8 a) obj->fillrgb.a = a; } -void swfoutput_setstrokecolor(swfoutput* obj, u8 r, u8 g, u8 b, u8 a) +static void swfoutput_setstrokecolor(swfoutput* obj, U8 r, U8 g, U8 b, U8 a) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; if(obj->strokergb.r == r && obj->strokergb.g == g && obj->strokergb.b == b && obj->strokergb.a == a) return; - if(shapeid>=0) - endshape(); + if(i->shapeid>=0) + endshape(obj); obj->strokergb.r = r; obj->strokergb.g = g; obj->strokergb.b = b; obj->strokergb.a = a; } -void swfoutput_setlinewidth(struct swfoutput*obj, double linewidth) +static void swfoutput_setlinewidth(struct swfoutput*obj, double _linewidth) { - if(obj->linewidth == (u16)(linewidth*20)) + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + if(i->linewidth == (U16)(_linewidth*20)) return; - if(shapeid>=0) - endshape(); - obj->linewidth = (u16)(linewidth*20); -} - - -void swfoutput_startclip(swfoutput*obj, T1_OUTLINE*outline, struct swfmatrix*m) -{ - if(textid>=0) - endtext(); - if(shapeid>=0) - endshape(); - - if(clippos >= 127) - { - logf(" Too many clip levels."); - clippos --; - } - - startshape(obj); - int olddrawmode = drawmode; - swfoutput_setdrawmode(obj, DRAWMODE_CLIP); - swfoutput_drawpath(obj, outline, m); - swf_ShapeSetEnd(tag); - swfoutput_setdrawmode(obj, olddrawmode); - - tag = swf_InsertTag(tag,ST_PLACEOBJECT2); - cliptags[clippos] = tag; - clipshapes[clippos] = shapeid; - clipdepths[clippos] = depth++; - clippos++; - shapeid = -1; + if(i->shapeid>=0) + endshape(obj); + i->linewidth = (U16)(_linewidth*20); } -void swfoutput_endclip(swfoutput*obj) -{ - if(textid>=0) - endtext(); - if(shapeid>=0) - endshape(); - - if(!clippos) { - logf(" Invalid end of clipping region"); - return; - } - clippos--; - swf_ObjectPlaceClip(cliptags[clippos],clipshapes[clippos],clipdepths[clippos],NULL,NULL,NULL,depth++); -} static void drawlink(struct swfoutput*obj, ActionTAG*,ActionTAG*, swfcoord*points, char mouseover); void swfoutput_linktourl(struct swfoutput*obj, char*url, swfcoord*points) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; ActionTAG* actions; + if(!strncmp("http://pdf2swf:", url, 15)) { + char*tmp = strdup(url); + int l = strlen(tmp); + if(tmp[l-1] == '/') + tmp[l-1] = 0; + swfoutput_namedlink(obj, tmp+15, points); + free(tmp); + return; + } - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); + if(i->shapeid>=0) + endshape(obj); + if(i->textid>=0) + endtext(obj); - if(opennewwindow) + if(config_opennewwindow) actions = action_GetUrl(0, url, "_parent"); else actions = action_GetUrl(0, url, "_this"); @@ -1147,45 +1521,75 @@ void swfoutput_linktourl(struct swfoutput*obj, char*url, swfcoord*points) } void swfoutput_linktopage(struct swfoutput*obj, int page, swfcoord*points) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; ActionTAG* actions; - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); + if(i->shapeid>=0) + endshape(obj); + if(i->textid>=0) + endtext(obj); actions = action_GotoFrame(0, page); actions = action_End(actions); drawlink(obj, actions, 0, points,0); } + +/* Named Links (a.k.a. Acrobatmenu) are used to implement various gadgets + of the viewer objects, like subtitles, index elements etc. +*/ void swfoutput_namedlink(struct swfoutput*obj, char*name, swfcoord*points) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; ActionTAG *actions1,*actions2; + char*tmp = strdup(name); + char mouseover = 1; - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); - - actions1 = action_PushString(0, "/:subtitle"); - actions1 = action_PushString(actions1, name); - actions1 = action_SetVariable(actions1); - actions1 = action_End(actions1); + if(i->shapeid>=0) + endshape(obj); + if(i->textid>=0) + endtext(obj); - actions2 = action_PushString(0, "/:subtitle"); - actions2 = action_PushString(actions2, ""); - actions2 = action_SetVariable(actions2); - actions2 = action_End(actions2); + if(!strncmp(tmp, "call:", 5)) + { + char*x = strchr(&tmp[5], ':'); + if(!x) { + actions1 = action_PushInt(0, 0); //number of parameters (0) + actions1 = action_PushString(actions1, &tmp[5]); //function name + actions1 = action_CallFunction(actions1); + } else { + *x = 0; + actions1 = action_PushString(0, x+1); //parameter + actions1 = action_PushInt(actions1, 1); //number of parameters (1) + actions1 = action_PushString(actions1, &tmp[5]); //function name + actions1 = action_CallFunction(actions1); + } + actions2 = action_End(0); + mouseover = 0; + } + else + { + actions1 = action_PushString(0, "/:subtitle"); + actions1 = action_PushString(actions1, name); + actions1 = action_SetVariable(actions1); + actions1 = action_End(actions1); + + actions2 = action_PushString(0, "/:subtitle"); + actions2 = action_PushString(actions2, ""); + actions2 = action_SetVariable(actions2); + actions2 = action_End(actions2); + } - drawlink(obj, actions1, actions2, points,1); + drawlink(obj, actions1, actions2, points,mouseover); swf_ActionFree(actions1); swf_ActionFree(actions2); + free(tmp); } static void drawlink(struct swfoutput*obj, ActionTAG*actions1, ActionTAG*actions2, swfcoord*points, char mouseover) { + swfoutput_internal*i = (swfoutput_internal*)obj->internal; RGBA rgb; SRECT r; int lsid=0; @@ -1198,7 +1602,7 @@ static void drawlink(struct swfoutput*obj, ActionTAG*actions1, ActionTAG*actions double posx = 0; double posy = 0; int t; - int buttonid = ++currentswfid; + int buttonid = ++i->currentswfid; for(t=1;t<4;t++) { if(points[t].x>xmax) xmax=points[t].x; @@ -1206,7 +1610,7 @@ static void drawlink(struct swfoutput*obj, ActionTAG*actions1, ActionTAG*actions if(points[t].xcurrentswfid; + i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3); + swf_ShapeNew(&i->shape); rgb.r = rgb.b = rgb.a = rgb.g = 0; - fsid = swf_ShapeAddSolidFillStyle(shape,&rgb); - swf_SetU16(tag, myshapeid); + fsid = swf_ShapeAddSolidFillStyle(i->shape,&rgb); + swf_SetU16(i->tag, myshapeid); r.xmin = (int)(xmin*20); r.ymin = (int)(ymin*20); r.xmax = (int)(xmax*20); r.ymax = (int)(ymax*20); - swf_SetRect(tag,&r); - swf_SetShapeStyles(tag,shape); - swf_ShapeCountBits(shape,NULL,NULL); - swf_SetShapeBits(tag,shape); - swf_ShapeSetAll(tag,shape,/*x*/0,/*y*/0,0,fsid,0); - swflastx = swflasty = 0; - moveto(tag, p1); - lineto(tag, p2); - lineto(tag, p3); - lineto(tag, p4); - lineto(tag, p1); - swf_ShapeSetEnd(tag); + swf_SetRect(i->tag,&r); + swf_SetShapeStyles(i->tag,i->shape); + swf_ShapeCountBits(i->shape,NULL,NULL); + swf_SetShapeBits(i->tag,i->shape); + swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0); + i->swflastx = i->swflasty = 0; + moveto(obj, i->tag, p1); + lineto(obj, i->tag, p2); + lineto(obj, i->tag, p3); + lineto(obj, i->tag, p4); + lineto(obj, i->tag, p1); + swf_ShapeSetEnd(i->tag); /* shape2 */ - myshapeid2 = ++currentswfid; - tag = swf_InsertTag(tag,ST_DEFINESHAPE3); - swf_ShapeNew(&shape); + myshapeid2 = ++i->currentswfid; + i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3); + swf_ShapeNew(&i->shape); rgb.r = rgb.b = rgb.a = rgb.g = 255; rgb.a = 40; - fsid = swf_ShapeAddSolidFillStyle(shape,&rgb); - swf_SetU16(tag, myshapeid2); + fsid = swf_ShapeAddSolidFillStyle(i->shape,&rgb); + swf_SetU16(i->tag, myshapeid2); r.xmin = (int)(xmin*20); r.ymin = (int)(ymin*20); r.xmax = (int)(xmax*20); r.ymax = (int)(ymax*20); - swf_SetRect(tag,&r); - swf_SetShapeStyles(tag,shape); - swf_ShapeCountBits(shape,NULL,NULL); - swf_SetShapeBits(tag,shape); - swf_ShapeSetAll(tag,shape,/*x*/0,/*y*/0,0,fsid,0); - swflastx = swflasty = 0; - moveto(tag, p1); - lineto(tag, p2); - lineto(tag, p3); - lineto(tag, p4); - lineto(tag, p1); - swf_ShapeSetEnd(tag); + swf_SetRect(i->tag,&r); + swf_SetShapeStyles(i->tag,i->shape); + swf_ShapeCountBits(i->shape,NULL,NULL); + swf_SetShapeBits(i->tag,i->shape); + swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0); + i->swflastx = i->swflasty = 0; + moveto(obj, i->tag, p1); + lineto(obj, i->tag, p2); + lineto(obj, i->tag, p3); + lineto(obj, i->tag, p4); + lineto(obj, i->tag, p1); + swf_ShapeSetEnd(i->tag); if(!mouseover) { - tag = swf_InsertTag(tag,ST_DEFINEBUTTON); - swf_SetU16(tag,buttonid); //id - swf_ButtonSetFlags(tag, 0); //menu=no - swf_ButtonSetRecord(tag,0x01,myshapeid,depth,0,0); - swf_ButtonSetRecord(tag,0x02,myshapeid2,depth,0,0); - swf_ButtonSetRecord(tag,0x04,myshapeid2,depth,0,0); - swf_ButtonSetRecord(tag,0x08,myshapeid,depth,0,0); - swf_SetU8(tag,0); - swf_ActionSet(tag,actions1); - swf_SetU8(tag,0); + i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON); + swf_SetU16(i->tag,buttonid); //id + swf_ButtonSetFlags(i->tag, 0); //menu=no + swf_ButtonSetRecord(i->tag,0x01,myshapeid,i->depth,0,0); + swf_ButtonSetRecord(i->tag,0x02,myshapeid2,i->depth,0,0); + swf_ButtonSetRecord(i->tag,0x04,myshapeid2,i->depth,0,0); + swf_ButtonSetRecord(i->tag,0x08,myshapeid,i->depth,0,0); + swf_SetU8(i->tag,0); + swf_ActionSet(i->tag,actions1); + swf_SetU8(i->tag,0); } else { - tag = swf_InsertTag(tag,ST_DEFINEBUTTON2); - swf_SetU16(tag,buttonid); //id - swf_ButtonSetFlags(tag, 0); //menu=no - swf_ButtonSetRecord(tag,0x01,myshapeid,depth,0,0); - swf_ButtonSetRecord(tag,0x02,myshapeid2,depth,0,0); - swf_ButtonSetRecord(tag,0x04,myshapeid2,depth,0,0); - swf_ButtonSetRecord(tag,0x08,myshapeid,depth,0,0); - swf_SetU8(tag,0); // end of button records - swf_ButtonSetCondition(tag, BC_IDLE_OVERUP); - swf_ActionSet(tag,actions1); + i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON2); + swf_SetU16(i->tag,buttonid); //id + swf_ButtonSetFlags(i->tag, 0); //menu=no + swf_ButtonSetRecord(i->tag,0x01,myshapeid,i->depth,0,0); + swf_ButtonSetRecord(i->tag,0x02,myshapeid2,i->depth,0,0); + swf_ButtonSetRecord(i->tag,0x04,myshapeid2,i->depth,0,0); + swf_ButtonSetRecord(i->tag,0x08,myshapeid,i->depth,0,0); + swf_SetU8(i->tag,0); // end of button records + swf_ButtonSetCondition(i->tag, BC_IDLE_OVERUP); + swf_ActionSet(i->tag,actions1); if(actions2) { - swf_ButtonSetCondition(tag, BC_OVERUP_IDLE); - swf_ActionSet(tag,actions2); - swf_SetU8(tag,0); - swf_ButtonPostProcess(tag, 2); + swf_ButtonSetCondition(i->tag, BC_OVERUP_IDLE); + swf_ActionSet(i->tag,actions2); + swf_SetU8(i->tag,0); + swf_ButtonPostProcess(i->tag, 2); } else { - swf_SetU8(tag,0); - swf_ButtonPostProcess(tag, 1); + swf_SetU8(i->tag,0); + swf_ButtonPostProcess(i->tag, 1); } } - tag = swf_InsertTag(tag,ST_PLACEOBJECT2); + i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2); if(posx!=0 || posy!=0) { + SPOINT p; + p.x = (int)(posx*20); + p.y = (int)(posy*20); + p = swf_TurnPoint(p, &i->page_matrix); MATRIX m; - swf_GetMatrix(0,&m); - m.tx = (int)(posx*20); - m.ty = (int)(posy*20); - swf_ObjectPlace(tag, buttonid, depth++,&m,0,0); + m = i->page_matrix; + m.tx = p.x; + m.ty = p.y; + swf_ObjectPlace(i->tag, buttonid, i->depth++,&m,0,0); } else { - swf_ObjectPlace(tag, buttonid, depth++,0,0,0); + swf_ObjectPlace(i->tag, buttonid, i->depth++,&i->page_matrix,0,0); + } +} + + +/////////// +/* +for(t=0;tinternal; + gfxcoord_t lastx=0,lasty=0,px=0,py=0; + char lastwasmoveto; + while(1) { + if(!line) + break; + /* check whether the next segment is zero */ + if(line->type == gfx_moveTo) { + msg(" ======== moveTo %.2f %.2f", line->x, line->y); + moveto(obj, i->tag, line->x, line->y); + px = lastx = line->x; + py = lasty = line->y; + lastwasmoveto = 1; + } if(line->type == gfx_lineTo) { + msg(" ======== lineTo %.2f %.2f", line->x, line->y); + lineto(obj, i->tag, line->x, line->y); + px = line->x; + py = line->y; + lastwasmoveto = 0; + } else if(line->type == gfx_splineTo) { + msg(" ======== splineTo %.2f %.2f", line->x, line->y); + plotxy s,p; + s.x = line->sx;p.x = line->x; + s.y = line->sy;p.y = line->y; + splineto(obj, i->tag, s, p); + px = line->x; + py = line->y; + lastwasmoveto = 0; + } + line = line->next; } } -static void drawimage(struct swfoutput*obj, int bitid, int sizex,int sizey, +void swfoutput_drawgfxline(struct swfoutput*obj, gfxline_t*line, gfxcoord_t width, gfxcolor_t*col, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + gfxdevice_t*dev = &i->device; + dev->stroke(dev, line, width, col, cap_style, joint_style, miterLimit); +} +void swfoutput_fillgfxline(struct swfoutput*obj, gfxline_t*line, gfxcolor_t*col) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + gfxdevice_t*dev = &i->device; + dev->fill(dev, line, col); +} +void swfoutput_startclip(struct swfoutput*obj, gfxline_t*line) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + gfxdevice_t*dev = &i->device; + dev->startclip(dev, line); +} +void swfoutput_endclip(struct swfoutput*obj) +{ + swfoutput_internal*i = (swfoutput_internal*)obj->internal; + gfxdevice_t*dev = &i->device; + dev->endclip(dev); +} + +#define IMAGE_TYPE_JPEG 0 +#define IMAGE_TYPE_LOSSLESS 1 + +static void swfoutput_drawimage(struct swfoutput*obj, RGBA* data, int sizex,int sizey, double x1,double y1, double x2,double y2, double x3,double y3, - double x4,double y4) + double x4,double y4, int type) { - RGBA rgb; - SRECT r; - int lsid=0; - int fsid; - struct plotxy p1,p2,p3,p4; - int myshapeid; - double xmax=x1,ymax=y1,xmin=x1,ymin=y1; - if(x2>xmax) xmax=x2; - if(y2>ymax) ymax=y2; - if(x2xmax) xmax=x3; - if(y3>ymax) ymax=y3; - if(x3xmax) xmax=x4; - if(y4>ymax) ymax=y4; - if(x4internal; + + RGBA*newpic=0; + + double l1 = sqrt((x4-x1)*(x4-x1) + (y4-y1)*(y4-y1)); + double l2 = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)); + + gfxline_t p1,p2,p3,p4,p5; + p1.type=gfx_moveTo;p1.x=x1; p1.y=y1;p1.next=&p2; + p2.type=gfx_lineTo;p2.x=x2; p2.y=y2;p2.next=&p3; + p3.type=gfx_lineTo;p3.x=x3; p3.y=y3;p3.next=&p4; + p4.type=gfx_lineTo;p4.x=x4; p4.y=y4;p4.next=&p5; + p5.type=gfx_lineTo;p5.x=x1; p5.y=y1;p5.next=0; {p1.x = (int)(p1.x*20)/20.0; p1.y = (int)(p1.y*20)/20.0; @@ -1355,185 +1858,564 @@ static void drawimage(struct swfoutput*obj, int bitid, int sizex,int sizey, p3.x = (int)(p3.x*20)/20.0; p3.y = (int)(p3.y*20)/20.0; p4.x = (int)(p4.x*20)/20.0; - p4.y = (int)(p4.y*20)/20.0;} + p4.y = (int)(p4.y*20)/20.0; + p5.x = (int)(p5.x*20)/20.0; + p5.y = (int)(p5.y*20)/20.0; + } - MATRIX m; - m.sx = (int)(65536*20*(p4.x-p1.x)/sizex); - m.r1 = -(int)(65536*20*(p4.y-p1.y)/sizex); - m.r0 = (int)(65536*20*(p1.x-p2.x)/sizey); - m.sy = -(int)(65536*20*(p1.y-p2.y)/sizey); - - m.tx = (int)(p1.x*20); - m.ty = (int)(p1.y*20); + float m00,m10,tx; + float m01,m11,ty; + + gfxmatrix_t m; + m.m00 = (p4.x-p1.x)/sizex; m.m10 = (p2.x-p1.x)/sizey; + m.m01 = (p4.y-p1.y)/sizex; m.m11 = (p2.y-p1.y)/sizey; + m.tx = p1.x - 0.5; + m.ty = p1.y - 0.5; + + gfximage_t img; + img.data = (gfxcolor_t*)data; + img.width = sizex; + img.height = sizey; - /* shape */ - myshapeid = ++currentswfid; - tag = swf_InsertTag(tag,ST_DEFINESHAPE); - swf_ShapeNew(&shape); - //lsid = ShapeAddLineStyle(shape,obj->linewidth,&obj->strokergb); - //fsid = ShapeAddSolidFillStyle(shape,&obj->fillrgb); - fsid = swf_ShapeAddBitmapFillStyle(shape,&m,bitid,1); - swf_SetU16(tag, myshapeid); - r.xmin = (int)(xmin*20); - r.ymin = (int)(ymin*20); - r.xmax = (int)(xmax*20); - r.ymax = (int)(ymax*20); - swf_SetRect(tag,&r); - swf_SetShapeStyles(tag,shape); - swf_ShapeCountBits(shape,NULL,NULL); - swf_SetShapeBits(tag,shape); - swf_ShapeSetAll(tag,shape,/*x*/0,/*y*/0,lsid,fsid,0); - swflastx = swflasty = 0; - moveto(tag, p1); - lineto(tag, p2); - lineto(tag, p3); - lineto(tag, p4); - lineto(tag, p1); - /* - ShapeMoveTo (tag, shape, (int)(x1*20),(int)(y1*20)); - ShapeSetLine (tag, shape, (int)(x1*20); - ShapeSetLine (tag, shape, x*20,0); - ShapeSetLine (tag, shape, 0,-y*20); - ShapeSetLine (tag, shape, -x*20,0);*/ - swf_ShapeSetEnd(tag); - - /* instance */ - tag = swf_InsertTag(tag,ST_PLACEOBJECT2); - swf_ObjectPlace(tag,myshapeid,/*depth*/depth++,NULL,NULL,NULL); -} - -int swfoutput_drawimagejpeg_old(struct swfoutput*obj, char*filename, int sizex,int sizey, - double x1,double y1, - double x2,double y2, - double x3,double y3, - double x4,double y4) -{ - TAG*oldtag; - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); - - int bitid = ++currentswfid; - oldtag = tag; - tag = swf_InsertTag(tag,ST_DEFINEBITSJPEG2); - swf_SetU16(tag, bitid); - if(swf_SetJPEGBits(tag, filename, jpegquality)<0) { - swf_DeleteTag(tag); - tag = oldtag; - return -1; + if(type == IMAGE_TYPE_JPEG) + /* TODO: pass image_dpi to device instead */ + i->device.setparameter(&i->device, "next_bitmap_is_jpeg", "1"); + + i->device.fillbitmap(&i->device, &p1, &img, &m, 0); +} + +void swfoutput_drawimagejpeg(struct swfoutput*obj, RGBA*mem, int sizex,int sizey, + double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4) +{ + swfoutput_drawimage(obj,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_JPEG); +} + +void swfoutput_drawimagelossless(struct swfoutput*obj, RGBA*mem, int sizex,int sizey, + double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4) +{ + swfoutput_drawimage(obj,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_LOSSLESS); +} + +void swfoutput_setparameter(char*name, char*value) +{ + if(!strcmp(name, "jpegsubpixels")) { + config_jpegsubpixels = atof(value); + } else if(!strcmp(name, "ppmsubpixels")) { + config_ppmsubpixels = atof(value); + } else if(!strcmp(name, "drawonlyshapes")) { + config_drawonlyshapes = atoi(value); + } else if(!strcmp(name, "ignoredraworder")) { + config_ignoredraworder = atoi(value); + } else if(!strcmp(name, "filloverlap")) { + config_filloverlap = atoi(value); + } else if(!strcmp(name, "linksopennewwindow")) { + config_opennewwindow = atoi(value); + } else if(!strcmp(name, "opennewwindow")) { + config_opennewwindow = atoi(value); + } else if(!strcmp(name, "storeallcharacters")) { + config_storeallcharacters = atoi(value); + } else if(!strcmp(name, "enablezlib")) { + config_enablezlib = atoi(value); + } else if(!strcmp(name, "insertstop")) { + config_insertstoptag = atoi(value); + } else if(!strcmp(name, "protected")) { + config_protect = atoi(value); + } else if(!strcmp(name, "flashversion")) { + config_flashversion = atoi(value); + } else if(!strcmp(name, "minlinewidth")) { + config_minlinewidth = atof(value); + } else if(!strcmp(name, "caplinewidth")) { + config_caplinewidth = atof(value); + } else if(!strcmp(name, "jpegquality")) { + int val = atoi(value); + if(val<0) val=0; + if(val>100) val=100; + config_jpegquality = val; + } else if(!strcmp(name, "splinequality")) { + int v = atoi(value); + v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel + if(v<1) v = 1; + config_splinemaxerror = v; + } else if(!strcmp(name, "fontquality")) { + int v = atoi(value); + v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel + if(v<1) v = 1; + config_fontsplinemaxerror = v; + } else { + fprintf(stderr, "unknown parameter: %s (=%s)\n", name, value); } +} - drawimage(obj, bitid, sizex, sizey, x1,y1,x2,y2,x3,y3,x4,y4); - return bitid; +// -------------------------------------------------------------------- + +static CXFORM gfxcxform_to_cxform(gfxcxform_t* c) +{ + CXFORM cx; + swf_GetCXForm(0, &cx, 1); + if(!c) + return cx; + if(c->rg!=0 || c->rb!=0 || c->ra!=0 || + c->gr!=0 || c->gb!=0 || c->ga!=0 || + c->br!=0 || c->bg!=0 || c->ba!=0 || + c->ar!=0 || c->ag!=0 || c->ab!=0) + msg(" CXForm not SWF-compatible"); + + cx.a0 = (S16)(c->aa*256); + cx.r0 = (S16)(c->rr*256); + cx.g0 = (S16)(c->gg*256); + cx.b0 = (S16)(c->bb*256); + cx.a1 = c->t.a; + cx.r1 = c->t.r; + cx.g1 = c->t.g; + cx.b1 = c->t.b; + return cx; } -int swfoutput_drawimagejpeg(struct swfoutput*obj, RGBA*mem, int sizex,int sizey, - double x1,double y1, - double x2,double y2, - double x3,double y3, - double x4,double y4) -{ - TAG*oldtag; - JPEGBITS*jpeg; - - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); - - int bitid = ++currentswfid; - oldtag = tag; - tag = swf_InsertTag(tag,ST_DEFINEBITSJPEG2); - swf_SetU16(tag, bitid); - swf_SetJPEGBits2(tag,sizex,sizey,mem,jpegquality); - drawimage(obj, bitid, sizex, sizey, x1,y1,x2,y2,x3,y3,x4,y4); - return bitid; +ArtSVP* gfxstrokeToSVP(gfxline_t*line, gfxcoord_t width, gfx_capType cap_style, gfx_joinType joint_style, double miterLimit) +{ + ArtVpath *vec = NULL; + ArtSVP *svp = NULL; + int pos=0,len=0; + gfxline_t*l2; + double x=0,y=0; + + l2 = line; + while(l2) { + if(l2->type == gfx_moveTo) { + pos ++; + } if(l2->type == gfx_lineTo) { + pos ++; + } if(l2->type == gfx_splineTo) { + int parts = (int)(sqrt(fabs(l2->x-2*l2->sx+x) + fabs(l2->y-2*l2->sy+y))/3); + if(!parts) parts = 1; + pos += parts + 1; + } + x = l2->x; + y = l2->y; + l2 = l2->next; + } + pos++; + len = pos; + + vec = art_new (ArtVpath, len); + + pos = 0; + l2 = line; + while(l2) { + if(l2->type == gfx_moveTo) { + vec[pos].code = ART_MOVETO; + vec[pos].x = l2->x; + vec[pos].y = l2->y; + pos++; + assert(pos<=len); + } else if(l2->type == gfx_lineTo) { + vec[pos].code = ART_LINETO; + vec[pos].x = l2->x; + vec[pos].y = l2->y; + pos++; + assert(pos<=len); + } else if(l2->type == gfx_splineTo) { + int i; + int parts = (int)(sqrt(fabs(l2->x-2*l2->sx+x) + fabs(l2->y-2*l2->sy+y))/3); + if(!parts) parts = 1; + for(i=0;i<=parts;i++) { + double t = (double)i/(double)parts; + vec[pos].code = ART_LINETO; + vec[pos].x = l2->x*t*t + 2*l2->sx*t*(1-t) + x*(1-t)*(1-t); + vec[pos].y = l2->y*t*t + 2*l2->sy*t*(1-t) + y*(1-t)*(1-t); + pos++; + assert(pos<=len); + } + } + x = l2->x; + y = l2->y; + l2 = l2->next; + } + vec[pos].code = ART_END; + + svp = art_svp_vpath_stroke (vec, + (joint_style==gfx_joinMiter)?ART_PATH_STROKE_JOIN_MITER: + ((joint_style==gfx_joinRound)?ART_PATH_STROKE_JOIN_ROUND: + ((joint_style==gfx_joinBevel)?ART_PATH_STROKE_JOIN_BEVEL:ART_PATH_STROKE_JOIN_BEVEL)), + (cap_style==gfx_capButt)?ART_PATH_STROKE_CAP_BUTT: + ((cap_style==gfx_capRound)?ART_PATH_STROKE_CAP_ROUND: + ((cap_style==gfx_capSquare)?ART_PATH_STROKE_CAP_SQUARE:ART_PATH_STROKE_CAP_SQUARE)), + width, //line_width + miterLimit, //miter_limit + 0.05 //flatness + ); + free(vec); + return svp; } -int swfoutput_drawimagelossless(struct swfoutput*obj, RGBA*mem, int sizex,int sizey, - double x1,double y1, - double x2,double y2, - double x3,double y3, - double x4,double y4) -{ - TAG*oldtag; - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); - - int bitid = ++currentswfid; - oldtag = tag; - tag = swf_InsertTag(tag,ST_DEFINEBITSLOSSLESS); - swf_SetU16(tag, bitid); - if(swf_SetLosslessBits(tag,sizex,sizey,mem, BMF_32BIT)<0) { - swf_DeleteTag(tag); - tag = oldtag; +gfxline_t* SVPtogfxline(ArtSVP*svp) +{ + int size = 0; + int t; + int pos = 0; + for(t=0;tn_segs;t++) { + size += svp->segs[t].n_points + 1; + } + gfxline_t* lines = (gfxline_t*)rfx_alloc(sizeof(gfxline_t)*size); + + for(t=0;tn_segs;t++) { + ArtSVPSeg* seg = &svp->segs[t]; + int p; + for(p=0;pn_points;p++) { + lines[pos].type = p==0?gfx_moveTo:gfx_lineTo; + ArtPoint* point = &seg->points[p]; + lines[pos].x = point->x; + lines[pos].y = point->y; + lines[pos].next = &lines[pos+1]; + pos++; + } + } + if(pos) { + lines[pos-1].next = 0; + return lines; + } else { + return 0; + } +} + + + +static int add_image(swfoutput_internal*i, gfximage_t*img, int targetwidth, int targetheight, int* newwidth, int* newheight) +{ + RGBA*newpic = 0; + RGBA*mem = (RGBA*)img->data; + int bitid = ++i->currentswfid; + + int sizex = img->width; + int sizey = img->height; + int is_jpeg = i->jpeg; + i->jpeg = 0; + + int newsizex=sizex, newsizey=sizey; + + /// { + if(is_jpeg && config_jpegsubpixels) { + newsizex = (int)(targetwidth*config_jpegsubpixels+0.5); + newsizey = (int)(targetheight*config_jpegsubpixels+0.5); + } else if(!is_jpeg && config_ppmsubpixels) { + newsizex = (int)(targetwidth*config_ppmsubpixels+0.5); + newsizey = (int)(targetheight*config_ppmsubpixels+0.5); + } + /// } + + if(sizex<=0 || sizey<=0 || newsizex<=0 || newsizey<=0) return -1; + + /* TODO: cache images */ + *newwidth = sizex; + *newheight = sizey; + + if(newsizex Drawing %dx%d %s%simage at size %dx%d (%dx%d), %s%d colors", + sizex, sizey, + has_alpha?(has_alpha==2?"semi-transparent ":"transparent "):"", + is_jpeg?"jpeg-":"", + newsizex, newsizey, + targetwidth, targetheight, + /*newsizex, newsizey,*/ + num_colors>256?">":"", num_colors>256?256:num_colors); + + if(has_alpha) { + if(num_colors<=256 || sizex<8 || sizey<8) { + i->tag = swf_InsertTag(i->tag,ST_DEFINEBITSLOSSLESS2); + swf_SetU16(i->tag, bitid); + swf_SetLosslessImage(i->tag,mem,sizex,sizey); + } else { + /*TODO: check what is smaller */ + i->tag = swf_InsertTag(i->tag,ST_DEFINEBITSJPEG3); + swf_SetU16(i->tag, bitid); + swf_SetJPEGBits3(i->tag,sizex,sizey,mem,config_jpegquality); + //swf_SetLosslessImage(i->tag,mem,sizex,sizey); + } + } else { + if(num_colors<=256 || sizex<8 || sizey<8) { + i->tag = swf_InsertTag(i->tag,ST_DEFINEBITSLOSSLESS); + swf_SetU16(i->tag, bitid); + swf_SetLosslessImage(i->tag,mem,sizex,sizey); + } else { + /*TODO: check what is smaller */ + i->tag = swf_InsertTag(i->tag,ST_DEFINEBITSJPEG2); + swf_SetU16(i->tag, bitid); + swf_SetJPEGBits2(i->tag,sizex,sizey,mem,config_jpegquality); + //swf_SetLosslessImage(i->tag,mem,sizex,sizey); + } } - drawimage(obj, bitid, sizex, sizey, x1,y1,x2,y2,x3,y3,x4,y4); + if(newpic) + free(newpic); + return bitid; } -int swfoutput_drawimagelosslessN(struct swfoutput*obj, U8*mem, RGBA*pal, int sizex,int sizey, - double x1,double y1, - double x2,double y2, - double x3,double y3, - double x4,double y4, int n) -{ - TAG*oldtag; - U8*mem2 = 0; - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); - - if(sizex&3) - { - /* SWF expects scanlines to be 4 byte aligned */ - int x,y; - U8*ptr; - mem2 = (U8*)malloc(BYTES_PER_SCANLINE(sizex)*sizey); - ptr = mem2; - for(y=0;yinternal; + swfoutput*obj = i->obj; + + endshape(obj); + endtext(obj); + + int targetx = (int)(sqrt(matrix->m00*matrix->m00 + matrix->m01*matrix->m01)*img->width); + int targety = (int)(sqrt(matrix->m10*matrix->m10 + matrix->m11*matrix->m11)*img->height); + + int newwidth=0,newheight=0; + int bitid = add_image(i, img, targetx, targety, &newwidth, &newheight); + if(bitid<0) + return; + double fx = (double)img->width / (double)newwidth; + double fy = (double)img->height / (double)newheight; + + MATRIX m; + float m00,m10,tx; + float m01,m11,ty; + m.sx = (int)(65536*20*matrix->m00*fx); m.r1 = (int)(65536*20*matrix->m10*fy); + m.r0 = (int)(65536*20*matrix->m01*fx); m.sy = (int)(65536*20*matrix->m11*fy); + m.tx = (int)(matrix->tx*20); + m.ty = (int)(matrix->ty*20); + + /* shape */ + int myshapeid = ++i->currentswfid; + i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE); + SHAPE*shape; + swf_ShapeNew(&shape); + int fsid = swf_ShapeAddBitmapFillStyle(shape,&m,bitid,1); + swf_SetU16(i->tag, myshapeid); + SRECT r = gfxline_getSWFbbox(line); + swf_SetRect(i->tag,&r); + swf_SetShapeStyles(i->tag,shape); + swf_ShapeCountBits(shape,NULL,NULL); + swf_SetShapeBits(i->tag,shape); + swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0); + i->swflastx = i->swflasty = UNDEFINED_COORD; + drawgfxline(obj, line); + swf_ShapeSetEnd(i->tag); + swf_ShapeFree(shape); + + i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2); + CXFORM cxform2 = gfxcxform_to_cxform(cxform); + swf_ObjectPlace(i->tag,myshapeid,/*depth*/i->depth++,&i->page_matrix,&cxform2,NULL); +} + +void swf_startclip(gfxdevice_t*dev, gfxline_t*line) +{ + swfoutput_internal*i = (swfoutput_internal*)dev->internal; + swfoutput*obj = i->obj; + + endtext(obj); + endshape(obj); + + if(i->clippos >= 127) + { + msg(" Too many clip levels."); + i->clippos --; + } + + int myshapeid = ++i->currentswfid; + i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE); + RGBA col; + memset(&col, 0, sizeof(RGBA)); + SHAPE*shape; + swf_ShapeNew(&shape); + int fsid = swf_ShapeAddSolidFillStyle(shape,&col); + swf_SetU16(i->tag,myshapeid); + SRECT r = gfxline_getSWFbbox(line); + swf_SetRect(i->tag,&r); + swf_SetShapeStyles(i->tag,shape); + swf_ShapeCountBits(shape,NULL,NULL); + swf_SetShapeBits(i->tag,shape); + swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0); + i->swflastx = i->swflasty = UNDEFINED_COORD; + drawgfxline(obj, line); + swf_ShapeSetEnd(i->tag); + swf_ShapeFree(shape); + + /* TODO: remember the bbox, and check all shapes against it */ + + i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2); + i->cliptags[i->clippos] = i->tag; + i->clipshapes[i->clippos] = myshapeid; + i->clipdepths[i->clippos] = i->depth++; + i->clippos++; +} + +void swf_endclip(gfxdevice_t*dev) +{ + swfoutput_internal*i = (swfoutput_internal*)dev->internal; + swfoutput*obj = i->obj; + if(i->textid>=0) + endtext(obj); + if(i->shapeid>=0) + endshape(obj); + + if(!i->clippos) { + msg(" Invalid end of clipping region"); + return; } + i->clippos--; + swf_ObjectPlaceClip(i->cliptags[i->clippos],i->clipshapes[i->clippos],i->clipdepths[i->clippos],&i->page_matrix,NULL,NULL,i->depth++); +} +int swf_setparameter(gfxdevice_t*dev, const char*key, const char*value) +{ + if(!strcmp(key, "next_bitmap_is_jpeg")) { + ((swfoutput_internal*)dev->internal)->jpeg = 1; + return 1; + } + return 0; +} - int bitid = ++currentswfid; - oldtag = tag; - tag = swf_InsertTag(tag,ST_DEFINEBITSLOSSLESS2); - swf_SetU16(tag, bitid); - if(swf_SetLosslessBitsIndexed(tag,sizex,sizey,mem, pal, n)<0) { - swf_DeleteTag(tag); - tag = oldtag; - return -1; +int gfxline_type(gfxline_t*line) +{ + int tmplines=0; + int tmpsplines=0; + int lines=0; + int splines=0; + int haszerosegments=0; + while(line) { + if(line->type == gfx_moveTo) { + tmplines=0; + tmpsplines=0; + } else if(line->type == gfx_lineTo) { + tmplines++; + if(tmplines>lines) + lines=tmplines; + } else if(line->type == gfx_splineTo) { + tmpsplines++; + if(tmpsplines>lines) + splines=tmpsplines; + } + line = line->next; } - if(mem2) - free(mem2); - - drawimage(obj, bitid, sizex, sizey, x1,y1,x2,y2,x3,y3,x4,y4); - return bitid; + if(lines==0 && splines==0) return 0; + else if(lines==1 && splines==0) return 1; + else if(lines==0 && splines==1) return 2; + else if(splines==0) return 3; + else return 4; } -void swfoutput_drawimageagain(struct swfoutput*obj, int id, int sizex,int sizey, - double x1,double y1, - double x2,double y2, - double x3,double y3, - double x4,double y4) +int gfxline_has_dots(gfxline_t*line) { - if(id<0) return; - if(shapeid>=0) - endshape(); - if(textid>=0) - endtext(); + int tmplines=0; + double x,y; + double dist = 0; + int isline = 0; + while(line) { + if(line->type == gfx_moveTo) { + if(isline && dist < 1) { + return 1; + } + dist = 0; + isline = 0; + } else if(line->type == gfx_lineTo) { + dist += fabs(line->x - x) + fabs(line->y - y); + isline = 1; + } else if(line->type == gfx_splineTo) { + dist += fabs(line->sx - x) + fabs(line->sy - y) + + fabs(line->x - line->sx) + fabs(line->y - line->sy); + isline = 1; + } + x = line->x; + y = line->y; + line = line->next; + } + if(isline && dist < 1) { + return 1; + } + return 0; +} - drawimage(obj, id, sizex, sizey, x1,y1,x2,y2,x3,y3,x4,y4); +int gfxline_fix_short_edges(gfxline_t*line) +{ + double x,y; + while(line) { + if(line->type == gfx_lineTo) { + if(fabs(line->x - x) + fabs(line->y - y) < 0.01) { + line->x += 0.01; + } + } else if(line->type == gfx_splineTo) { + if(fabs(line->sx - x) + fabs(line->sy - y) + + fabs(line->x - line->sx) + fabs(line->y - line->sy) < 0.01) { + line->x += 0.01; + } + } + x = line->x; + y = line->y; + line = line->next; + } + return 0; } +int shapenr = 0; + +void swf_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit) +{ + swfoutput_internal*i = (swfoutput_internal*)dev->internal; + swfoutput*obj = i->obj; + int type = gfxline_type(line); + int has_dots = gfxline_has_dots(line); + + /* TODO: * split line into segments, and perform this check for all segments */ + if(!has_dots && + (width <= config_caplinewidth + || (cap_style == gfx_capRound && joint_style == gfx_joinRound) + || (cap_style == gfx_capRound && type<=2))) { + msg(" draw as stroke, type=%d dots=%d", type, has_dots); + endtext(obj); + swfoutput_setstrokecolor(obj, color->r, color->g, color->b, color->a); + swfoutput_setlinewidth(obj, width); + startshape(obj); + stopFill(obj); + drawgfxline(obj, line); + } else { + msg(" draw as polygon, type=%d dots=%d", type, has_dots); + if(has_dots) + gfxline_fix_short_edges(line); + /* we need to convert the line into a polygon */ + ArtSVP* svp = gfxstrokeToSVP(line, width, cap_style, joint_style, miterLimit); + gfxline_t*gfxline = SVPtogfxline(svp); + dev->fill(dev, gfxline, color); + } +} +void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) +{ + swfoutput_internal*i = (swfoutput_internal*)dev->internal; + swfoutput*obj = i->obj; + endtext(obj); + if(!config_ignoredraworder) + endshape(obj); + swfoutput_setfillcolor(obj, color->r, color->g, color->b, color->a); + startshape(obj); + startFill(obj); + i->fill=1; + drawgfxline(obj, line); + msg(" end of swf_fill (shapeid=%d)", i->shapeid); +} +void swf_fillgradient(gfxdevice_t*dev, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) +{ + msg(" Gradient filling not implemented yet"); +}