5 Extension module for the rfxswf library.
6 Part of the swftools package.
8 Copyright (c) 2001 Rainer Böhme <rfxswf@reflex-studio.de>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
24 #define SF_MOVETO 0x01
28 #define SF_NEWSTYLE 0x10
30 #define FILL_SOLID 0x00
31 #define FILL_LINEAR 0x10 // Gradient
32 #define FILL_RADIAL 0x12
33 #define FILL_TILED 0x40 // Bitmap
34 #define FILL_CLIPPED 0x41
36 void swf_ShapeFree(SHAPE * s)
38 { if (s->linestyle.data) free(s->linestyle.data);
39 s->linestyle.data = NULL;
41 if (s->fillstyle.data) free(s->fillstyle.data);
42 s->fillstyle.data = NULL;
44 if (s->data) free(s->data);
50 int swf_ShapeNew(SHAPE * * s)
53 sh = (SHAPE *)malloc(sizeof(SHAPE)); s[0] = sh;
54 if (sh) memset(sh,0x00,sizeof(SHAPE));
58 int swf_GetSimpleShape(TAG * t,SHAPE * * s) // without Linestyle/Fillstyle Record
64 if (FAILED(swf_ShapeNew(s))) return -1;
68 sh->bits.fill = (U16)swf_GetBits(t,4);
69 sh->bits.line = (U16)swf_GetBits(t,4);
70 bitl = 0; end = 0; pos = swf_GetTagPos(t);
73 { int edge = swf_GetBits(t,1); bitl+=1;
76 if (swf_GetBits(t,1)) // Line
77 { U16 nbits = swf_GetBits(t,4)+2;
80 if (swf_GetBits(t,1)) // x/y Line
81 { swf_GetBits(t,nbits);
86 { swf_GetBits(t,nbits+1);
91 { U16 nbits = swf_GetBits(t,4)+2;
103 { U16 flags = swf_GetBits(t,5); bitl+=5;
107 { U16 nbits = swf_GetBits(t,5); bitl+=5;
108 swf_GetBits(t,nbits);
109 swf_GetBits(t,nbits);
114 { swf_GetBits(t,sh->bits.fill);
119 { swf_GetBits(t,sh->bits.fill);
124 { swf_GetBits(t,sh->bits.line);
128 if (flags&SF_NEWSTYLE)
129 { fprintf(stderr,"RFXSWF: Can't process extended styles in shape.\n");
135 swf_SetTagPos(t,pos);
138 if (sh->data) free(sh->data);
139 sh->data = (U8*)malloc(len);
143 swf_GetBlock(t,sh->data,len);
150 int swf_SetSimpleShape(TAG * t,SHAPE * s) // without Linestyle/Fillstyle Record
157 { swf_ResetWriteBits(t);
159 swf_SetBits(t,s->bits.fill,4);
160 swf_SetBits(t,s->bits.line,4);
161 swf_SetBlock(t,s->data,l);
163 swf_ResetWriteBits(t);
168 int swf_SetFillStyle(TAG * t,FILLSTYLE * f)
169 { if ((!t)||(!f)) return -1;
170 swf_SetU8(t,f->type);
176 if (swf_GetTagID(t)!=ST_DEFINESHAPE3) swf_SetRGB(t,&f->color);
177 else swf_SetRGBA(t,&f->color);
182 swf_SetU16(t,f->id_bitmap);
183 swf_SetMatrix(t,&f->m);
187 swf_SetMatrix(t,&f->m);
188 swf_SetGradient(t,&f->gradient,/*alpha?*/t->id==ST_DEFINESHAPE3?1:0);
195 int swf_SetLineStyle(TAG * t,LINESTYLE * l)
196 { if ((!l)||(!t)) return -1;
197 swf_SetU16(t,l->width);
199 if (swf_GetTagID(t)!=ST_DEFINESHAPE3) swf_SetRGB(t,&l->color);
200 else swf_SetRGBA(t,&l->color);
205 int swf_SetShapeStyleCount(TAG * t,U16 n)
217 int swf_SetShapeStyles(TAG * t,SHAPE * s)
222 l += swf_SetShapeStyleCount(t,s->fillstyle.n);
224 for (i=0;i<s->fillstyle.n;i++)
225 l+=swf_SetFillStyle(t,&s->fillstyle.data[i]);
227 l += swf_SetShapeStyleCount(t,s->linestyle.n);
229 for (i=0;i<s->linestyle.n;i++)
230 l+=swf_SetLineStyle(t,&s->linestyle.data[i]);
235 int swf_ShapeCountBits(SHAPE * s,U8 * fbits,U8 * lbits)
237 s->bits.fill = swf_CountUBits(s->fillstyle.n, 0);
238 s->bits.line = swf_CountUBits(s->linestyle.n, 0);
239 if (fbits) fbits[0] = s->bits.fill;
240 if (lbits) lbits[0] = s->bits.line;
244 int swf_SetShapeBits(TAG * t,SHAPE * s)
245 { if ((!t)||(!s)) return -1;
246 swf_ResetWriteBits(t);
247 swf_SetBits(t,s->bits.fill,4);
248 swf_SetBits(t,s->bits.line,4);
252 int swf_SetShapeHeader(TAG * t,SHAPE * s)
254 res = swf_SetShapeStyles(t,s);
255 if (res>=0) res = swf_ShapeCountBits(s,NULL,NULL);
256 if (res>=0) res = swf_SetShapeBits(t,s);
260 int swf_ShapeAddFillStyle(SHAPE * s,U8 type,MATRIX * m,RGBA * color,U16 id_bitmap, GRADIENT*gradient)
271 def_c.r = def_c.g = def_c.b = 0;
275 swf_GetMatrix(NULL,m);
280 swf_GetGradient(NULL, gradient, 1);
285 if (s->fillstyle.data)
286 { FILLSTYLE * new = (FILLSTYLE *)realloc(s->fillstyle.data,(s->fillstyle.n+1)*sizeof(FILLSTYLE));
288 s->fillstyle.data = new;
291 { s->fillstyle.data = (FILLSTYLE *)malloc(sizeof(FILLSTYLE));
293 if (!s->fillstyle.data) return -1;
296 // set fillstyle (no gradients yet!)
298 s->fillstyle.data[s->fillstyle.n].type = type;
299 s->fillstyle.data[s->fillstyle.n].id_bitmap = id_bitmap;
300 memcpy(&s->fillstyle.data[s->fillstyle.n].m,m,sizeof(MATRIX));
301 memcpy(&s->fillstyle.data[s->fillstyle.n].color,color,sizeof(RGBA));
302 memcpy(&s->fillstyle.data[s->fillstyle.n].gradient,gradient,sizeof(GRADIENT));
304 return (++s->fillstyle.n);
307 int swf_ShapeAddSolidFillStyle(SHAPE * s,RGBA * color)
308 { return swf_ShapeAddFillStyle(s,FILL_SOLID,NULL,color,0,0);
311 int swf_ShapeAddBitmapFillStyle(SHAPE * s,MATRIX * m,U16 id_bitmap,int clip)
312 { return swf_ShapeAddFillStyle(s,clip?FILL_CLIPPED:FILL_TILED,m,NULL,id_bitmap,0);
315 int swf_ShapeAddGradientFillStyle(SHAPE * s,MATRIX * m,GRADIENT* gradient,int radial)
316 { return swf_ShapeAddFillStyle(s,radial?FILL_RADIAL:FILL_LINEAR,m,NULL,0,gradient);
319 int swf_ShapeAddLineStyle(SHAPE * s,U16 width,RGBA * color)
325 def.r = def.g = def.b = 0;
327 if (s->linestyle.data)
328 { LINESTYLE * new = (LINESTYLE *)realloc(s->linestyle.data,(s->linestyle.n+1)*sizeof(LINESTYLE));
330 s->linestyle.data = new;
333 { s->linestyle.data = (LINESTYLE *)malloc(sizeof(LINESTYLE));
335 if (!s->linestyle.data) return -1;
338 s->linestyle.data[s->linestyle.n].width = width;
339 memcpy(&s->linestyle.data[s->linestyle.n].color,color,sizeof(RGBA));
341 return (++s->linestyle.n);
344 int swf_ShapeSetMove(TAG * t,SHAPE * s,S32 x,S32 y)
348 swf_SetBits(t,SF_MOVETO,5);
350 b = swf_CountBits(x,0);
351 b = swf_CountBits(y,b);
360 int swf_ShapeSetStyle(TAG * t,SHAPE * s,int line,int fill0,int fill1)
361 { if ((!t)||(!s)) return -1;
364 swf_SetBits(t,(line?SF_LINE:0)|(fill0?SF_FILL0:0)|(fill1?SF_FILL1:0),5);
366 if (fill0) swf_SetBits(t,fill0,s->bits.fill);
367 if (fill1) swf_SetBits(t,fill1,s->bits.fill);
368 if (line) swf_SetBits(t,line ,s->bits.line);
373 /* TODO: sometimes we want to set fillstyle 0, as that's the empty fill
374 used for line drawings. At the moment, we can't, as 0 fill be considered
375 nonexistent and therefore not set.
376 these defines are a workaround (they also reduce the maximal number of
377 fill styles to 32768)
379 #define UNDEFINED_COORD 0x7fffffff
381 int swf_ShapeSetAll(TAG * t,SHAPE * s,S32 x,S32 y,int line,int fill0,int fill1)
384 if ((!t)||(!s)) return -1;
386 if(x!=UNDEFINED_COORD || y!=UNDEFINED_COORD)
390 swf_SetBits(t,(hasmove?SF_MOVETO:0)|(line?SF_LINE:0)|(fill0?SF_FILL0:0)|(fill1?SF_FILL1:0),5);
393 b = swf_CountBits(x,0);
394 b = swf_CountBits(y,b);
400 if (fill0) swf_SetBits(t,fill0,s->bits.fill);
401 if (fill1) swf_SetBits(t,fill1,s->bits.fill);
402 if (line) swf_SetBits(t,line ,s->bits.line);
407 int swf_ShapeSetEnd(TAG * t)
410 swf_ResetWriteBits(t);
414 int swf_ShapeSetLine(TAG * t,SHAPE * s,S32 x,S32 y)
417 swf_SetBits(t,3,2); // Straight Edge
419 if ((!s)||((x!=0)&&(y!=0)))
420 { b = swf_CountBits(x,2);
421 b = swf_CountBits(y,b);
424 fprintf(stderr, "Bit overflow in swf_ShapeSetLine(1)- %d\n", b);
429 swf_SetBits(t, b-2, 4);
437 { b = swf_CountBits(y,2);
441 fprintf(stderr, "Bit overflow in swf_ShapeSetLine(2)- %d\n", b);
444 swf_SetBits(t, b-2, 4);
449 { b = swf_CountBits(x,2);
453 fprintf(stderr, "Bit overflow in swf_ShapeSetLine(3)- %d\n", b);
456 swf_SetBits(t, b-2, 4);
463 int swf_ShapeSetCurve(TAG * t,SHAPE * s,S32 x,S32 y,S32 ax,S32 ay)
469 b = swf_CountBits(ax,2);
470 b = swf_CountBits(ay,b);
471 b = swf_CountBits(x,b);
472 b = swf_CountBits(y,b);
474 swf_SetBits(t,b-2,4);
483 int swf_ShapeSetCircle(TAG * t,SHAPE * s,S32 x,S32 y,S32 rx,S32 ry)
484 { double C1 = 0.2930;
486 double begin = 0.7070;
490 swf_ShapeSetMove(t,s,x+begin*rx,y+begin*ry);
491 swf_ShapeSetCurve(t,s, -C1*rx, C1*ry, -C2*rx, 0);
492 swf_ShapeSetCurve(t,s, -C2*rx, 0, -C1*rx, -C1*ry);
493 swf_ShapeSetCurve(t,s, -C1*rx, -C1*ry, 0, -C2*ry);
494 swf_ShapeSetCurve(t,s, 0, -C2*ry, C1*rx, -C1*ry);
495 swf_ShapeSetCurve(t,s, C1*rx, -C1*ry, C2*rx, 0);
496 swf_ShapeSetCurve(t,s, C2*rx, 0, C1*rx, C1*ry);
497 swf_ShapeSetCurve(t,s, C1*rx, C1*ry, 0, C2*ry);
498 swf_ShapeSetCurve(t,s, 0, C2*ry, -C1*rx, C1*ry);
503 /* todo: merge this with swf_GetSimpleShape */
504 SHAPELINE* swf_ParseShapeData(U8*data, int bits, int fillbits, int linebits)
507 SHAPELINE*lines = &_lines;
516 memset(tag, 0, sizeof(TAG));
518 tag->len = tag->memsize = (bits+7)/8;
524 flags = swf_GetBits(tag, 1);
525 if(!flags) { //style change
526 flags = swf_GetBits(tag, 5);
530 int n = swf_GetBits(tag, 5);
531 x = swf_GetSBits(tag, n); //x
532 y = swf_GetSBits(tag, n); //y
535 fill0 = swf_GetBits(tag, fillbits);
537 fill1 = swf_GetBits(tag, fillbits);
539 line = swf_GetBits(tag, linebits);
541 fprintf(stderr, "Additional file styles style change not yet supported\n");
543 //enumerateUsedIDs_styles(tag, callback, callback_data, num);
544 fillbits = swf_GetBits(tag, 4);
545 linebits = swf_GetBits(tag, 4);
548 lines->next = (SHAPELINE*)malloc(sizeof(SHAPELINE));
550 lines->type = moveTo;
553 lines->sx = lines->sy = 0;
554 lines->fillstyle0 = fill0;
555 lines->fillstyle1 = fill1;
556 lines->linestyle = line;
560 flags = swf_GetBits(tag, 1);
561 if(flags) { //straight edge
562 int n = swf_GetBits(tag, 4) + 2;
563 if(swf_GetBits(tag, 1)) { //line flag
564 x += swf_GetSBits(tag, n); //delta x
565 y += swf_GetSBits(tag, n); //delta y
567 int v=swf_GetBits(tag, 1);
569 d = swf_GetSBits(tag, n); //vert/horz
573 lines->next = (SHAPELINE*)malloc(sizeof(SHAPELINE));
575 lines->type = lineTo;
578 lines->sx = lines->sy = 0;
579 lines->fillstyle0 = fill0;
580 lines->fillstyle1 = fill1;
581 lines->linestyle = line;
583 } else { //curved edge
584 int n = swf_GetBits(tag, 4) + 2;
586 x += swf_GetSBits(tag, n);
587 y += swf_GetSBits(tag, n);
590 x += swf_GetSBits(tag, n);
591 y += swf_GetSBits(tag, n);
593 lines->next = (SHAPELINE*)malloc(sizeof(SHAPELINE));
595 lines->type = splineTo;
600 lines->fillstyle0 = fill0;
601 lines->fillstyle1 = fill1;
602 lines->linestyle = line;
610 SRECT swf_GetShapeBoundingBox(SHAPE2*shape2)
613 SHAPELINE*l = shape2->lines;
616 r.xmin = r.ymin = SCOORD_MAX;
617 r.xmax = r.ymax = SCOORD_MIN;
622 t1 = shape2->linestyles[l->linestyle - 1].width*3/2;
627 if(l->type == lineTo || l->type == splineTo)
630 if(lastx - t1 < r.xmin) r.xmin = lastx - t1;
631 if(lasty - t1 < r.ymin) r.ymin = lasty - t1;
632 if(lastx + t1 > r.xmax) r.xmax = lastx + t1;
633 if(lasty + t1 > r.ymax) r.ymax = lasty + t1;
634 if(l->x - t1 < r.xmin) r.xmin = l->x - t1;
635 if(l->y - t1 < r.ymin) r.ymin = l->y - t1;
636 if(l->x + t1 > r.xmax) r.xmax = l->x + t1;
637 if(l->y + t1 > r.ymax) r.ymax = l->y + t1;
638 if(l->type == splineTo) {
639 if(l->sx - t1 < r.xmin) r.xmin = l->sx - t1;
640 if(l->sy - t1 < r.ymin) r.ymin = l->sy - t1;
641 if(l->sx + t1 > r.xmax) r.xmax = l->sx + t1;
642 if(l->sy + t1 > r.ymax) r.ymax = l->sy + t1;
649 if(!valid) memset(&r, 0, sizeof(SRECT));
653 void swf_Shape2Free(SHAPE2 * s)
655 SHAPELINE*line = s->lines;
657 SHAPELINE*next = line->next;
669 SHAPE2* swf_ShapeToShape2(SHAPE*shape) {
671 SHAPE2*shape2 = (SHAPE2*)malloc(sizeof(SHAPE2));
673 shape2->numlinestyles = shape->linestyle.n;
674 shape2->linestyles = (LINESTYLE*)malloc(sizeof(LINESTYLE)*shape->linestyle.n);
675 memcpy(shape2->linestyles, shape->linestyle.data, sizeof(LINESTYLE)*shape->linestyle.n);
677 shape2->numfillstyles = shape->fillstyle.n;
678 shape2->fillstyles = (FILLSTYLE*)malloc(sizeof(FILLSTYLE)*shape->fillstyle.n);
679 memcpy(shape2->fillstyles, shape->fillstyle.data, sizeof(FILLSTYLE)*shape->fillstyle.n);
681 shape2->lines = swf_ParseShapeData(shape->data, shape->bitlen, shape->bits.fill, shape->bits.line);
686 void swf_ShapeSetBitmapRect(TAG*tag, U16 gfxid, int width, int height)
694 swf_ShapeNew(&shape);
695 rgb.b = rgb.g = rgb.r = 0xff;
697 ls = swf_ShapeAddLineStyle(shape,20,&rgb);
698 swf_GetMatrix(NULL,&m);
702 fs = swf_ShapeAddBitmapFillStyle(shape,&m,gfxid,0);
709 swf_SetShapeStyles(tag,shape);
710 swf_ShapeCountBits(shape,NULL,NULL);
711 swf_SetShapeBits(tag,shape);
713 swf_ShapeSetAll(tag,shape,0,0,lines?ls:0,fs,0);
715 swf_ShapeSetLine(tag,shape,width*20,0);
716 swf_ShapeSetLine(tag,shape,0,height*20);
717 swf_ShapeSetLine(tag,shape,-width*20,0);
718 swf_ShapeSetLine(tag,shape,0,-height*20);
719 swf_ShapeSetEnd(tag);
720 swf_ShapeFree(shape);