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