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