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