pointers which are freed are now cleanly set to 0 afterwards.
[swftools.git] / lib / modules / swftools.c
1 /* swftools.c
2
3    Math and matrix functions, misc tools
4
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2000, 2001 Rainer Böhme <rfxswf@reflex-studio.de>
9  
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.
14
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.
19
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 */
23
24 // Matrix & Math tools for SWF files
25
26 #define S64 long long
27 SFIXED RFXSWF_SP(SFIXED a1,SFIXED a2,SFIXED b1,SFIXED b2)
28 { S64 a;
29   a = (S64)a1*(S64)b1+(S64)a2*(S64)b2;
30   return (SFIXED)(a>>16);
31 }
32 SFIXED RFXSWF_QFIX(int zaehler,int nenner) // bildet Quotient von zwei INTs in SFIXED
33 { S64 z = zaehler<<16;
34   S64 a = z/(S64)nenner;
35   return (SFIXED)a;
36 }
37 #undef S64
38
39 MATRIX * swf_MatrixJoin(MATRIX * d,MATRIX * s1,MATRIX * s2)
40 {        
41   if (!d) return NULL;
42   if (!s1) return (s2)?(MATRIX *)memcpy(d,s2,sizeof(MATRIX)):NULL;
43   if (!s2) return (MATRIX *)memcpy(d,s1,sizeof(MATRIX));
44   
45   d->tx = s1->tx + s2->tx;
46   d->ty = s1->ty + s2->ty;
47   
48   d->sx = RFXSWF_SP(s1->sx,s1->r1,s2->sx,s2->r0);
49   d->sy = RFXSWF_SP(s1->r0,s1->sy,s2->r1,s2->sy);
50   d->r0 = RFXSWF_SP(s1->r0,s1->sy,s2->sx,s2->r0);
51   d->r1 = RFXSWF_SP(s1->sx,s1->r1,s2->r1,s2->sy);
52
53   //DumpMatrix(NULL,d);
54   
55   return d;
56 }
57
58 MATRIX * swf_MatrixMapTriangle(MATRIX * m,int dx,int dy,int x0,int y0,
59                                int x1,int y1,int x2,int y2)
60 { int dx1 = x1 - x0;
61   int dy1 = y1 - y0;
62   int dx2 = x2 - x0;
63   int dy2 = y2 - y0;
64   
65   if (!m) return NULL;
66   if ((!dx)||(!dy)) return NULL; // check DIV by zero
67
68   m->tx = x0;
69   m->ty = y0;
70   m->sx = RFXSWF_QFIX(dx1,dx);
71   m->sy = RFXSWF_QFIX(dy2,dy);
72   m->r0 = RFXSWF_QFIX(dy1,dx);
73   m->r1 = RFXSWF_QFIX(dx2,dy);
74   
75   return m;
76 }
77
78 void swf_SetDefineID(TAG * tag, U16 newid)
79 {
80   int oldlen = tag->len;
81   tag->len = 0;
82   swf_SetU16(tag, newid); /* set defining ID */
83   tag->len = oldlen;
84 }
85
86 U16 swf_GetDefineID(TAG * t)
87 // up to SWF 4.0
88 { U32 oldTagPos;
89   U16 id = 0;
90
91   oldTagPos = swf_GetTagPos(t);
92   swf_SetTagPos(t,0);
93
94   switch (swf_GetTagID(t))
95   { case ST_DEFINESHAPE:
96     case ST_DEFINESHAPE2:
97     case ST_DEFINESHAPE3:
98     case ST_DEFINEMORPHSHAPE:
99     case ST_DEFINEEDITTEXT:
100     case ST_DEFINEBITS:
101     case ST_DEFINEBITSJPEG2:
102     case ST_DEFINEBITSJPEG3:
103     case ST_DEFINEBITSLOSSLESS:
104     case ST_DEFINEBITSLOSSLESS2:
105     case ST_DEFINEBUTTON:
106     case ST_DEFINEBUTTON2:
107     case ST_DEFINEBUTTONCXFORM: //pseudodefine
108     case ST_DEFINEBUTTONSOUND: //pseudodefine
109     case ST_DEFINEFONT:
110     case ST_DEFINEFONT2:
111     case ST_DEFINEFONTINFO: //pseudodefine
112     case ST_DEFINEFONTINFO2: //pseudodefine
113     case ST_DEFINETEXT:
114     case ST_DEFINETEXT2:
115     case ST_DEFINESOUND:
116     case ST_DEFINESPRITE:
117     case ST_DEFINEMOVIE:
118     case ST_DEFINEVIDEOSTREAM:
119     case ST_VIDEOFRAME: //pseudodefine
120     case ST_NAMECHARACTER: //pseudodefine
121       id = swf_GetU16(t);
122       break;
123   }
124
125   swf_SetTagPos(t,oldTagPos);
126
127   return id;
128 }
129
130 SRECT swf_GetDefineBBox(TAG * t)
131 {
132   U32 oldTagPos;
133   U16 id = 0;
134   SRECT b1,b2;
135
136   oldTagPos = swf_GetTagPos(t);
137   swf_SetTagPos(t,0);
138
139   swf_GetRect(0, &b1);
140
141   switch (swf_GetTagID(t))
142   { case ST_DEFINESHAPE:
143     case ST_DEFINESHAPE2:
144     case ST_DEFINESHAPE3:
145     case ST_DEFINEEDITTEXT:
146     case ST_DEFINEBUTTON:
147     case ST_DEFINEBUTTON2:
148     case ST_DEFINETEXT:
149     case ST_DEFINETEXT2:
150     case ST_DEFINEVIDEOSTREAM:
151       id = swf_GetU16(t);
152       swf_GetRect(t, &b1);
153       break;
154     case ST_DEFINEMORPHSHAPE:
155       id = swf_GetU16(t);
156       swf_GetRect(t, &b1);
157       swf_GetRect(t, &b2);
158       swf_ExpandRect2(&b1, &b2);
159       break;
160     case ST_DEFINEBITSLOSSLESS:
161     case ST_DEFINEBITSLOSSLESS2:
162     case ST_DEFINEBITS:
163     case ST_DEFINEBITSJPEG2:
164     case ST_DEFINEBITSJPEG3:
165       // FIXME
166       break;
167   }
168
169   swf_SetTagPos(t,oldTagPos);
170
171   return b1;
172 }
173
174 U16 swf_GetPlaceID(TAG * t)
175 // up to SWF 4.0
176 { U32 oldTagPos;
177   U16 id = 0;
178
179   oldTagPos = swf_GetTagPos(t);
180   swf_SetTagPos(t,0);
181
182   switch (swf_GetTagID(t))
183   { case ST_PLACEOBJECT:
184     case ST_REMOVEOBJECT:
185     case ST_FREECHARACTER:
186     case ST_STARTSOUND:
187       id = swf_GetU16(t);
188       break;
189
190     case ST_PLACEOBJECT2:
191     { U8 flags = swf_GetU8(t);
192       U16 d = swf_GetU16(t);
193       id = (flags&PF_CHAR)?swf_GetU16(t):id;
194     } break;
195
196   }
197
198   swf_SetTagPos(t,oldTagPos);
199
200   return id;
201 }
202
203 static int swf_definingtagids[] =
204 {ST_DEFINESHAPE,
205  ST_DEFINESHAPE2,
206  ST_DEFINESHAPE3,
207  ST_DEFINEMORPHSHAPE,
208  ST_DEFINEFONT,
209  ST_DEFINEFONT2,
210  ST_DEFINETEXT,
211  ST_DEFINETEXT2,
212  ST_DEFINEEDITTEXT,
213  ST_DEFINEBITS,
214  ST_DEFINEBITSJPEG2,
215  ST_DEFINEBITSJPEG3,
216  ST_DEFINEBITSLOSSLESS,
217  ST_DEFINEBITSLOSSLESS2,
218  ST_DEFINEMOVIE,
219  ST_DEFINESPRITE,
220  ST_DEFINEBUTTON,
221  ST_DEFINEBUTTON2,
222  ST_DEFINESOUND,
223  ST_DEFINEVIDEOSTREAM,
224  -1
225 };
226
227 // tags which may be used inside a sprite definition
228 static int swf_spritetagids[] =
229 {ST_SHOWFRAME,
230  ST_PLACEOBJECT,
231  ST_PLACEOBJECT2,
232  ST_REMOVEOBJECT,
233  ST_REMOVEOBJECT2, //?
234  ST_DOACTION,
235  ST_STARTSOUND,
236  ST_FRAMELABEL,
237  ST_SOUNDSTREAMHEAD,
238  ST_SOUNDSTREAMHEAD2,
239  ST_SOUNDSTREAMBLOCK,
240  ST_END,
241  -1
242 };
243
244 static int swf_pseudodefiningtagids[] = 
245 {
246  ST_DEFINEFONTINFO,
247  ST_DEFINEFONTINFO2,
248  ST_DEFINEBUTTONCXFORM,
249  ST_DEFINEBUTTONSOUND,
250  ST_NAMECHARACTER,
251  ST_DOINITACTION,
252  ST_VIDEOFRAME,
253  -1
254 };
255
256 U8 swf_isAllowedSpriteTag(TAG * tag)
257 {
258     int id = tag->id;
259     int t=0;
260     while(swf_spritetagids[t]>=0)
261     {
262         if(swf_spritetagids[t] == id) 
263             return 1;
264         t++;
265     }
266     return 0; 
267 }
268
269 U8 swf_isDefiningTag(TAG * tag)
270 {
271     int id = tag->id;
272     int t=0;
273     while(swf_definingtagids[t]>=0)
274     {
275         if(swf_definingtagids[t] == id) 
276             return 1;
277         t++;
278     }
279     return 0; 
280 }
281
282 U8 swf_isPseudoDefiningTag(TAG * tag)
283 {
284     int id = tag->id;
285     int t=0;
286     while(swf_pseudodefiningtagids[t]>=0)
287     {
288         if(swf_pseudodefiningtagids[t] == id) 
289             return 1;
290         t++;
291     }
292     return 0; 
293 }
294
295 U16 swf_GetDepth(TAG * t)
296 // up to SWF 4.0
297
298   U16 depth = 0;
299   U32 oldTagPos;
300   oldTagPos = swf_GetTagPos(t);
301   swf_SetTagPos(t,0);
302
303   switch (swf_GetTagID(t))
304   { case ST_PLACEOBJECT:
305     case ST_REMOVEOBJECT:
306       swf_GetU16(t); //id
307       depth = swf_GetU16(t);
308       break;
309     case ST_REMOVEOBJECT2:
310       depth = swf_GetU16(t);
311       break;
312     case ST_PLACEOBJECT2:
313     { U8 flags = swf_GetU8(t);
314       depth = swf_GetU16(t);
315     } break;
316   }
317   swf_SetTagPos(t,oldTagPos);
318   return depth;
319 }
320
321 char* swf_GetName(TAG * t)
322 {
323     char* name = 0;
324     U32 oldTagPos;
325     MATRIX m;
326     CXFORM c;
327     oldTagPos = swf_GetTagPos(t);
328     swf_SetTagPos(t,0);
329     switch(swf_GetTagID(t))
330     {
331         case ST_FRAMELABEL:
332             name = &t->data[swf_GetTagPos(t)];
333         break;
334         case ST_PLACEOBJECT2: {   
335             U8 flags = swf_GetU8(t);
336             swf_GetU16(t); //depth;
337             if(flags&PF_CHAR) 
338               swf_GetU16(t); //id
339             if(flags&PF_MATRIX)
340               swf_GetMatrix(t, &m);
341             if(flags&PF_CXFORM)
342               swf_GetCXForm(t, &c, 1);
343             if(flags&PF_RATIO)
344               swf_GetU16(t);
345             if(flags&PF_CLIPACTION)
346               swf_GetU16(t);
347             if(flags&PF_NAME) {
348               swf_ResetReadBits(t);
349               name = &t->data[swf_GetTagPos(t)];
350             }
351         }
352         break;
353     }
354     swf_SetTagPos(t,oldTagPos);
355     return name;
356 }
357
358 /* used in enumerateUsedIDs */
359 void swf_GetMorphGradient(TAG * tag, GRADIENT * gradient1, GRADIENT * gradient2)
360 {
361     GRADIENT dummy1;
362     GRADIENT dummy2;
363     int t;
364     if(!gradient1)
365         gradient1 = &dummy1;
366     if(!gradient2)
367         gradient2 = &dummy2;
368     gradient1->num = 
369     gradient2->num = swf_GetU8(tag);
370     for(t=0;t<gradient1->num;t++)
371     {
372         int s=t;
373         if(s>=8) //FIXME
374             s=7;
375         gradient1->ratios[t] = swf_GetU8(tag);
376         swf_GetRGBA(tag, &gradient1->rgba[t]);
377         gradient2->ratios[t] = swf_GetU8(tag);
378         swf_GetRGBA(tag, &gradient2->rgba[t]);
379     }
380 }
381
382 #define DEBUG_ENUMERATE if(0)
383
384 static void enumerateUsedIDs_styles(TAG * tag, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
385 {
386     U16 count;
387     int t;
388     count = swf_GetU8(tag);
389     if(count == 0xff && num>1) // defineshape2,3 only
390         count = swf_GetU16(tag);
391
392     for(t=0;t<count;t++)
393     {
394         int type;
395         U8*pos;
396         swf_ResetReadBits(tag);
397         type = swf_GetU8(tag); //type
398         if(type == 0) {
399             if(num == 3)
400                 {swf_GetRGBA(tag, NULL);if(morph) swf_GetRGBA(tag, NULL);}
401             else 
402                 {swf_GetRGB(tag, NULL);if(morph) swf_GetRGB(tag, NULL);}
403         }
404         else if(type == 0x10 || type == 0x12)
405         {
406             swf_ResetReadBits(tag);
407             swf_GetMatrix(tag, NULL);
408             if(morph)
409                 swf_GetMatrix(tag, NULL);
410             swf_ResetReadBits(tag);
411             if(morph)
412                 swf_GetMorphGradient(tag, NULL, NULL);
413             else
414                 swf_GetGradient(tag, NULL, /*alpha*/ num>=3?1:0);
415         }
416         else if(type == 0x40 || type == 0x41)
417         {
418             swf_ResetReadBits(tag);
419             // we made it.
420             if(tag->data[tag->pos] != 0xff ||
421                tag->data[tag->pos+1] != 0xff)
422             (callback)(tag, tag->pos, callback_data);
423
424             swf_GetU16(tag);
425             swf_ResetReadBits(tag);
426             swf_GetMatrix(tag, NULL);
427             if(morph)
428                 swf_GetMatrix(tag, NULL);
429         }
430         else {
431             fprintf(stderr, "rfxswf:swftools.c Unknown fillstyle:0x%02x\n",type);
432         }
433     }
434     swf_ResetReadBits(tag);
435     count = swf_GetU8(tag); // line style array
436     if(count == 0xff)
437         count = swf_GetU16(tag);
438     for(t=0;t<count;t++) 
439     {
440         swf_GetU16(tag);
441         if(morph)
442             swf_GetU16(tag);
443         if(num == 3)
444             {swf_GetRGBA(tag, NULL);if(morph) swf_GetRGBA(tag, NULL);}
445         else
446             {swf_GetRGB(tag, NULL);if(morph) swf_GetRGB(tag, NULL);}
447     }
448 }
449
450 void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), void*callback_data)
451 {
452     int num = 1;
453     swf_ResetReadBits(tag);
454     tag->pos = 0;
455     switch(tag->id)
456     {
457         case ST_DEFINEBUTTONCXFORM: {
458             int t;
459             callback(tag, tag->pos + base, callback_data);
460             for(t=0;t<4;t++) {
461                 int flags;
462                 callback(tag, tag->pos + base, callback_data);
463                 swf_GetU16(tag); //sound id
464                 flags = swf_GetU8(tag);
465                 if(flags&1)
466                     swf_GetU32(tag); // in point
467                 if(flags&2)
468                     swf_GetU32(tag); // out points
469                 if(flags&4)
470                     swf_GetU16(tag); // loop count
471                 if(flags&8)
472                 {
473                     int npoints = swf_GetU8(tag);
474                     int s;
475                     for(s=0;s<npoints;s++)
476                     {
477                         swf_GetU32(tag);
478                         swf_GetU16(tag);
479                         swf_GetU16(tag);
480                     }
481                 }
482             }
483         } break;
484         case ST_DEFINEBUTTONSOUND:
485             callback(tag, tag->pos + base, callback_data); //button id
486         break;
487
488         case ST_EXPORTASSETS: {
489             int num =  swf_GetU16(tag);
490             int t;
491             for(t=0;t<num;t++) {
492                 callback(tag, tag->pos + base, callback_data); //button id
493                 swf_GetU16(tag); //id
494                 while(swf_GetU8(tag)); //name
495             }
496         } break;
497
498         case ST_FREECHARACTER: /* unusual tags, which all start with an ID */
499         case ST_NAMECHARACTER:
500         case ST_GENERATORTEXT:
501             callback(tag, tag->pos + base, callback_data);
502         break;
503         case ST_PLACEOBJECT:
504             callback(tag, tag->pos + base, callback_data);
505         break;
506         case ST_PLACEOBJECT2:
507             // only if placeflaghascharacter
508             if(!(tag->data[0]&2))
509                 break;
510             callback(tag, 3 + base, callback_data);
511         break;
512         case ST_REMOVEOBJECT:
513             callback(tag, tag->pos + base, callback_data);
514         break;
515         case ST_STARTSOUND:
516             callback(tag, tag->pos + base, callback_data);
517         break;
518         case ST_DEFINESPRITE: {
519             if(tag->len <= 4)
520                 break; // sprite is expanded
521
522             swf_GetU16(tag); // id
523             swf_GetU16(tag); // framenum
524
525             while(1) {
526                 U16 flags = swf_GetU16(tag);
527                 U32 len;
528                 U16 id = flags>>6;
529                 TAG *tag2 = swf_InsertTag(NULL, id);
530                 len = flags&0x3f;
531                 if(len == 63)
532                     len = swf_GetU32(tag);
533                 if(id == ST_END)
534                     break;
535                 tag2->len = tag2->memsize = len;
536                 tag2->data = malloc(len);
537                 memcpy(tag2->data, &tag->data[tag->pos], len);
538                 /* I never saw recursive sprites, but they are (theoretically) 
539                    possible, so better add base here again */
540                 enumerateUsedIDs(tag2, tag->pos + base, callback, callback_data);
541                 swf_DeleteTag(tag2);
542                 swf_GetBlock(tag, NULL, len);
543             }
544         } 
545         break;
546         case ST_DEFINEBUTTON2: // has some font ids in the button records
547             num++; 
548         //fallthrough
549         case ST_DEFINEBUTTON: {
550             swf_GetU16(tag); //button id
551             if(num>1)
552             { 
553                 int offset;
554                 swf_GetU8(tag); //flag
555                 offset = swf_GetU16(tag); //offset
556             }
557             while(1)
558             {
559                 U16 charid;
560                 if(!swf_GetU8(tag)) //flags
561                     break; 
562                 callback(tag, tag->pos + base, callback_data);
563                 swf_GetU16(tag); //char
564                 swf_GetU16(tag); //layer
565                 swf_ResetReadBits(tag);
566                 swf_GetMatrix(tag, NULL);
567                 if(num>1) {
568                   swf_ResetReadBits(tag);
569                   swf_GetCXForm(tag, NULL, 1);
570                 }
571             }
572             // ...
573         }
574         break;
575         case ST_DEFINEEDITTEXT:  {
576             U8 flags1,flags2;
577             swf_GetU16(tag); //id
578             swf_GetRect(tag, NULL); //bounding box
579             swf_ResetReadBits(tag);
580             flags1 = swf_GetU8(tag);
581             flags2 = swf_GetU8(tag);
582             if(flags1 & 1)
583                 callback(tag, tag->pos + base, callback_data);
584         }
585         break;
586         case ST_DEFINETEXT2:
587             num ++;
588         case ST_DEFINETEXT: { 
589             int glyphbits, advancebits;
590             int id;
591             id = swf_GetU16(tag); //id
592             swf_GetRect(tag, NULL); //bounding box
593             swf_ResetReadBits(tag);
594             swf_GetMatrix(tag, NULL); //matrix
595             swf_ResetReadBits(tag);
596             glyphbits = swf_GetU8(tag); //glyphbits
597             advancebits = swf_GetU8(tag); //advancebits
598             while(1) {
599                 U16 flags;
600                 swf_ResetReadBits(tag);
601                 flags = swf_GetBits(tag, 8);
602                 if(!flags) break;
603                 if(flags & 128) // text style record
604                 {
605                     swf_ResetReadBits(tag);
606                     if(flags & 8) { // hasfont
607                         callback(tag, tag->pos + base, callback_data);
608                         id = swf_GetU16(tag);
609                     }
610                     if(flags & 4) { // hascolor
611                         if(num==1) swf_GetRGB(tag, NULL);
612                         else       swf_GetRGBA(tag, NULL);
613                     }
614                     if(flags & 2) { //has x offset
615                         swf_ResetReadBits(tag);
616                         swf_GetU16(tag);
617                     }
618                     if(flags & 1) { //has y offset
619                         swf_ResetReadBits(tag);
620                         swf_GetU16(tag);
621                     }
622                     if(flags & 8) { //has height
623                         swf_ResetReadBits(tag);
624                         swf_GetU16(tag);
625                     }
626                 } else { // glyph record
627                     int t;
628                     swf_ResetReadBits(tag);
629                     for(t=0;t<flags;t++) {
630                         swf_GetBits(tag, glyphbits);
631                         swf_GetBits(tag, advancebits);
632                     }
633                 }
634             }
635             break;
636         }
637         case ST_DEFINEFONTINFO:
638         case ST_DEFINEFONTINFO2:
639         case ST_VIDEOFRAME:
640             callback(tag, tag->pos + base, callback_data);
641         break;
642         case ST_DEFINEVIDEOSTREAM:
643         break;
644
645         case ST_DOINITACTION:
646             callback(tag, tag->pos + base, callback_data);
647         break;
648
649         case ST_DEFINEMORPHSHAPE:
650         case ST_DEFINESHAPE3:
651         num++; //fallthrough
652         case ST_DEFINESHAPE2:
653         num++; //fallthrough
654         case ST_DEFINESHAPE: {
655             int fillbits;
656             int linebits;
657             int id; 
658             int numshapes = 1;
659             int morph = 0;
660             if(tag->id == ST_DEFINEMORPHSHAPE) {
661                 numshapes = 2;
662                 morph = 1;
663             }
664
665             id = swf_GetU16(tag); // id;
666             swf_GetRect(tag, NULL); // bounds
667             if(morph) {
668                 swf_ResetReadBits(tag);
669                 swf_GetRect(tag, NULL); // bounds2
670                 swf_GetU32(tag); //offset to endedges
671             }
672    
673             DEBUG_ENUMERATE printf("Tag:%d Name:%s ID:%d\n", tag->id, swf_TagGetName(tag), id);
674
675             enumerateUsedIDs_styles(tag, callback, callback_data, num, morph);
676             DEBUG_ENUMERATE printf("-------\n");
677             while(--numshapes>=0) /* morph shapes define two shapes */
678             {
679                 DEBUG_ENUMERATE printf("shape:%d\n", numshapes);
680                 fillbits = swf_GetBits(tag, 4);
681                 linebits = swf_GetBits(tag, 4);
682                 DEBUG_ENUMERATE printf("%d %d\n", fillbits, linebits);
683                 swf_ResetReadBits(tag);
684                 while(1) {
685                     int flags;
686                     flags = swf_GetBits(tag, 1);
687                     if(!flags) { //style change
688                         flags = swf_GetBits(tag, 5);
689                         if(!flags)
690                             break;
691                         if(flags&1) { //move
692                             int n = swf_GetBits(tag, 5); 
693                             int x,y;
694                             x = swf_GetBits(tag, n); //x
695                             y = swf_GetBits(tag, n); //y
696                             DEBUG_ENUMERATE printf("move %f %f\n",x/20.0,y/20.0);
697                         }
698                         if(flags&2) { //fill0
699                             int fill0;
700                             fill0 = swf_GetBits(tag, fillbits); 
701                             DEBUG_ENUMERATE printf("fill0 %d\n", fill0);
702                         }
703                         if(flags&4) { //fill1
704                             int fill1;
705                             fill1 = swf_GetBits(tag, fillbits); 
706                             DEBUG_ENUMERATE printf("fill1 %d\n", fill1);
707                         }
708                         if(flags&8) { //linestyle
709                             int line;
710                             line = swf_GetBits(tag, linebits); 
711                             DEBUG_ENUMERATE printf("linestyle %d\n",line);
712                         }
713                         if(flags&16) {
714                             DEBUG_ENUMERATE printf("more fillstyles\n");
715                             enumerateUsedIDs_styles(tag, callback, callback_data, num, 0);
716                             fillbits = swf_GetBits(tag, 4);
717                             linebits = swf_GetBits(tag, 4);
718                         }
719                     } else {
720                         flags = swf_GetBits(tag, 1);
721                         if(flags) { //straight edge
722                             int n = swf_GetBits(tag, 4) + 2;
723                             if(swf_GetBits(tag, 1)) { //line flag
724                                 int x,y;
725                                 x = swf_GetSBits(tag, n); //delta x
726                                 y = swf_GetSBits(tag, n); //delta y
727                                 DEBUG_ENUMERATE printf("line %f %f\n",x/20.0,y/20.0);
728                             } else {
729                                 int v=swf_GetBits(tag, 1);
730                                 int d;
731                                 d = swf_GetSBits(tag, n); //vert/horz
732                                 DEBUG_ENUMERATE printf("%s %f\n",v?"vertical":"horizontal", d/20.0);
733                             }
734                         } else { //curved edge
735                             int n = swf_GetBits(tag, 4) + 2;
736                             int x1,y1,x2,y2;
737                             x1 = swf_GetSBits(tag, n);
738                             y1 = swf_GetSBits(tag, n);
739                             x2 = swf_GetSBits(tag, n);
740                             y2 = swf_GetSBits(tag, n);
741                             DEBUG_ENUMERATE printf("curve %f %f %f %f\n", x1/20.0, y1/20.0, x2/20.0, y2/20.0);
742                         }
743                     }
744                 }
745             }
746         }
747         break;
748         default:
749         break;
750     }
751 }
752
753 void callbackCount(TAG * t,int pos, void*ptr)
754 {
755     (*(int*)ptr)++;
756     DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
757 }
758
759 void callbackFillin(TAG * t,int pos, void*ptr)
760 {
761     **(int**)ptr = pos;
762     (*(int**)ptr)++;
763     DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
764 }
765
766 int swf_GetNumUsedIDs(TAG * t)
767 {
768     int num = 0;
769     enumerateUsedIDs(t, 0, callbackCount, &num);
770     return num;
771 }
772
773 void swf_GetUsedIDs(TAG * t, int * positions)
774 {
775     int * ptr = positions;
776     enumerateUsedIDs(t, 0, callbackFillin, &ptr);
777 }
778
779 void swf_Relocate (SWF*swf, char*bitmap)
780 {
781     TAG*tag;
782     int slaveids[65536];
783     memset(slaveids, -1, sizeof(slaveids));
784     tag = swf->firstTag;
785     while(tag)
786     {
787         int num; 
788         int *ptr;
789         int t;
790
791         if(swf_isDefiningTag(tag))
792         {
793             int newid;
794             int id;
795             
796             id = swf_GetDefineID(tag); //own id
797
798             if(!bitmap[id]) { //free
799                 newid = id;
800             }
801             else {
802                 newid = 0;
803                 for (t=1;t<65536;t++)
804                 {
805                     if(!bitmap[t])
806                     {
807                         newid = t;
808                         break;
809                     }
810                 }
811             }
812             bitmap[newid] = 1;
813             slaveids[id] = newid;
814
815             swf_SetDefineID(tag, newid);
816         } 
817         
818         num = swf_GetNumUsedIDs(tag);
819         ptr = malloc(sizeof(int)*num);
820         swf_GetUsedIDs(tag, ptr);
821
822         for(t=0;t<num;t++) {
823             int id = GET16(&tag->data[ptr[t]]);
824             if(slaveids[id]<0) {
825                 fprintf(stderr, "swf_Relocate: Mapping id never encountered before: %d\n", id);
826                 return ;
827             }
828             id = slaveids[id];
829             PUT16(&tag->data[ptr[t]], id);
830         }
831         tag=tag->next;
832     }
833 }
834