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
27 SFIXED RFXSWF_SP(SFIXED a1,SFIXED a2,SFIXED b1,SFIXED b2)
28 { S64 a = ((S64)a1*(S64)b1+(S64)a2*(S64)b2)>>16;
29 SFIXED result = (SFIXED)(a);
31 fprintf(stderr, "Warning: overflow in matrix multiplication");
34 SFIXED RFXSWF_QFIX(int zaehler,int nenner) // bildet Quotient von zwei INTs in SFIXED
35 { S64 z = zaehler<<16;
36 S64 a = z/(S64)nenner;
41 MATRIX * swf_MatrixJoin(MATRIX * d,MATRIX * s1,MATRIX * s2)
44 if (!s1) return (s2)?(MATRIX *)memcpy(d,s2,sizeof(MATRIX)):NULL;
45 if (!s2) return (MATRIX *)memcpy(d,s1,sizeof(MATRIX));
47 d->tx = s1->tx + RFXSWF_SP(s1->sx,s1->r1,s2->tx,s2->ty);
48 d->ty = s1->ty + RFXSWF_SP(s1->r0,s1->sy,s2->tx,s2->ty);
50 d->sx = RFXSWF_SP(s1->sx,s1->r1,s2->sx,s2->r0);
51 d->r0 = RFXSWF_SP(s1->r0,s1->sy,s2->sx,s2->r0);
53 d->r1 = RFXSWF_SP(s1->sx,s1->r1,s2->r1,s2->sy);
54 d->sy = RFXSWF_SP(s1->r0,s1->sy,s2->r1,s2->sy);
61 MATRIX * swf_MatrixMapTriangle(MATRIX * m,int dx,int dy,int x0,int y0,
62 int x1,int y1,int x2,int y2)
69 if ((!dx)||(!dy)) return NULL; // check DIV by zero
73 m->sx = RFXSWF_QFIX(dx1,dx);
74 m->sy = RFXSWF_QFIX(dy2,dy);
75 m->r0 = RFXSWF_QFIX(dy1,dx);
76 m->r1 = RFXSWF_QFIX(dx2,dy);
81 void swf_SetDefineID(TAG * tag, U16 newid)
83 int oldlen = tag->len;
85 swf_SetU16(tag, newid); /* set defining ID */
89 U16 swf_GetDefineID(TAG * t)
94 oldTagPos = swf_GetTagPos(t);
97 switch (swf_GetTagID(t))
98 { case ST_DEFINESHAPE:
100 case ST_DEFINESHAPE3:
101 case ST_DEFINESHAPE4:
102 case ST_DEFINEMORPHSHAPE:
103 case ST_DEFINEMORPHSHAPE2:
104 case ST_DEFINEEDITTEXT:
106 case ST_DEFINEBITSJPEG2:
107 case ST_DEFINEBITSJPEG3:
108 case ST_DEFINEBITSLOSSLESS:
109 case ST_DEFINEBITSLOSSLESS2:
110 case ST_DEFINESCALINGGRID: //pseudodefine
111 case ST_DEFINEBUTTON:
112 case ST_DEFINEBUTTON2:
113 case ST_DEFINEBUTTONCXFORM: //pseudodefine
114 case ST_DEFINEBUTTONSOUND: //pseudodefine
115 case ST_CSMTEXTSETTINGS: //pseudodefine
119 case ST_DEFINEFONTINFO: //pseudodefine
120 case ST_DEFINEFONTINFO2: //pseudodefine
121 case ST_DEFINEFONTALIGNZONES: //pseudodefine
122 case ST_DEFINEFONTNAME: //pseudodefine
126 case ST_DEFINESPRITE:
128 case ST_DEFINEVIDEOSTREAM:
129 case ST_GLYPHNAMES: //pseudodefine
130 case ST_VIDEOFRAME: //pseudodefine
131 case ST_NAMECHARACTER: //pseudodefine
132 case ST_DOINITACTION: //pseudodefine
136 fprintf(stderr, "rfxswf: Error: tag %d (%s) has no id\n", t->id, swf_TagGetName(t));
139 swf_SetTagPos(t,oldTagPos);
144 SRECT swf_GetDefineBBox(TAG * t)
149 memset(&b1, 0, sizeof(b1));
151 oldTagPos = swf_GetTagPos(t);
156 switch (swf_GetTagID(t))
157 { case ST_DEFINESHAPE:
158 case ST_DEFINESHAPE2:
159 case ST_DEFINESHAPE3:
160 case ST_DEFINESHAPE4:
161 case ST_DEFINEEDITTEXT:
164 case ST_DEFINEVIDEOSTREAM:
168 case ST_DEFINEMORPHSHAPE:
172 swf_ExpandRect2(&b1, &b2);
174 case ST_DEFINEBITSLOSSLESS:
175 case ST_DEFINEBITSLOSSLESS2:
177 case ST_DEFINEBITSJPEG2:
178 case ST_DEFINEBITSJPEG3:
183 swf_SetTagPos(t,oldTagPos);
188 U16 swf_GetPlaceID(TAG * t)
193 oldTagPos = swf_GetTagPos(t);
196 switch (swf_GetTagID(t))
197 { case ST_PLACEOBJECT:
198 case ST_REMOVEOBJECT:
199 case ST_FREECHARACTER:
204 case ST_PLACEOBJECT2:
205 { U8 flags = swf_GetU8(t);
206 U16 d = swf_GetU16(t);
207 id = (flags&PF_CHAR)?swf_GetU16(t):id;
209 case ST_PLACEOBJECT3:
210 { U8 flags = swf_GetU8(t);
211 U8 flags2 = swf_GetU8(t);
212 U16 d = swf_GetU16(t);
213 id = (flags&PF_CHAR)?swf_GetU16(t):id;
218 swf_SetTagPos(t,oldTagPos);
223 static int swf_definingtagids[] =
229 ST_DEFINEMORPHSHAPE2,
239 ST_DEFINEBITSLOSSLESS,
240 ST_DEFINEBITSLOSSLESS2,
246 ST_DEFINEVIDEOSTREAM,
251 // tags which may be used inside a sprite definition
252 static int swf_spritetagids[] =
270 /* tags which add content or information to a character with a given ID */
271 static int swf_pseudodefiningtagids[] =
275 ST_DEFINEFONTALIGNZONES,
277 ST_DEFINEBUTTONCXFORM,
278 ST_DEFINEBUTTONSOUND,
279 ST_DEFINESCALINGGRID,
288 U8 swf_isAllowedSpriteTag(TAG * tag)
292 while(swf_spritetagids[t]>=0)
294 if(swf_spritetagids[t] == id)
301 U8 swf_isDefiningTag(TAG * tag)
305 while(swf_definingtagids[t]>=0)
307 if(swf_definingtagids[t] == id)
314 U8 swf_isPseudoDefiningTag(TAG * tag)
318 while(swf_pseudodefiningtagids[t]>=0)
320 if(swf_pseudodefiningtagids[t] == id)
327 int swf_GetDepth(TAG * t)
331 oldTagPos = swf_GetTagPos(t);
334 switch (swf_GetTagID(t))
335 { case ST_PLACEOBJECT:
336 case ST_REMOVEOBJECT:
338 depth = swf_GetU16(t);
340 case ST_REMOVEOBJECT2:
341 depth = swf_GetU16(t);
343 case ST_PLACEOBJECT2:
344 { U8 flags = swf_GetU8(t);
345 depth = swf_GetU16(t);
347 case ST_PLACEOBJECT3:
348 { U8 flags = swf_GetU8(t);
349 U8 flags2 = swf_GetU8(t);
350 depth = swf_GetU16(t);
354 depth = swf_GetU16(t);
357 swf_SetTagPos(t,oldTagPos);
361 void swf_SetDepth(TAG * t, U16 depth)
363 switch (swf_GetTagID(t))
364 { case ST_PLACEOBJECT:
365 case ST_REMOVEOBJECT:
366 PUT16(t->data, depth);
368 case ST_REMOVEOBJECT2:
369 PUT16(t->data, depth);
371 case ST_PLACEOBJECT2:
372 PUT16(&t->data[1], depth);
375 PUT16(t->data, depth);
378 fprintf(stderr, "rfxswf: Error: tag %d has no depth\n", t->id);
382 char* swf_GetName(TAG * t)
388 oldTagPos = swf_GetTagPos(t);
390 switch(swf_GetTagID(t))
393 name = (char*)&t->data[swf_GetTagPos(t)];
395 case ST_PLACEOBJECT3:
396 case ST_PLACEOBJECT2: {
397 U8 flags = swf_GetU8(t);
398 if(t->id == ST_PLACEOBJECT3)
400 swf_GetU16(t); //depth;
404 swf_GetMatrix(t, &m);
406 swf_GetCXForm(t, &c, 1);
409 if(flags&PF_CLIPDEPTH)
412 swf_ResetReadBits(t);
413 name = (char*)&t->data[swf_GetTagPos(t)];
418 swf_SetTagPos(t,oldTagPos);
422 /* used in enumerateUsedIDs */
423 void swf_GetMorphGradient(TAG * tag, GRADIENT * gradient1, GRADIENT * gradient2)
426 int num = swf_GetU8(tag) & 15;
427 if(gradient1) gradient1->num = num;
428 if(gradient2) gradient2->num = num;
431 gradient1->num = num;
432 gradient1->rgba = (RGBA*)rfx_calloc(sizeof(RGBA)*gradient1->num);
433 gradient1->ratios = (U8*)rfx_calloc(sizeof(gradient1->ratios[0])*gradient1->num);
436 gradient2->num = num;
437 gradient2->rgba = (RGBA*)rfx_calloc(sizeof(RGBA)*gradient2->num);
438 gradient2->ratios = (U8*)rfx_calloc(sizeof(gradient2->ratios[0])*gradient2->num);
445 ratio = swf_GetU8(tag);
446 swf_GetRGBA(tag, &color);
448 gradient1->ratios[t] = ratio;
449 gradient1->rgba[t] = color;
452 ratio = swf_GetU8(tag);
453 swf_GetRGBA(tag, &color);
455 gradient2->ratios[t] = ratio;
456 gradient2->rgba[t] = color;
461 #define DEBUG_ENUMERATE if(0)
462 //#define DEBUG_ENUMERATE
464 void enumerateUsedIDs_fillstyle(TAG * tag, int t, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
467 type = swf_GetU8(tag); //type
468 DEBUG_ENUMERATE printf("fill style %d) type=%02x (tagpos=%d)\n", t, type, tag->pos);
472 {swf_GetRGBA(tag, &color);if(morph) swf_GetRGBA(tag, NULL);}
474 {swf_GetRGB(tag, &color);if(morph) swf_GetRGB(tag, NULL);}
475 DEBUG_ENUMERATE printf(" %02x%02x%02x%02x\n", color.r,color.g,color.b,color.a);
477 else if(type == 0x10 || type == 0x12 || type == 0x13)
479 swf_ResetReadBits(tag);
481 swf_GetMatrix(tag, &m);
482 DEBUG_ENUMERATE swf_DumpMatrix(stdout, &m);
484 swf_GetMatrix(tag, &m);
485 DEBUG_ENUMERATE swf_DumpMatrix(stdout, &m);
487 swf_ResetReadBits(tag);
489 swf_GetMorphGradient(tag, NULL, NULL);
496 swf_GetGradient(tag, &g, /*alpha*/ num>=3?1:0);
497 DEBUG_ENUMERATE swf_DumpGradient(stdout, &g);
502 else if(type == 0x40 || type == 0x41 || type == 0x42 || type == 0x43)
504 swf_ResetReadBits(tag);
505 if(tag->data[tag->pos] != 0xff ||
506 tag->data[tag->pos+1] != 0xff)
507 (callback)(tag, tag->pos, callback_data);
510 swf_ResetReadBits(tag);
511 swf_GetMatrix(tag, NULL);
513 swf_GetMatrix(tag, NULL);
516 fprintf(stderr, "rfxswf:swftools.c Unknown fillstyle:0x%02x in tag %02d\n",type, tag->id);
520 void enumerateUsedIDs_linestyle(TAG * tag, int t, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
524 width = swf_GetU16(tag);
529 U16 flags = swf_GetU16(tag);
530 DEBUG_ENUMERATE printf("line style %d) flags: %08x\n", t, flags);
531 if((flags & 0x30) == 0x20) {
532 U16 miter = swf_GetU16(tag); // miter limit
533 DEBUG_ENUMERATE printf("line style %d) miter join: %08x\n", t, miter);
541 {swf_GetRGBA(tag, &color);if(morph) swf_GetRGBA(tag, NULL);}
543 {swf_GetRGB(tag, &color);if(morph) swf_GetRGB(tag, NULL);}
545 enumerateUsedIDs_fillstyle(tag, t, callback, callback_data, num, morph);
547 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);
550 void enumerateUsedIDs_styles(TAG * tag, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
554 count = swf_GetU8(tag);
555 if(count == 0xff && num>1) // defineshape2,3,4 only
556 count = swf_GetU16(tag);
558 DEBUG_ENUMERATE printf("%d fill styles\n", count);
561 enumerateUsedIDs_fillstyle(tag, t, callback, callback_data, num, morph);
563 swf_ResetReadBits(tag);
564 count = swf_GetU8(tag); // line style array
566 count = swf_GetU16(tag);
567 DEBUG_ENUMERATE printf("%d line styles\n", count);
570 enumerateUsedIDs_linestyle(tag, t, callback, callback_data, num, morph);
574 void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), void*callback_data)
577 swf_ResetReadBits(tag);
581 case ST_DEFINEBUTTONSOUND: {
583 callback(tag, tag->pos + base, callback_data);
586 callback(tag, tag->pos + base, callback_data);
587 swf_GetU16(tag); //sound id
588 flags = swf_GetU8(tag);
590 swf_GetU32(tag); // in point
592 swf_GetU32(tag); // out points
594 swf_GetU16(tag); // loop count
597 int npoints = swf_GetU8(tag);
599 for(s=0;s<npoints;s++)
608 case ST_DEFINEBUTTONCXFORM:
609 callback(tag, tag->pos + base, callback_data); //button id
612 case ST_EXPORTASSETS: {
613 int num = swf_GetU16(tag);
616 callback(tag, tag->pos + base, callback_data); //button id
617 swf_GetU16(tag); //id
618 while(swf_GetU8(tag)); //name
622 case ST_IMPORTASSETS:
623 case ST_IMPORTASSETS2: {
624 swf_GetString(tag); //count
625 swf_GetU8(tag); //reserved
626 swf_GetU8(tag); //reserved
627 int num = swf_GetU16(tag); //url
630 callback(tag, tag->pos + base, callback_data); //button id
631 swf_GetU16(tag); //id
632 while(swf_GetU8(tag)); //name
636 case ST_FREECHARACTER: /* unusual tags, which all start with an ID */
637 case ST_NAMECHARACTER:
638 case ST_DEFINEBINARY:
639 case ST_DEFINEFONTNAME:
640 case ST_GENERATORTEXT:
641 callback(tag, tag->pos + base, callback_data);
644 callback(tag, tag->pos + base, callback_data);
646 case ST_PLACEOBJECT2:
647 // only if placeflaghascharacter
648 if(!(tag->data[0]&2))
650 callback(tag, 3 + base, callback_data);
652 case ST_PLACEOBJECT3:
653 // only if placeflaghascharacter
654 if(!(tag->data[0]&2))
656 callback(tag, 4 + base, callback_data);
658 case ST_REMOVEOBJECT:
659 callback(tag, tag->pos + base, callback_data);
662 callback(tag, tag->pos + base, callback_data);
664 case ST_DEFINESPRITE: {
666 break; // sprite is expanded
668 swf_GetU16(tag); // id
669 swf_GetU16(tag); // framenum
672 U16 flags = swf_GetU16(tag);
675 TAG *tag2 = swf_InsertTag(NULL, id);
678 len = swf_GetU32(tag);
681 tag2->len = tag2->memsize = len;
682 tag2->data = (U8*)rfx_alloc(len);
683 memcpy(tag2->data, &tag->data[tag->pos], len);
684 /* I never saw recursive sprites, but they are (theoretically)
685 possible, so better add base here again */
686 enumerateUsedIDs(tag2, tag->pos + base, callback, callback_data);
688 swf_GetBlock(tag, NULL, len);
692 case ST_DEFINEBUTTON2: // has some font ids in the button records
695 case ST_DEFINEBUTTON: {
696 swf_GetU16(tag); //button id
700 swf_GetU8(tag); //flag
701 offset = swf_GetU16(tag); //offset
705 U8 flags = swf_GetU8(tag);
708 callback(tag, tag->pos + base, callback_data);
709 swf_GetU16(tag); //char
710 swf_GetU16(tag); //layer
711 swf_ResetReadBits(tag);
712 swf_GetMatrix(tag, NULL);
714 swf_ResetReadBits(tag);
715 swf_GetCXForm(tag, NULL, 1);
718 U8 num = swf_GetU8(tag);
721 swf_DeleteFilter(swf_GetFilter(tag));
725 U8 blendmode = swf_GetU8(tag);
731 case ST_DEFINEEDITTEXT: {
733 swf_GetU16(tag); //id
734 swf_GetRect(tag, NULL); //bounding box
735 swf_ResetReadBits(tag);
736 flags1 = swf_GetU8(tag);
737 flags2 = swf_GetU8(tag);
739 callback(tag, tag->pos + base, callback_data);
744 case ST_DEFINETEXT: {
745 int glyphbits, advancebits;
747 id = swf_GetU16(tag); //id
748 swf_GetRect(tag, NULL); //bounding box
749 swf_ResetReadBits(tag);
750 swf_GetMatrix(tag, NULL); //matrix
751 swf_ResetReadBits(tag);
752 glyphbits = swf_GetU8(tag); //glyphbits
753 advancebits = swf_GetU8(tag); //advancebits
757 swf_ResetReadBits(tag);
758 flags = swf_GetBits(tag, 8);
761 swf_ResetReadBits(tag);
762 if(flags & 8) { // hasfont
763 callback(tag, tag->pos + base, callback_data);
764 id = swf_GetU16(tag);
766 if(flags & 4) { // hascolor
767 if(num==1) swf_GetRGB(tag, NULL);
768 else swf_GetRGBA(tag, NULL);
770 if(flags & 2) { //has x offset
771 swf_ResetReadBits(tag);
774 if(flags & 1) { //has y offset
775 swf_ResetReadBits(tag);
778 if(flags & 8) { //has height
779 swf_ResetReadBits(tag);
783 flags = swf_GetBits(tag, 8);
785 swf_ResetReadBits(tag);
786 for(t=0;t<flags;t++) {
787 swf_GetBits(tag, glyphbits);
788 swf_GetBits(tag, advancebits);
793 case ST_DEFINEFONTALIGNZONES:
794 case ST_DEFINESCALINGGRID:
796 case ST_CSMTEXTSETTINGS:
797 case ST_DEFINEFONTINFO:
798 case ST_DEFINEFONTINFO2:
800 callback(tag, tag->pos + base, callback_data);
802 case ST_DEFINEVIDEOSTREAM:
805 case ST_DOINITACTION:
806 callback(tag, tag->pos + base, callback_data);
809 case ST_DEFINEMORPHSHAPE2:
810 case ST_DEFINESHAPE4:
812 case ST_DEFINEMORPHSHAPE:
813 case ST_DEFINESHAPE3:
815 case ST_DEFINESHAPE2:
817 case ST_DEFINESHAPE: {
823 if(tag->id == ST_DEFINEMORPHSHAPE || tag->id==ST_DEFINEMORPHSHAPE2) {
828 id = swf_GetU16(tag); // id;
829 SRECT r={0,0,0,0},r2={0,0,0,0};
830 swf_GetRect(tag, &r); // shape bounds
832 swf_ResetReadBits(tag);
833 swf_GetRect(tag, NULL); // shape bounds2
835 swf_ResetReadBits(tag);
836 swf_GetRect(tag, NULL); // edge bounds1
840 swf_ResetReadBits(tag);
841 swf_GetRect(tag, &r2); // edge bounds
842 U8 flags = swf_GetU8(tag); // flags, &1: contains scaling stroke, &2: contains non-scaling stroke
843 DEBUG_ENUMERATE printf("flags: %02x (1=scaling strokes, 2=non-scaling strokes)\n", flags);
846 swf_GetU32(tag); //offset to endedges
849 DEBUG_ENUMERATE printf("Tag:%d Name:%s ID:%d\n", tag->id, swf_TagGetName(tag), id);
850 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);
851 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);
853 DEBUG_ENUMERATE printf("style tag pos: %d\n", tag->pos);
854 enumerateUsedIDs_styles(tag, callback, callback_data, num, morph);
855 DEBUG_ENUMERATE printf("-------\n");
856 swf_ResetReadBits(tag);
857 while(--numshapes>=0) /* morph shapes define two shapes */
859 DEBUG_ENUMERATE printf("shape:%d\n", numshapes);
860 fillbits = swf_GetBits(tag, 4);
861 linebits = swf_GetBits(tag, 4);
862 DEBUG_ENUMERATE printf("fillbits=%d linebits=%d\n", fillbits, linebits);
863 swf_ResetReadBits(tag);
867 flags = swf_GetBits(tag, 1);
868 if(!flags) { //style change
869 flags = swf_GetBits(tag, 5);
873 int n = swf_GetBits(tag, 5);
874 x = swf_GetBits(tag, n); //x
875 y = swf_GetBits(tag, n); //y
876 DEBUG_ENUMERATE printf("moveTo %.2f %.2f\n",x/20.0,y/20.0);
878 if(flags&2) { //fill0
880 fill0 = swf_GetBits(tag, fillbits);
881 DEBUG_ENUMERATE printf("fill0 %d\n", fill0);
883 if(flags&4) { //fill1
885 fill1 = swf_GetBits(tag, fillbits);
886 DEBUG_ENUMERATE printf("fill1 %d\n", fill1);
888 if(flags&8) { //linestyle
890 line = swf_GetBits(tag, linebits);
891 DEBUG_ENUMERATE printf("linestyle %d\n",line);
894 DEBUG_ENUMERATE printf("more fillstyles\n");
895 enumerateUsedIDs_styles(tag, callback, callback_data, num, 0);
896 fillbits = swf_GetBits(tag, 4);
897 linebits = swf_GetBits(tag, 4);
900 flags = swf_GetBits(tag, 1);
901 if(flags) { //straight edge
902 int n = swf_GetBits(tag, 4) + 2;
903 if(swf_GetBits(tag, 1)) { //line flag
904 x += swf_GetSBits(tag, n); //delta x
905 y += swf_GetSBits(tag, n); //delta y
906 DEBUG_ENUMERATE printf("lineTo %.2f %.2f\n",x/20.0,y/20.0);
908 int v=swf_GetBits(tag, 1);
910 d = swf_GetSBits(tag, n); //vert/horz
915 DEBUG_ENUMERATE printf("lineTo %.2f %.2f (%s)\n",x/20.0,y/20.0, v?"vertical":"horizontal");
917 } else { //curved edge
918 int n = swf_GetBits(tag, 4) + 2;
920 x1 = swf_GetSBits(tag, n);
921 y1 = swf_GetSBits(tag, n);
922 x2 = swf_GetSBits(tag, n);
923 y2 = swf_GetSBits(tag, n);
924 DEBUG_ENUMERATE printf("splineTo %.2f %.2f %.2f %.2f\n", x1/20.0, y1/20.0, x2/20.0, y2/20.0);
936 void callbackCount(TAG * t,int pos, void*ptr)
939 DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
942 void callbackFillin(TAG * t,int pos, void*ptr)
946 DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
949 int swf_GetNumUsedIDs(TAG * t)
952 enumerateUsedIDs(t, 0, callbackCount, &num);
956 void swf_GetUsedIDs(TAG * t, int * positions)
958 int * ptr = positions;
959 enumerateUsedIDs(t, 0, callbackFillin, &ptr);
962 void swf_Relocate (SWF*swf, char*bitmap)
966 memset(slaveids, -1, sizeof(slaveids));
974 if(swf_isDefiningTag(tag))
979 id = swf_GetDefineID(tag); //own id
981 if(!bitmap[id]) { //free
986 for (t=1;t<65536;t++)
996 slaveids[id] = newid;
998 swf_SetDefineID(tag, newid);
1001 num = swf_GetNumUsedIDs(tag);
1003 ptr = (int*)rfx_alloc(sizeof(int)*num);
1004 swf_GetUsedIDs(tag, ptr);
1006 for(t=0;t<num;t++) {
1007 int id = GET16(&tag->data[ptr[t]]);
1008 if(slaveids[id]<0) {
1009 fprintf(stderr, "swf_Relocate: Mapping id (%d) never encountered before in %s\n", id,
1010 swf_TagGetName(tag));
1013 PUT16(&tag->data[ptr[t]], id);
1022 void swf_Relocate2(SWF*swf, int*id2id)
1025 tag = swf->firstTag;
1027 if(swf_isDefiningTag(tag)) {
1028 int id = swf_GetDefineID(tag);
1031 swf_SetDefineID(tag, id);
1034 int num = swf_GetNumUsedIDs(tag);
1038 ptr = (int*)rfx_alloc(sizeof(int)*num);
1039 swf_GetUsedIDs(tag, ptr);
1040 for(t=0;t<num;t++) {
1041 int id = GET16(&tag->data[ptr[t]]);
1044 PUT16(&tag->data[ptr[t]], id);
1051 void swf_RelocateDepth(SWF*swf, char*bitmap)
1055 tag = swf->firstTag;
1056 for(nr=65535;nr>=0;nr--) {
1060 // now nr is the highest used depth. So we start
1061 // assigning depths at nr+1
1067 /* TODO * clip depths
1070 if(tag->id == ST_PLACEOBJECT2) {
1072 swf_GetPlaceObject(tag, &obj);
1074 int newdepth = obj.clipdepth+nr;
1075 if(newdepth>65535) {
1076 fprintf(stderr, "Couldn't relocate depths: too large values\n");
1079 obj.clipdepth = newdepth;
1080 swf_ResetTag(tag, ST_PLACEOBJECT2);
1081 swf_SetPlaceObject(tag, &obj);
1083 swf_PlaceObjectFree(&obj);
1086 depth = swf_GetDepth(tag);
1088 int newdepth = depth+nr;
1089 if(newdepth>65535) {
1090 fprintf(stderr, "Couldn't relocate depths: too large values\n");
1093 swf_SetDepth(tag, newdepth);
1099 U8 swf_isShapeTag(TAG*tag)
1101 if(tag->id == ST_DEFINESHAPE ||
1102 tag->id == ST_DEFINESHAPE2 ||
1103 tag->id == ST_DEFINESHAPE3 ||
1104 tag->id == ST_DEFINESHAPE4)
1109 U8 swf_isPlaceTag(TAG*tag)
1111 if(tag->id == ST_PLACEOBJECT ||
1112 tag->id == ST_PLACEOBJECT2 ||
1113 tag->id == ST_PLACEOBJECT3)
1117 U8 swf_isTextTag(TAG*tag)
1119 if(tag->id == ST_DEFINETEXT ||
1120 tag->id == ST_DEFINETEXT2)
1125 U8 swf_isFontTag(TAG*tag)
1127 if(tag->id == ST_DEFINEFONT ||
1128 tag->id == ST_DEFINEFONT2 ||
1129 tag->id == ST_DEFINEFONTINFO)
1134 U8 swf_isImageTag(TAG*tag)
1136 if(tag->id == ST_DEFINEBITSJPEG ||
1137 tag->id == ST_DEFINEBITSJPEG2 ||
1138 tag->id == ST_DEFINEBITSJPEG3 ||
1139 tag->id == ST_DEFINEBITSLOSSLESS ||
1140 tag->id == ST_DEFINEBITSLOSSLESS2)
1145 TAG* swf_Concatenate (TAG*list1,TAG*list2)
1147 TAG*tag=0,*lasttag=0;
1149 char depthmap[65536];
1151 memset(bitmap, 0, sizeof(bitmap));
1152 memset(depthmap, 0, sizeof(depthmap));
1153 memset(&swf1, 0, sizeof(swf1));
1154 memset(&swf2, 0, sizeof(swf2));
1156 swf1.firstTag = list1;
1158 swf2.firstTag = list2;
1163 if(!swf_isDefiningTag(tag)) {
1164 int id = swf_GetDefineID(tag);
1167 if(tag->id == ST_PLACEOBJECT ||
1168 tag->id == ST_PLACEOBJECT2) {
1169 int depth = swf_GetDepth(tag);
1170 depthmap[depth] = 1;
1172 if(tag->id == ST_REMOVEOBJECT ||
1173 tag->id == ST_REMOVEOBJECT2) {
1174 int depth = swf_GetDepth(tag);
1175 depthmap[depth] = 0;
1180 swf_Relocate(&swf2, bitmap);
1181 swf_RelocateDepth(&swf2, depthmap);
1182 lasttag->next = swf2.firstTag;
1183 swf2.firstTag->prev = lasttag;
1185 return swf1.firstTag;
1188 static int tagHash(TAG*tag)
1191 unsigned int a = 0x6b973e5a;
1192 /* start at pos 2, as 0 and 1 are the id */
1193 for(t=2;t<tag->len;t++) {
1196 a += tag->data[t]*0xefbc35a5*b*(t+1);
1198 return a&0x7fffffff; //always return positive number
1201 void swf_Optimize(SWF*swf)
1203 const int hash_size = 131072;
1204 char* dontremap = (char*)rfx_calloc(sizeof(char)*65536);
1205 U16* remap = (U16*)rfx_alloc(sizeof(U16)*65536);
1206 TAG* id2tag = (TAG*)rfx_calloc(sizeof(TAG*)*65536);
1207 TAG** hashmap = (TAG**)rfx_calloc(sizeof(TAG*)*hash_size);
1210 for(t=0;t<65536;t++) {
1216 tag = swf->firstTag;
1218 /* make sure we don't remap to this tag,
1219 as it might have different "helper tags"
1220 FIXME: a better way would be to compare
1221 the helper tags, too.
1223 if(swf_isPseudoDefiningTag(tag) &&
1224 tag->id != ST_NAMECHARACTER) {
1225 dontremap[swf_GetDefineID(tag)] = 1;
1229 tag = swf->firstTag;
1231 TAG*next = tag->next;
1234 int num = swf_GetNumUsedIDs(tag);
1235 int*positions = (int*)rfx_alloc(sizeof(int)*num);
1237 swf_GetUsedIDs(tag, positions);
1238 for(t=0;t<num;t++) {
1239 int id = GET16(&tag->data[positions[t]]);
1241 PUT16(&tag->data[positions[t]], id);
1243 rfx_free(positions);
1245 /* now look for previous tags with the same
1247 if(swf_isDefiningTag(tag)) {
1249 int id = swf_GetDefineID(tag);
1250 int hash = tagHash(tag);
1253 while((tag2 = hashmap[hash%hash_size])) {
1254 if(tag2 != (TAG*)0 && tag->len == tag2->len) {
1255 if(memcmp(&tag->data[2],&tag2->data[2],tag->len-2) == 0) {
1263 while(hashmap[hash%hash_size]) hash++;
1264 hashmap[hash%hash_size] = tag;
1266 /* we found two identical tags- remap one
1268 remap[id] = swf_GetDefineID(tag2);
1270 if(tag == swf->firstTag)
1271 swf->firstTag = next;
1273 } else if(swf_isPseudoDefiningTag(tag)) {
1274 int id = swf_GetDefineID(tag);
1276 /* if this tag was remapped, we don't
1277 need the helper tag anymore. Discard
1280 if(tag == swf->firstTag)
1281 swf->firstTag = next;
1288 rfx_free(dontremap);
1294 void swf_SetDefineBBox(TAG * tag, SRECT newbbox)
1298 swf_SetTagPos(tag,0);
1300 switch (swf_GetTagID(tag))
1302 case ST_DEFINESHAPE:
1303 case ST_DEFINESHAPE2:
1304 case ST_DEFINESHAPE3:
1305 case ST_DEFINEEDITTEXT:
1307 case ST_DEFINETEXT2:
1308 case ST_DEFINEVIDEOSTREAM: {
1309 U32 after_bbox_offset = 0, len;
1311 id = swf_GetU16(tag);
1312 swf_GetRect(tag, &b1);
1313 swf_ResetReadBits(tag);
1314 after_bbox_offset = tag->pos;
1315 len = tag->len - after_bbox_offset;
1316 data = (U8*)malloc(len);
1317 memcpy(data, &tag->data[after_bbox_offset], len);
1320 swf_SetRect(tag, &newbbox);
1321 swf_SetBlock(tag, data, len);
1323 tag->pos = tag->readBit = 0;
1327 fprintf(stderr, "rfxswf: Tag %d (%s) has no bbox\n", tag->id, swf_TagGetName(tag));
1331 RGBA swf_GetSWFBackgroundColor(SWF*swf)
1333 TAG*t=swf->firstTag;
1335 color.r = color.b = color.g = 0;
1338 if(t->id == ST_SETBACKGROUNDCOLOR) {
1339 swf_SetTagPos(t, 0);
1340 color.r = swf_GetU8(t);
1341 color.g = swf_GetU8(t);
1342 color.b = swf_GetU8(t);