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