3 Math and matrix functions, misc tools
5 Extension module for the rfxswf library.
6 Part of the swftools package.
8 Copyright (c) 2000, 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 // Matrix & Math tools for SWF files
26 #include "../rfxswf.h"
29 SFIXED RFXSWF_SP(SFIXED a1,SFIXED a2,SFIXED b1,SFIXED b2)
30 { S64 a = ((S64)a1*(S64)b1+(S64)a2*(S64)b2)>>16;
31 SFIXED result = (SFIXED)(a);
33 fprintf(stderr, "Warning: overflow in matrix multiplication");
36 SFIXED RFXSWF_QFIX(int zaehler,int nenner) // bildet Quotient von zwei INTs in SFIXED
37 { S64 z = zaehler<<16;
38 S64 a = z/(S64)nenner;
43 MATRIX * swf_MatrixJoin(MATRIX * d,MATRIX * s1,MATRIX * s2)
46 if (!s1) return (s2)?(MATRIX *)memcpy(d,s2,sizeof(MATRIX)):NULL;
47 if (!s2) return (MATRIX *)memcpy(d,s1,sizeof(MATRIX));
49 d->tx = s1->tx + RFXSWF_SP(s1->sx,s1->r1,s2->tx,s2->ty);
50 d->ty = s1->ty + RFXSWF_SP(s1->r0,s1->sy,s2->tx,s2->ty);
52 d->sx = RFXSWF_SP(s1->sx,s1->r1,s2->sx,s2->r0);
53 d->r0 = RFXSWF_SP(s1->r0,s1->sy,s2->sx,s2->r0);
55 d->r1 = RFXSWF_SP(s1->sx,s1->r1,s2->r1,s2->sy);
56 d->sy = RFXSWF_SP(s1->r0,s1->sy,s2->r1,s2->sy);
63 MATRIX * swf_MatrixMapTriangle(MATRIX * m,int dx,int dy,int x0,int y0,
64 int x1,int y1,int x2,int y2)
71 if ((!dx)||(!dy)) return NULL; // check DIV by zero
75 m->sx = RFXSWF_QFIX(dx1,dx);
76 m->sy = RFXSWF_QFIX(dy2,dy);
77 m->r0 = RFXSWF_QFIX(dy1,dx);
78 m->r1 = RFXSWF_QFIX(dx2,dy);
83 void swf_SetDefineID(TAG * tag, U16 newid)
85 int oldlen = tag->len;
87 swf_SetU16(tag, newid); /* set defining ID */
91 U16 swf_GetDefineID(TAG * t)
96 oldTagPos = swf_GetTagPos(t);
99 switch (swf_GetTagID(t))
100 { case ST_DEFINESHAPE:
101 case ST_DEFINESHAPE2:
102 case ST_DEFINESHAPE3:
103 case ST_DEFINESHAPE4:
104 case ST_DEFINEMORPHSHAPE:
105 case ST_DEFINEMORPHSHAPE2:
106 case ST_DEFINEEDITTEXT:
108 case ST_DEFINEBITSJPEG2:
109 case ST_DEFINEBITSJPEG3:
110 case ST_DEFINEBITSLOSSLESS:
111 case ST_DEFINEBITSLOSSLESS2:
112 case ST_DEFINESCALINGGRID: //pseudodefine
113 case ST_DEFINEBUTTON:
114 case ST_DEFINEBUTTON2:
115 case ST_DEFINEBUTTONCXFORM: //pseudodefine
116 case ST_DEFINEBUTTONSOUND: //pseudodefine
117 case ST_CSMTEXTSETTINGS: //pseudodefine
121 case ST_DEFINEFONTINFO: //pseudodefine
122 case ST_DEFINEFONTINFO2: //pseudodefine
123 case ST_DEFINEFONTALIGNZONES: //pseudodefine
124 case ST_DEFINEFONTNAME: //pseudodefine
126 case ST_DEFINEBINARY:
129 case ST_DEFINESPRITE:
131 case ST_DEFINEVIDEOSTREAM:
132 case ST_GLYPHNAMES: //pseudodefine
133 case ST_VIDEOFRAME: //pseudodefine
134 case ST_NAMECHARACTER: //pseudodefine
135 case ST_DOINITACTION: //pseudodefine
139 fprintf(stderr, "rfxswf: Error: tag %d (%s) has no id\n", t->id, swf_TagGetName(t));
142 swf_SetTagPos(t,oldTagPos);
147 SRECT swf_GetDefineBBox(TAG * t)
152 memset(&b1, 0, sizeof(b1));
154 oldTagPos = swf_GetTagPos(t);
159 switch (swf_GetTagID(t))
160 { case ST_DEFINESHAPE:
161 case ST_DEFINESHAPE2:
162 case ST_DEFINESHAPE3:
163 case ST_DEFINESHAPE4:
164 case ST_DEFINEEDITTEXT:
167 case ST_DEFINEVIDEOSTREAM:
171 case ST_DEFINEMORPHSHAPE:
175 swf_ExpandRect2(&b1, &b2);
177 case ST_DEFINEBITSLOSSLESS:
178 case ST_DEFINEBITSLOSSLESS2:
180 case ST_DEFINEBITSJPEG2:
181 case ST_DEFINEBITSJPEG3:
186 swf_SetTagPos(t,oldTagPos);
191 U16 swf_GetPlaceID(TAG * t)
196 oldTagPos = swf_GetTagPos(t);
199 switch (swf_GetTagID(t))
200 { case ST_PLACEOBJECT:
201 case ST_REMOVEOBJECT:
202 case ST_FREECHARACTER:
207 case ST_PLACEOBJECT2:
208 { U8 flags = swf_GetU8(t);
209 U16 d = swf_GetU16(t);
210 id = (flags&PF_CHAR)?swf_GetU16(t):id;
212 case ST_PLACEOBJECT3:
213 { U8 flags = swf_GetU8(t);
214 U8 flags2 = swf_GetU8(t);
215 U16 d = swf_GetU16(t);
216 id = (flags&PF_CHAR)?swf_GetU16(t):id;
221 swf_SetTagPos(t,oldTagPos);
226 static int swf_definingtagids[] =
232 ST_DEFINEMORPHSHAPE2,
242 ST_DEFINEBITSLOSSLESS,
243 ST_DEFINEBITSLOSSLESS2,
249 ST_DEFINEVIDEOSTREAM,
254 // tags which may be used inside a sprite definition
255 static int swf_spritetagids[] =
273 /* tags which add content or information to a character with a given ID */
274 static int swf_pseudodefiningtagids[] =
278 ST_DEFINEFONTALIGNZONES,
280 ST_DEFINEBUTTONCXFORM,
281 ST_DEFINEBUTTONSOUND,
282 ST_DEFINESCALINGGRID,
291 U8 swf_isAllowedSpriteTag(TAG * tag)
295 while(swf_spritetagids[t]>=0)
297 if(swf_spritetagids[t] == id)
304 U8 swf_isDefiningTag(TAG * tag)
308 while(swf_definingtagids[t]>=0)
310 if(swf_definingtagids[t] == id)
317 U8 swf_isPseudoDefiningTag(TAG * tag)
321 while(swf_pseudodefiningtagids[t]>=0)
323 if(swf_pseudodefiningtagids[t] == id)
330 int swf_GetDepth(TAG * t)
334 oldTagPos = swf_GetTagPos(t);
337 switch (swf_GetTagID(t))
338 { case ST_PLACEOBJECT:
339 case ST_REMOVEOBJECT:
341 depth = swf_GetU16(t);
343 case ST_REMOVEOBJECT2:
344 depth = swf_GetU16(t);
346 case ST_PLACEOBJECT2:
347 { U8 flags = swf_GetU8(t);
348 depth = swf_GetU16(t);
350 case ST_PLACEOBJECT3:
351 { U8 flags = swf_GetU8(t);
352 U8 flags2 = swf_GetU8(t);
353 depth = swf_GetU16(t);
357 depth = swf_GetU16(t);
360 swf_SetTagPos(t,oldTagPos);
364 void swf_SetDepth(TAG * t, U16 depth)
366 switch (swf_GetTagID(t))
367 { case ST_PLACEOBJECT:
368 case ST_REMOVEOBJECT:
369 PUT16(t->data, depth);
371 case ST_REMOVEOBJECT2:
372 PUT16(t->data, depth);
374 case ST_PLACEOBJECT2:
375 PUT16(&t->data[1], depth);
378 PUT16(t->data, depth);
381 fprintf(stderr, "rfxswf: Error: tag %d has no depth\n", t->id);
385 char* swf_GetName(TAG * t)
391 oldTagPos = swf_GetTagPos(t);
393 switch(swf_GetTagID(t))
396 name = (char*)&t->data[swf_GetTagPos(t)];
398 case ST_PLACEOBJECT3:
399 case ST_PLACEOBJECT2: {
400 U8 flags = swf_GetU8(t);
401 if(t->id == ST_PLACEOBJECT3)
403 swf_GetU16(t); //depth;
407 swf_GetMatrix(t, &m);
409 swf_GetCXForm(t, &c, 1);
412 if(flags&PF_CLIPDEPTH)
415 swf_ResetReadBits(t);
416 name = (char*)&t->data[swf_GetTagPos(t)];
421 swf_SetTagPos(t,oldTagPos);
425 /* used in enumerateUsedIDs */
426 void swf_GetMorphGradient(TAG * tag, GRADIENT * gradient1, GRADIENT * gradient2)
429 int num = swf_GetU8(tag) & 15;
430 if(gradient1) gradient1->num = num;
431 if(gradient2) gradient2->num = num;
434 gradient1->num = num;
435 gradient1->rgba = (RGBA*)rfx_calloc(sizeof(RGBA)*gradient1->num);
436 gradient1->ratios = (U8*)rfx_calloc(sizeof(gradient1->ratios[0])*gradient1->num);
439 gradient2->num = num;
440 gradient2->rgba = (RGBA*)rfx_calloc(sizeof(RGBA)*gradient2->num);
441 gradient2->ratios = (U8*)rfx_calloc(sizeof(gradient2->ratios[0])*gradient2->num);
448 ratio = swf_GetU8(tag);
449 swf_GetRGBA(tag, &color);
451 gradient1->ratios[t] = ratio;
452 gradient1->rgba[t] = color;
455 ratio = swf_GetU8(tag);
456 swf_GetRGBA(tag, &color);
458 gradient2->ratios[t] = ratio;
459 gradient2->rgba[t] = color;
464 #define DEBUG_ENUMERATE if(0)
465 //#define DEBUG_ENUMERATE
467 void enumerateUsedIDs_fillstyle(TAG * tag, int t, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
470 type = swf_GetU8(tag); //type
471 DEBUG_ENUMERATE printf("fill style %d) type=%02x (tagpos=%d)\n", t, type, tag->pos);
475 {swf_GetRGBA(tag, &color);if(morph) swf_GetRGBA(tag, NULL);}
477 {swf_GetRGB(tag, &color);if(morph) swf_GetRGB(tag, NULL);}
478 DEBUG_ENUMERATE printf(" %02x%02x%02x%02x\n", color.r,color.g,color.b,color.a);
480 else if(type == 0x10 || type == 0x12 || type == 0x13)
482 swf_ResetReadBits(tag);
484 swf_GetMatrix(tag, &m);
485 DEBUG_ENUMERATE swf_DumpMatrix(stdout, &m);
487 swf_GetMatrix(tag, &m);
488 DEBUG_ENUMERATE swf_DumpMatrix(stdout, &m);
490 swf_ResetReadBits(tag);
492 swf_GetMorphGradient(tag, NULL, NULL);
499 swf_GetGradient(tag, &g, /*alpha*/ num>=3?1:0);
500 DEBUG_ENUMERATE swf_DumpGradient(stdout, &g);
505 else if(type == 0x40 || type == 0x41 || type == 0x42 || type == 0x43)
507 swf_ResetReadBits(tag);
508 if(tag->data[tag->pos] != 0xff ||
509 tag->data[tag->pos+1] != 0xff)
510 (callback)(tag, tag->pos, callback_data);
513 swf_ResetReadBits(tag);
514 swf_GetMatrix(tag, NULL);
516 swf_GetMatrix(tag, NULL);
519 fprintf(stderr, "rfxswf:swftools.c Unknown fillstyle:0x%02x in tag %02d\n",type, tag->id);
523 void enumerateUsedIDs_linestyle(TAG * tag, int t, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
527 width = swf_GetU16(tag);
532 U16 flags = swf_GetU16(tag);
533 DEBUG_ENUMERATE printf("line style %d) flags: %08x\n", t, flags);
534 if((flags & 0x30) == 0x20) {
535 U16 miter = swf_GetU16(tag); // miter limit
536 DEBUG_ENUMERATE printf("line style %d) miter join: %08x\n", t, miter);
544 {swf_GetRGBA(tag, &color);if(morph) swf_GetRGBA(tag, NULL);}
546 {swf_GetRGB(tag, &color);if(morph) swf_GetRGB(tag, NULL);}
548 enumerateUsedIDs_fillstyle(tag, t, callback, callback_data, num, morph);
550 DEBUG_ENUMERATE printf("line style %d) width=%.2f color=%02x%02x%02x%02x \n", t, width/20.0, color.r,color.g,color.b,color.a);
553 void enumerateUsedIDs_styles(TAG * tag, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
557 count = swf_GetU8(tag);
558 if(count == 0xff && num>1) // defineshape2,3,4 only
559 count = swf_GetU16(tag);
561 DEBUG_ENUMERATE printf("%d fill styles\n", count);
564 enumerateUsedIDs_fillstyle(tag, t, callback, callback_data, num, morph);
566 swf_ResetReadBits(tag);
567 count = swf_GetU8(tag); // line style array
569 count = swf_GetU16(tag);
570 DEBUG_ENUMERATE printf("%d line styles\n", count);
573 enumerateUsedIDs_linestyle(tag, t, callback, callback_data, num, morph);
577 void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), void*callback_data)
580 swf_ResetReadBits(tag);
584 case ST_DEFINEBUTTONSOUND: {
586 callback(tag, tag->pos + base, callback_data);
589 callback(tag, tag->pos + base, callback_data);
590 swf_GetU16(tag); //sound id
591 flags = swf_GetU8(tag);
593 swf_GetU32(tag); // in point
595 swf_GetU32(tag); // out points
597 swf_GetU16(tag); // loop count
600 int npoints = swf_GetU8(tag);
602 for(s=0;s<npoints;s++)
611 case ST_DEFINEBUTTONCXFORM:
612 callback(tag, tag->pos + base, callback_data); //button id
615 case ST_EXPORTASSETS: {
616 int num = swf_GetU16(tag);
619 callback(tag, tag->pos + base, callback_data); //button id
620 swf_GetU16(tag); //id
621 while(swf_GetU8(tag)); //name
625 case ST_IMPORTASSETS:
626 case ST_IMPORTASSETS2: {
627 swf_GetString(tag); //count
628 swf_GetU8(tag); //reserved
629 swf_GetU8(tag); //reserved
630 int num = swf_GetU16(tag); //url
633 callback(tag, tag->pos + base, callback_data); //button id
634 swf_GetU16(tag); //id
635 while(swf_GetU8(tag)); //name
639 case ST_FREECHARACTER: /* unusual tags, which all start with an ID */
640 case ST_NAMECHARACTER:
641 case ST_DEFINEBINARY:
642 case ST_DEFINEFONTNAME:
643 case ST_GENERATORTEXT:
644 callback(tag, tag->pos + base, callback_data);
647 callback(tag, tag->pos + base, callback_data);
649 case ST_PLACEOBJECT2:
650 // only if placeflaghascharacter
651 if(!(tag->data[0]&2))
653 callback(tag, 3 + base, callback_data);
655 case ST_PLACEOBJECT3:
656 // only if placeflaghascharacter
657 if(!(tag->data[0]&2))
659 callback(tag, 4 + base, callback_data);
661 case ST_REMOVEOBJECT:
662 callback(tag, tag->pos + base, callback_data);
665 callback(tag, tag->pos + base, callback_data);
667 case ST_DEFINESPRITE: {
669 break; // sprite is expanded
671 swf_GetU16(tag); // id
672 swf_GetU16(tag); // framenum
675 U16 flags = swf_GetU16(tag);
678 TAG *tag2 = swf_InsertTag(NULL, id);
681 len = swf_GetU32(tag);
684 tag2->len = tag2->memsize = len;
685 tag2->data = (U8*)rfx_alloc(len);
686 memcpy(tag2->data, &tag->data[tag->pos], len);
687 /* I never saw recursive sprites, but they are (theoretically)
688 possible, so better add base here again */
689 enumerateUsedIDs(tag2, tag->pos + base, callback, callback_data);
690 swf_DeleteTag(0, tag2);
691 swf_GetBlock(tag, NULL, len);
695 case ST_DEFINEBUTTON2: // has some font ids in the button records
698 case ST_DEFINEBUTTON: {
699 swf_GetU16(tag); //button id
703 swf_GetU8(tag); //flag
704 offset = swf_GetU16(tag); //offset
708 U8 flags = swf_GetU8(tag);
711 callback(tag, tag->pos + base, callback_data);
712 swf_GetU16(tag); //char
713 swf_GetU16(tag); //layer
714 swf_ResetReadBits(tag);
715 swf_GetMatrix(tag, NULL);
717 swf_ResetReadBits(tag);
718 swf_GetCXForm(tag, NULL, 1);
721 U8 num = swf_GetU8(tag);
724 swf_DeleteFilter(swf_GetFilter(tag));
728 U8 blendmode = swf_GetU8(tag);
734 case ST_DEFINEEDITTEXT: {
736 swf_GetU16(tag); //id
737 swf_GetRect(tag, NULL); //bounding box
738 swf_ResetReadBits(tag);
739 flags1 = swf_GetU8(tag);
740 flags2 = swf_GetU8(tag);
742 callback(tag, tag->pos + base, callback_data);
747 case ST_DEFINETEXT: {
748 int glyphbits, advancebits;
750 id = swf_GetU16(tag); //id
751 swf_GetRect(tag, NULL); //bounding box
752 swf_ResetReadBits(tag);
753 swf_GetMatrix(tag, NULL); //matrix
754 swf_ResetReadBits(tag);
755 glyphbits = swf_GetU8(tag); //glyphbits
756 advancebits = swf_GetU8(tag); //advancebits
760 swf_ResetReadBits(tag);
761 flags = swf_GetBits(tag, 8);
764 swf_ResetReadBits(tag);
765 if(flags & 8) { // hasfont
766 callback(tag, tag->pos + base, callback_data);
767 id = swf_GetU16(tag);
769 if(flags & 4) { // hascolor
770 if(num==1) swf_GetRGB(tag, NULL);
771 else swf_GetRGBA(tag, NULL);
773 if(flags & 2) { //has x offset
774 swf_ResetReadBits(tag);
777 if(flags & 1) { //has y offset
778 swf_ResetReadBits(tag);
781 if(flags & 8) { //has height
782 swf_ResetReadBits(tag);
786 flags = swf_GetBits(tag, 8);
788 swf_ResetReadBits(tag);
789 for(t=0;t<flags;t++) {
790 swf_GetBits(tag, glyphbits);
791 swf_GetBits(tag, advancebits);
796 case ST_DEFINEFONTALIGNZONES:
797 case ST_DEFINESCALINGGRID:
799 case ST_CSMTEXTSETTINGS:
800 case ST_DEFINEFONTINFO:
801 case ST_DEFINEFONTINFO2:
803 callback(tag, tag->pos + base, callback_data);
805 case ST_DEFINEVIDEOSTREAM:
808 case ST_DOINITACTION:
809 callback(tag, tag->pos + base, callback_data);
812 case ST_DEFINEMORPHSHAPE2:
813 case ST_DEFINESHAPE4:
815 case ST_DEFINEMORPHSHAPE:
816 case ST_DEFINESHAPE3:
818 case ST_DEFINESHAPE2:
820 case ST_DEFINESHAPE: {
826 if(tag->id == ST_DEFINEMORPHSHAPE || tag->id==ST_DEFINEMORPHSHAPE2) {
831 id = swf_GetU16(tag); // id;
832 SRECT r={0,0,0,0},r2={0,0,0,0};
833 swf_GetRect(tag, &r); // shape bounds
835 swf_ResetReadBits(tag);
836 swf_GetRect(tag, NULL); // shape bounds2
838 swf_ResetReadBits(tag);
839 swf_GetRect(tag, NULL); // edge bounds1
843 swf_ResetReadBits(tag);
844 swf_GetRect(tag, &r2); // edge bounds
845 U8 flags = swf_GetU8(tag); // flags, &1: contains scaling stroke, &2: contains non-scaling stroke
846 DEBUG_ENUMERATE printf("flags: %02x (1=scaling strokes, 2=non-scaling strokes)\n", flags);
849 swf_GetU32(tag); //offset to endedges
852 DEBUG_ENUMERATE printf("Tag:%d Name:%s ID:%d\n", tag->id, swf_TagGetName(tag), id);
853 DEBUG_ENUMERATE printf("BBox %.2f %.2f %.2f %.2f\n", r.xmin/20.0,r.ymin/20.0,r.xmax/20.0,r.ymax/20.0);
854 DEBUG_ENUMERATE printf("BBox %.2f %.2f %.2f %.2f\n", r2.xmin/20.0,r2.ymin/20.0,r2.xmax/20.0,r2.ymax/20.0);
856 DEBUG_ENUMERATE printf("style tag pos: %d\n", tag->pos);
857 enumerateUsedIDs_styles(tag, callback, callback_data, num, morph);
858 DEBUG_ENUMERATE printf("-------\n");
859 swf_ResetReadBits(tag);
860 while(--numshapes>=0) /* morph shapes define two shapes */
862 DEBUG_ENUMERATE printf("shape:%d\n", numshapes);
863 fillbits = swf_GetBits(tag, 4);
864 linebits = swf_GetBits(tag, 4);
865 DEBUG_ENUMERATE printf("fillbits=%d linebits=%d\n", fillbits, linebits);
866 swf_ResetReadBits(tag);
870 flags = swf_GetBits(tag, 1);
871 if(!flags) { //style change
872 flags = swf_GetBits(tag, 5);
876 int n = swf_GetBits(tag, 5);
877 x = swf_GetBits(tag, n); //x
878 y = swf_GetBits(tag, n); //y
879 DEBUG_ENUMERATE printf("moveTo %.2f %.2f\n",x/20.0,y/20.0);
881 if(flags&2) { //fill0
883 fill0 = swf_GetBits(tag, fillbits);
884 DEBUG_ENUMERATE printf("fill0 %d\n", fill0);
886 if(flags&4) { //fill1
888 fill1 = swf_GetBits(tag, fillbits);
889 DEBUG_ENUMERATE printf("fill1 %d\n", fill1);
891 if(flags&8) { //linestyle
893 line = swf_GetBits(tag, linebits);
894 DEBUG_ENUMERATE printf("linestyle %d\n",line);
897 DEBUG_ENUMERATE printf("more fillstyles\n");
898 enumerateUsedIDs_styles(tag, callback, callback_data, num, 0);
899 fillbits = swf_GetBits(tag, 4);
900 linebits = swf_GetBits(tag, 4);
903 flags = swf_GetBits(tag, 1);
904 if(flags) { //straight edge
905 int n = swf_GetBits(tag, 4) + 2;
906 if(swf_GetBits(tag, 1)) { //line flag
907 x += swf_GetSBits(tag, n); //delta x
908 y += swf_GetSBits(tag, n); //delta y
909 DEBUG_ENUMERATE printf("lineTo %.2f %.2f\n",x/20.0,y/20.0);
911 int v=swf_GetBits(tag, 1);
913 d = swf_GetSBits(tag, n); //vert/horz
918 DEBUG_ENUMERATE printf("lineTo %.2f %.2f (%s)\n",x/20.0,y/20.0, v?"vertical":"horizontal");
920 } else { //curved edge
921 int n = swf_GetBits(tag, 4) + 2;
923 x1 = swf_GetSBits(tag, n);
924 y1 = swf_GetSBits(tag, n);
925 x2 = swf_GetSBits(tag, n);
926 y2 = swf_GetSBits(tag, n);
927 DEBUG_ENUMERATE printf("splineTo %.2f %.2f %.2f %.2f\n", x1/20.0, y1/20.0, x2/20.0, y2/20.0);
939 void callbackCount(TAG * t,int pos, void*ptr)
942 DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
945 void callbackFillin(TAG * t,int pos, void*ptr)
949 DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
952 int swf_GetNumUsedIDs(TAG * t)
955 enumerateUsedIDs(t, 0, callbackCount, &num);
959 void swf_GetUsedIDs(TAG * t, int * positions)
961 int * ptr = positions;
962 enumerateUsedIDs(t, 0, callbackFillin, &ptr);
965 void swf_Relocate (SWF*swf, char*bitmap)
969 memset(slaveids, -1, sizeof(slaveids));
977 if(swf_isDefiningTag(tag))
982 id = swf_GetDefineID(tag); //own id
984 if(!bitmap[id]) { //free
989 for (t=1;t<65536;t++)
999 slaveids[id] = newid;
1001 swf_SetDefineID(tag, newid);
1004 num = swf_GetNumUsedIDs(tag);
1006 ptr = (int*)rfx_alloc(sizeof(int)*num);
1007 swf_GetUsedIDs(tag, ptr);
1009 for(t=0;t<num;t++) {
1010 int id = GET16(&tag->data[ptr[t]]);
1011 if(slaveids[id]<0) {
1012 fprintf(stderr, "swf_Relocate: Mapping id (%d) never encountered before in %s\n", id,
1013 swf_TagGetName(tag));
1016 PUT16(&tag->data[ptr[t]], id);
1025 void swf_Relocate2(SWF*swf, int*id2id)
1028 tag = swf->firstTag;
1030 if(swf_isDefiningTag(tag)) {
1031 int id = swf_GetDefineID(tag);
1034 swf_SetDefineID(tag, id);
1037 int num = swf_GetNumUsedIDs(tag);
1041 ptr = (int*)rfx_alloc(sizeof(int)*num);
1042 swf_GetUsedIDs(tag, ptr);
1043 for(t=0;t<num;t++) {
1044 int id = GET16(&tag->data[ptr[t]]);
1047 PUT16(&tag->data[ptr[t]], id);
1054 void swf_RelocateDepth(SWF*swf, char*bitmap)
1058 tag = swf->firstTag;
1059 for(nr=65535;nr>=0;nr--) {
1063 // now nr is the highest used depth. So we start
1064 // assigning depths at nr+1
1070 /* TODO * clip depths
1073 if(tag->id == ST_PLACEOBJECT2) {
1075 swf_GetPlaceObject(tag, &obj);
1077 int newdepth = obj.clipdepth+nr;
1078 if(newdepth>65535) {
1079 fprintf(stderr, "Couldn't relocate depths: too large values\n");
1082 obj.clipdepth = newdepth;
1083 swf_ResetTag(tag, ST_PLACEOBJECT2);
1084 swf_SetPlaceObject(tag, &obj);
1086 swf_PlaceObjectFree(&obj);
1089 depth = swf_GetDepth(tag);
1091 int newdepth = depth+nr;
1092 if(newdepth>65535) {
1093 fprintf(stderr, "Couldn't relocate depths: too large values\n");
1096 swf_SetDepth(tag, newdepth);
1102 U8 swf_isShapeTag(TAG*tag)
1104 if(tag->id == ST_DEFINESHAPE ||
1105 tag->id == ST_DEFINESHAPE2 ||
1106 tag->id == ST_DEFINESHAPE3 ||
1107 tag->id == ST_DEFINESHAPE4)
1112 U8 swf_isPlaceTag(TAG*tag)
1114 if(tag->id == ST_PLACEOBJECT ||
1115 tag->id == ST_PLACEOBJECT2 ||
1116 tag->id == ST_PLACEOBJECT3)
1120 U8 swf_isTextTag(TAG*tag)
1122 if(tag->id == ST_DEFINETEXT ||
1123 tag->id == ST_DEFINETEXT2)
1128 U8 swf_isFontTag(TAG*tag)
1130 if(tag->id == ST_DEFINEFONT ||
1131 tag->id == ST_DEFINEFONT2 ||
1132 tag->id == ST_DEFINEFONTINFO)
1137 U8 swf_isImageTag(TAG*tag)
1139 if(tag->id == ST_DEFINEBITSJPEG ||
1140 tag->id == ST_DEFINEBITSJPEG2 ||
1141 tag->id == ST_DEFINEBITSJPEG3 ||
1142 tag->id == ST_DEFINEBITSLOSSLESS ||
1143 tag->id == ST_DEFINEBITSLOSSLESS2)
1148 TAG* swf_Concatenate (TAG*list1,TAG*list2)
1150 TAG*tag=0,*lasttag=0;
1152 char depthmap[65536];
1154 memset(bitmap, 0, sizeof(bitmap));
1155 memset(depthmap, 0, sizeof(depthmap));
1156 memset(&swf1, 0, sizeof(swf1));
1157 memset(&swf2, 0, sizeof(swf2));
1159 swf1.firstTag = list1;
1161 swf2.firstTag = list2;
1166 if(!swf_isDefiningTag(tag)) {
1167 int id = swf_GetDefineID(tag);
1170 if(tag->id == ST_PLACEOBJECT ||
1171 tag->id == ST_PLACEOBJECT2) {
1172 int depth = swf_GetDepth(tag);
1173 depthmap[depth] = 1;
1175 if(tag->id == ST_REMOVEOBJECT ||
1176 tag->id == ST_REMOVEOBJECT2) {
1177 int depth = swf_GetDepth(tag);
1178 depthmap[depth] = 0;
1183 swf_Relocate(&swf2, bitmap);
1184 swf_RelocateDepth(&swf2, depthmap);
1185 lasttag->next = swf2.firstTag;
1186 swf2.firstTag->prev = lasttag;
1188 return swf1.firstTag;
1191 static int tagHash(TAG*tag)
1194 unsigned int a = 0x6b973e5a;
1195 /* start at pos 2, as 0 and 1 are the id */
1196 for(t=2;t<tag->len;t++) {
1199 a += tag->data[t]*0xefbc35a5*b*(t+1);
1201 return a&0x7fffffff; //always return positive number
1204 void swf_Optimize(SWF*swf)
1206 const int hash_size = 131072;
1207 char* dontremap = (char*)rfx_calloc(sizeof(char)*65536);
1208 U16* remap = (U16*)rfx_alloc(sizeof(U16)*65536);
1209 TAG* id2tag = (TAG*)rfx_calloc(sizeof(TAG*)*65536);
1210 TAG** hashmap = (TAG**)rfx_calloc(sizeof(TAG*)*hash_size);
1213 for(t=0;t<65536;t++) {
1219 tag = swf->firstTag;
1221 /* make sure we don't remap to this tag,
1222 as it might have different "helper tags"
1223 FIXME: a better way would be to compare
1224 the helper tags, too.
1226 if(swf_isPseudoDefiningTag(tag) &&
1227 tag->id != ST_NAMECHARACTER) {
1228 dontremap[swf_GetDefineID(tag)] = 1;
1232 tag = swf->firstTag;
1234 TAG*next = tag->next;
1237 int num = swf_GetNumUsedIDs(tag);
1238 int*positions = (int*)rfx_alloc(sizeof(int)*num);
1240 swf_GetUsedIDs(tag, positions);
1241 for(t=0;t<num;t++) {
1242 int id = GET16(&tag->data[positions[t]]);
1244 PUT16(&tag->data[positions[t]], id);
1246 rfx_free(positions);
1248 /* now look for previous tags with the same
1250 if(swf_isDefiningTag(tag)) {
1252 int id = swf_GetDefineID(tag);
1253 int hash = tagHash(tag);
1256 while((tag2 = hashmap[hash%hash_size])) {
1257 if(tag2 != (TAG*)0 && tag->len == tag2->len) {
1258 if(memcmp(&tag->data[2],&tag2->data[2],tag->len-2) == 0) {
1266 while(hashmap[hash%hash_size]) hash++;
1267 hashmap[hash%hash_size] = tag;
1269 /* we found two identical tags- remap one
1271 remap[id] = swf_GetDefineID(tag2);
1272 swf_DeleteTag(swf, tag);
1274 } else if(swf_isPseudoDefiningTag(tag)) {
1275 int id = swf_GetDefineID(tag);
1277 /* if this tag was remapped, we don't
1278 need the helper tag anymore. Discard
1280 swf_DeleteTag(swf, tag);
1287 rfx_free(dontremap);
1293 void swf_SetDefineBBox(TAG * tag, SRECT newbbox)
1297 swf_SetTagPos(tag,0);
1299 switch (swf_GetTagID(tag))
1301 case ST_DEFINESHAPE:
1302 case ST_DEFINESHAPE2:
1303 case ST_DEFINESHAPE3:
1304 case ST_DEFINEEDITTEXT:
1306 case ST_DEFINETEXT2:
1307 case ST_DEFINEVIDEOSTREAM: {
1308 U32 after_bbox_offset = 0, len;
1310 id = swf_GetU16(tag);
1311 swf_GetRect(tag, &b1);
1312 swf_ResetReadBits(tag);
1313 after_bbox_offset = tag->pos;
1314 len = tag->len - after_bbox_offset;
1315 data = (U8*)malloc(len);
1316 memcpy(data, &tag->data[after_bbox_offset], len);
1319 swf_SetRect(tag, &newbbox);
1320 swf_SetBlock(tag, data, len);
1322 tag->pos = tag->readBit = 0;
1326 fprintf(stderr, "rfxswf: Tag %d (%s) has no bbox\n", tag->id, swf_TagGetName(tag));
1330 RGBA swf_GetSWFBackgroundColor(SWF*swf)
1332 TAG*t=swf->firstTag;
1334 color.r = color.b = color.g = 0;
1337 if(t->id == ST_SETBACKGROUNDCOLOR) {
1338 swf_SetTagPos(t, 0);
1339 color.r = swf_GetU8(t);
1340 color.g = swf_GetU8(t);
1341 color.b = swf_GetU8(t);