X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fmodules%2Fswfshape.c;h=51837f2b0c06b44a14c7d8a4cf4f0ecb2879aedf;hb=d67bc214215df3b2a1d13cef25ec18a21d0bb814;hp=4642cffab0d39c6e9ac98cfa79f9ec074ba00148;hpb=3568c643744cdce9ab08aaaf009badfbba1d59ba;p=swftools.git diff --git a/lib/modules/swfshape.c b/lib/modules/swfshape.c index 4642cff..51837f2 100644 --- a/lib/modules/swfshape.c +++ b/lib/modules/swfshape.c @@ -7,9 +7,19 @@ Copyright (c) 2001 Rainer Böhme - This file is distributed under the GPL, see file COPYING for details + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -*/ + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define SF_MOVETO 0x01 #define SF_FILL0 0x02 @@ -172,6 +182,11 @@ int swf_SetFillStyle(TAG * t,FILLSTYLE * f) swf_SetU16(t,f->id_bitmap); swf_SetMatrix(t,&f->m); break; + case FILL_LINEAR: + case FILL_RADIAL: + swf_SetMatrix(t,&f->m); + swf_SetGradient(t,&f->gradient,/*alpha?*/t->id==ST_DEFINESHAPE3?1:0); + break; } return 0; @@ -219,13 +234,10 @@ int swf_SetShapeStyles(TAG * t,SHAPE * s) int swf_ShapeCountBits(SHAPE * s,U8 * fbits,U8 * lbits) { if (!s) return -1; - - s->bits.fill = swf_CountBits(s->fillstyle.n,0); - s->bits.line = swf_CountBits(s->linestyle.n,0); - + s->bits.fill = swf_CountUBits(s->fillstyle.n, 0); + s->bits.line = swf_CountUBits(s->linestyle.n, 0); if (fbits) fbits[0] = s->bits.fill; if (lbits) lbits[0] = s->bits.line; - return 0; } @@ -245,63 +257,10 @@ int swf_SetShapeHeader(TAG * t,SHAPE * s) return res; } -int swf_ShapeExport(int handle,SHAPE * s) // without Linestyle/Fillstyle Record -{ int l; - if (!s) return 0; - - l = sizeof(SHAPE); - - if (handle>=0) - if (write(handle,s,sizeof(SHAPE))!=sizeof(SHAPE)) return -1; - - // Fillstyle, Linestyle ... - - if (s->data) - { int ll = (s->bitlen+7)/8; - l+=ll; - if (handle>=0) - if (write(handle,s->data,ll)!=ll) return -1; - } - - return l; -} - -int swf_ShapeImport(int handle,SHAPE * * shape) -{ SHAPE * s; - - if (handle<0) return -1; - - s = (SHAPE *)malloc(sizeof(SHAPE)); shape[0] = s; - if (!s) return -1; - - if (read(handle,s,sizeof(SHAPE))!=sizeof(SHAPE)) - { shape[0] = NULL; - free(s); - return -1; - } - - if (s->data) - { int ll = (s->bitlen+7)/8; - s->data = (U8*)malloc(ll); - if (!s->data) - { shape[0] = NULL; - free(s); - return -1; - } - if (read(handle,s->data,ll)!=ll) - { free(s->data); - free(s); - shape[0] = NULL; - return -1; - } - } - - return 0; -} - -int swf_ShapeAddFillStyle(SHAPE * s,U8 type,MATRIX * m,RGBA * color,U16 id_bitmap) +int swf_ShapeAddFillStyle(SHAPE * s,U8 type,MATRIX * m,RGBA * color,U16 id_bitmap, GRADIENT*gradient) { RGBA def_c; MATRIX def_m; + GRADIENT def_g; // handle defaults @@ -315,6 +274,11 @@ int swf_ShapeAddFillStyle(SHAPE * s,U8 type,MATRIX * m,RGBA * color,U16 id_bitma { m = &def_m; swf_GetMatrix(NULL,m); } + if(!gradient) + { + gradient = &def_g; + swf_GetGradient(NULL, gradient, 1); + } // handle memory @@ -329,22 +293,27 @@ int swf_ShapeAddFillStyle(SHAPE * s,U8 type,MATRIX * m,RGBA * color,U16 id_bitma if (!s->fillstyle.data) return -1; } - // set fillstyle (no gradients yet!) + // set fillstyle s->fillstyle.data[s->fillstyle.n].type = type; s->fillstyle.data[s->fillstyle.n].id_bitmap = id_bitmap; memcpy(&s->fillstyle.data[s->fillstyle.n].m,m,sizeof(MATRIX)); memcpy(&s->fillstyle.data[s->fillstyle.n].color,color,sizeof(RGBA)); + memcpy(&s->fillstyle.data[s->fillstyle.n].gradient,gradient,sizeof(GRADIENT)); return (++s->fillstyle.n); } int swf_ShapeAddSolidFillStyle(SHAPE * s,RGBA * color) -{ return swf_ShapeAddFillStyle(s,FILL_SOLID,NULL,color,0); +{ return swf_ShapeAddFillStyle(s,FILL_SOLID,NULL,color,0,0); } int swf_ShapeAddBitmapFillStyle(SHAPE * s,MATRIX * m,U16 id_bitmap,int clip) -{ return swf_ShapeAddFillStyle(s,clip?FILL_CLIPPED:FILL_TILED,m,NULL,id_bitmap); +{ return swf_ShapeAddFillStyle(s,clip?FILL_CLIPPED:FILL_TILED,m,NULL,id_bitmap,0); +} + +int swf_ShapeAddGradientFillStyle(SHAPE * s,MATRIX * m,GRADIENT* gradient,int radial) +{ return swf_ShapeAddFillStyle(s,radial?FILL_RADIAL:FILL_LINEAR,m,NULL,0,gradient); } int swf_ShapeAddLineStyle(SHAPE * s,U16 width,RGBA * color) @@ -388,7 +357,7 @@ int swf_ShapeSetMove(TAG * t,SHAPE * s,S32 x,S32 y) return 0; } -int swf_ShapeSetStyle(TAG * t,SHAPE * s,U16 line,U16 fill0,U16 fill1) +int swf_ShapeSetStyle(TAG * t,SHAPE * s,int line,int fill0,int fill1) { if ((!t)||(!s)) return -1; swf_SetBits(t,0,1); @@ -407,21 +376,26 @@ int swf_ShapeSetStyle(TAG * t,SHAPE * s,U16 line,U16 fill0,U16 fill1) these defines are a workaround (they also reduce the maximal number of fill styles to 32768) */ -#define FILL_RESET 0x8000 -#define LINE_RESET 0x8000 +#define UNDEFINED_COORD 0x7fffffff -int swf_ShapeSetAll(TAG * t,SHAPE * s,S32 x,S32 y,U16 line,U16 fill0,U16 fill1) +int swf_ShapeSetAll(TAG * t,SHAPE * s,S32 x,S32 y,int line,int fill0,int fill1) { U8 b; + U8 hasmove = 0; if ((!t)||(!s)) return -1; + if(x!=UNDEFINED_COORD || y!=UNDEFINED_COORD) + hasmove=1; + swf_SetBits(t,0,1); - swf_SetBits(t,SF_MOVETO|(line?SF_LINE:0)|(fill0?SF_FILL0:0)|(fill1?SF_FILL1:0),5); + swf_SetBits(t,(hasmove?SF_MOVETO:0)|(line?SF_LINE:0)|(fill0?SF_FILL0:0)|(fill1?SF_FILL1:0),5); - b = swf_CountBits(x,0); - b = swf_CountBits(y,b); - swf_SetBits(t,b,5); - swf_SetBits(t,x,b); - swf_SetBits(t,y,b); + if(hasmove) { + b = swf_CountBits(x,0); + b = swf_CountBits(y,b); + swf_SetBits(t,b,5); + swf_SetBits(t,x,b); + swf_SetBits(t,y,b); + } if (fill0) swf_SetBits(t,fill0,s->bits.fill); if (fill1) swf_SetBits(t,fill1,s->bits.fill); @@ -446,6 +420,11 @@ int swf_ShapeSetLine(TAG * t,SHAPE * s,S32 x,S32 y) { b = swf_CountBits(x,2); b = swf_CountBits(y,b); if (b<2) b=2; + if(b-2 >= 16) { + fprintf(stderr, "Bit overflow in swf_ShapeSetLine(1)- %d\n", b); + fflush(stdout); + b = 17; + } swf_SetBits(t, b-2, 4); swf_SetBits(t,1,1); swf_SetBits(t,x,b); @@ -457,6 +436,10 @@ int swf_ShapeSetLine(TAG * t,SHAPE * s,S32 x,S32 y) { b = swf_CountBits(y,2); if(b<2) b=2; + if(b-2 >= 16) { + fprintf(stderr, "Bit overflow in swf_ShapeSetLine(2)- %d\n", b); + b = 17; + } swf_SetBits(t, b-2, 4); swf_SetBits(t,1,2); swf_SetBits(t,y,b); @@ -465,6 +448,10 @@ int swf_ShapeSetLine(TAG * t,SHAPE * s,S32 x,S32 y) { b = swf_CountBits(x,2); if(b<2) b=2; + if(b-2 >= 16) { + fprintf(stderr, "Bit overflow in swf_ShapeSetLine(3)- %d\n", b); + b = 17; + } swf_SetBits(t, b-2, 4); swf_SetBits(t,0,2); swf_SetBits(t,x,b); @@ -538,6 +525,11 @@ SHAPELINE* swf_ParseShapeData(U8*data, int bits, int fillbits, int linebits) flags = swf_GetBits(tag, 5); if(!flags) break; + if(flags&1) { //move + int n = swf_GetBits(tag, 5); + x = swf_GetSBits(tag, n); //x + y = swf_GetSBits(tag, n); //y + } if(flags&2) fill0 = swf_GetBits(tag, fillbits); if(flags&4) @@ -545,16 +537,13 @@ SHAPELINE* swf_ParseShapeData(U8*data, int bits, int fillbits, int linebits) if(flags&8) line = swf_GetBits(tag, linebits); if(flags&16) { - return 0; + fprintf(stderr, "Additional file styles style change not yet supported\n"); + exit(1); //enumerateUsedIDs_styles(tag, callback, callback_data, num); fillbits = swf_GetBits(tag, 4); linebits = swf_GetBits(tag, 4); } if(flags&1) { //move - int n = swf_GetBits(tag, 5); - x = swf_GetBits(tag, n); //x - y = swf_GetBits(tag, n); //y - lines->next = (SHAPELINE*)malloc(sizeof(SHAPELINE)); lines = lines->next; lines->type = moveTo; @@ -570,7 +559,6 @@ SHAPELINE* swf_ParseShapeData(U8*data, int bits, int fillbits, int linebits) flags = swf_GetBits(tag, 1); if(flags) { //straight edge int n = swf_GetBits(tag, 4) + 2; - int x=0,y=0; if(swf_GetBits(tag, 1)) { //line flag x += swf_GetSBits(tag, n); //delta x y += swf_GetSBits(tag, n); //delta y @@ -618,29 +606,46 @@ SHAPELINE* swf_ParseShapeData(U8*data, int bits, int fillbits, int linebits) return _lines.next; } -SRECT swf_GetShapeBoundingBox(SHAPELINE*shape) +SRECT swf_GetShapeBoundingBox(SHAPE2*shape2) { SRECT r; - int SCOORD_MAX = 0x7fffffff; - int SCOORD_MIN = -0x80000000; + SHAPELINE*l = shape2->lines; + int lastx=0,lasty=0; + int valid = 0; r.xmin = r.ymin = SCOORD_MAX; r.xmax = r.ymax = SCOORD_MIN; - if(!shape) { - fprintf(stderr, "rfxswf: Warning: empty Shape\n"); - } - while(shape) { - if(shape->x < r.xmin) r.xmin = shape->x; - if(shape->y < r.ymin) r.ymin = shape->y; - if(shape->x > r.xmax) r.xmax = shape->x; - if(shape->y > r.ymax) r.ymax = shape->y; - if(shape->type == splineTo) { - if(shape->sx < r.xmin) r.xmin = shape->sx; - if(shape->sy < r.ymin) r.ymin = shape->sy; - if(shape->sx > r.xmax) r.xmax = shape->sx; - if(shape->sy > r.ymax) r.ymax = shape->sy; + + while(l) { + int t1; + if(l->linestyle>0) { + t1 = shape2->linestyles[l->linestyle - 1].width*3/2; + } else { + t1 = 0; + } + + if(l->type == lineTo || l->type == splineTo) + { + valid = 1; + if(lastx - t1 < r.xmin) r.xmin = lastx - t1; + if(lasty - t1 < r.ymin) r.ymin = lasty - t1; + if(lastx + t1 > r.xmax) r.xmax = lastx + t1; + if(lasty + t1 > r.ymax) r.ymax = lasty + t1; + if(l->x - t1 < r.xmin) r.xmin = l->x - t1; + if(l->y - t1 < r.ymin) r.ymin = l->y - t1; + if(l->x + t1 > r.xmax) r.xmax = l->x + t1; + if(l->y + t1 > r.ymax) r.ymax = l->y + t1; + if(l->type == splineTo) { + if(l->sx - t1 < r.xmin) r.xmin = l->sx - t1; + if(l->sy - t1 < r.ymin) r.ymin = l->sy - t1; + if(l->sx + t1 > r.xmax) r.xmax = l->sx + t1; + if(l->sy + t1 > r.ymax) r.ymax = l->sy + t1; + } } - shape = shape->next; + lastx = l->x; + lasty = l->y; + l = l->next; } + if(!valid) memset(&r, 0, sizeof(SRECT)); return r; } @@ -677,35 +682,216 @@ SHAPE2* swf_ShapeToShape2(SHAPE*shape) { return shape2; }; -SHAPE2* parseDefineShape(TAG*tag) +void swf_ShapeSetBitmapRect(TAG*tag, U16 gfxid, int width, int height) +{ + SHAPE*shape; + MATRIX m; + RGBA rgb; + SRECT r; + int lines = 0; + int ls=0,fs; + swf_ShapeNew(&shape); + rgb.b = rgb.g = rgb.r = 0xff; + if(lines) + ls = swf_ShapeAddLineStyle(shape,20,&rgb); + swf_GetMatrix(NULL,&m); + m.sx = 20*65536; + m.sy = 20*65536; + + fs = swf_ShapeAddBitmapFillStyle(shape,&m,gfxid,0); + r.xmin = 0; + r.ymin = 0; + r.xmax = width*20; + r.ymax = height*20; + swf_SetRect(tag,&r); + + swf_SetShapeStyles(tag,shape); + swf_ShapeCountBits(shape,NULL,NULL); + swf_SetShapeBits(tag,shape); + + swf_ShapeSetAll(tag,shape,0,0,lines?ls:0,fs,0); + + swf_ShapeSetLine(tag,shape,width*20,0); + swf_ShapeSetLine(tag,shape,0,height*20); + swf_ShapeSetLine(tag,shape,-width*20,0); + swf_ShapeSetLine(tag,shape,0,-height*20); + swf_ShapeSetEnd(tag); + swf_ShapeFree(shape); +} + +void swf_Shape2ToShape(SHAPE2*shape2, SHAPE*shape) +{ + TAG*tag = swf_InsertTag(0,0); + SHAPELINE*l,*next; + int newx=0,newy=0,lastx=0,lasty=0,oldls=0,oldfs0=0,oldfs1=0; + + memset(shape, 0, sizeof(SHAPE)); + + shape->linestyle.n = shape2->numlinestyles; + shape->linestyle.data = (LINESTYLE*)malloc(sizeof(LINESTYLE)*shape->linestyle.n); + memcpy(shape->linestyle.data, shape2->linestyles, sizeof(LINESTYLE)*shape->linestyle.n); + + shape->fillstyle.n = shape2->numfillstyles; + shape->fillstyle.data = (FILLSTYLE*)malloc(sizeof(FILLSTYLE)*shape->fillstyle.n); + memcpy(shape->fillstyle.data, shape2->fillstyles, sizeof(FILLSTYLE)*shape->fillstyle.n); + + swf_ShapeCountBits(shape,NULL,NULL); + + l = shape2->lines; + + while(l) { + int ls=0,fs0=0,fs1=0; + + if(l->type != moveTo) { + if(oldls != l->linestyle) {oldls = ls = l->linestyle;if(!ls) ls=0x8000;} + if(oldfs0 != l->fillstyle0) {oldfs0 = fs0 = l->fillstyle0;if(!fs0) fs0=0x8000;} + if(oldfs1 != l->fillstyle1) {oldfs1 = fs1 = l->fillstyle1;if(!fs1) fs1=0x8000;} + + if(ls || fs0 || fs1 || newx!=0x7fffffff || newy!=0x7fffffff) { + swf_ShapeSetAll(tag,shape,newx,newy,ls,fs0,fs1); + newx = 0x7fffffff; + newy = 0x7fffffff; + } + } + + if(l->type == lineTo) { + swf_ShapeSetLine(tag,shape,l->x-lastx,l->y-lasty); + } else if(l->type == splineTo) { + swf_ShapeSetCurve(tag,shape, l->sx-lastx,l->sy-lasty, l->x-l->sx,l->y-l->sy); + } + if(l->type == moveTo) { + newx = l->x; + newy = l->y; + } + + lastx = l->x; + lasty = l->y; + l = l->next; + } + swf_ShapeSetEnd(tag); + shape->data = tag->data; + shape->bitlen = tag->len*8; +} + +void swf_SetShape2(TAG*tag, SHAPE2*shape2) +{ + SHAPE shape; + swf_Shape2ToShape(shape2, &shape); + + swf_SetRect(tag,shape2->bbox); + swf_SetShapeStyles(tag, &shape); + swf_ShapeCountBits(&shape,NULL,NULL); + swf_SetShapeBits(tag,&shape); + + swf_SetBlock(tag, shape.data, (shape.bitlen+7)/8); +} + +static void parseFillStyleArray(TAG*tag, SHAPE2*shape) { - int num = 0; + U16 count; + int t; + int num=0; if(tag->id == ST_DEFINESHAPE) num = 1; else if(tag->id == ST_DEFINESHAPE2) num = 2; else if(tag->id == ST_DEFINESHAPE3) num = 3; - /* todo */ - fprintf(stderr, "Not implemented yet!\n"); - exit(1); - return 0; -} - -SHAPE* swf_Shape2ToShape(SHAPE2*shape) -{ - /* todo */ - fprintf(stderr, "Not implemented yet!\n"); - exit(1); - return 0; + count = swf_GetU8(tag); + if(count == 0xff && num>1) // defineshape2,3 only + count = swf_GetU16(tag); + + shape->numfillstyles = count; + shape->fillstyles = malloc(sizeof(FILLSTYLE)*count); + + for(t=0;tfillstyles[t]; + type = swf_GetU8(tag); //type + shape->fillstyles[t].type = type; + if(type == 0) { + /* plain color */ + if(num == 3) + swf_GetRGBA(tag, &dest->color); + else + swf_GetRGB(tag, &dest->color); + } + else if(type == 0x10 || type == 0x12) + { + /* linear/radial gradient fill */ + swf_ResetReadBits(tag); + swf_GetMatrix(tag, &dest->m); + swf_ResetReadBits(tag); + swf_GetGradient(tag, &dest->gradient, num>=3?1:0); + } + else if(type == 0x40 || type == 0x41) + { + /* bitmap fill */ + swf_ResetReadBits(tag); + dest->id_bitmap = swf_GetU16(tag); //id + swf_ResetReadBits(tag); //? + swf_GetMatrix(tag, &dest->m); + } + else { + fprintf(stderr, "rfxswf:swftools.c Unknown fillstyle:0x%02x\n",type); + } + } + swf_ResetReadBits(tag); + count = swf_GetU8(tag); // line style array + if(count == 0xff) + count = swf_GetU16(tag); + + //if(verbose) printf("lnum: %d\n", count); + + shape->numlinestyles = count; + shape->linestyles = malloc(sizeof(LINESTYLE)*count); + /* TODO: should we start with 1 and insert a correct definition of the + "built in" linestyle 0? */ + for(t=0;tlinestyles[t].width = swf_GetU16(tag); + if(num == 3) + swf_GetRGBA(tag, &shape->linestyles[t].color); + else + swf_GetRGB(tag, &shape->linestyles[t].color); + } + return; } -int swf_SetShape2(TAG*tag, SHAPE2*shape) +void swf_ParseDefineShape(TAG*tag, SHAPE2*shape) { - /* todo */ - fprintf(stderr, "Not implemented yet!\n"); - exit(1); - return 0; + int num = 0, id; + U16 fill,line; + SRECT r; + SRECT r2; + SHAPELINE*l; + if(tag->id == ST_DEFINESHAPE) + num = 1; + else if(tag->id == ST_DEFINESHAPE2) + num = 2; + else if(tag->id == ST_DEFINESHAPE3) + num = 3; + else { + fprintf(stderr, "parseDefineShape must be called with a shape tag"); + } + + id = swf_GetU16(tag); //id + memset(shape, 0, sizeof(SHAPE2)); + shape->bbox = malloc(sizeof(SRECT)); + swf_GetRect(tag, &r); + + memcpy(shape->bbox, &r, sizeof(SRECT)); + parseFillStyleArray(tag, shape); + + swf_ResetReadBits(tag); + fill = (U16)swf_GetBits(tag,4); + line = (U16)swf_GetBits(tag,4); + + shape->lines = swf_ParseShapeData(&tag->data[tag->pos], (tag->len - tag->pos)*8, fill, line); + + l = shape->lines; }