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)>>16;
  30   SFIXED result = (SFIXED)(a);
  31   if(a!=result)
  32       fprintf(stderr, "Warning: overflow in matrix multiplication");
  33   return result;
  34 }
  35 SFIXED RFXSWF_QFIX(int zaehler,int nenner) // bildet Quotient von zwei INTs in SFIXED
  36 { S64 z = zaehler<<16;
  37   S64 a = z/(S64)nenner;
  38   return (SFIXED)a;
  39 }
  40 #undef S64
  41
  42 MATRIX * swf_MatrixJoin(MATRIX * d,MATRIX * s1,MATRIX * s2)
  43 {
  44   if (!d) return NULL;
  45   if (!s1) return (s2)?(MATRIX *)memcpy(d,s2,sizeof(MATRIX)):NULL;
  46   if (!s2) return (MATRIX *)memcpy(d,s1,sizeof(MATRIX));
  47
  48   d->tx = s1->tx + RFXSWF_SP(s1->sx,s1->r1,s2->tx,s2->ty);
  49   d->ty = s1->ty + RFXSWF_SP(s1->r0,s1->sy,s2->tx,s2->ty);
  50
  51   d->sx = RFXSWF_SP(s1->sx,s1->r1,s2->sx,s2->r0);
  52   d->r0 = RFXSWF_SP(s1->r0,s1->sy,s2->sx,s2->r0);
  53
  54   d->r1 = RFXSWF_SP(s1->sx,s1->r1,s2->r1,s2->sy);
  55   d->sy = RFXSWF_SP(s1->r0,s1->sy,s2->r1,s2->sy);
  56
  57   //DumpMatrix(NULL,d);
  58
  59   return d;
  60 }
  61
  62 MATRIX * swf_MatrixMapTriangle(MATRIX * m,int dx,int dy,int x0,int y0,
  63                                int x1,int y1,int x2,int y2)
  64 { int dx1 = x1 - x0;
  65   int dy1 = y1 - y0;
  66   int dx2 = x2 - x0;
  67   int dy2 = y2 - y0;
  68
  69   if (!m) return NULL;
  70   if ((!dx)||(!dy)) return NULL; // check DIV by zero
  71
  72   m->tx = x0;
  73   m->ty = y0;
  74   m->sx = RFXSWF_QFIX(dx1,dx);
  75   m->sy = RFXSWF_QFIX(dy2,dy);
  76   m->r0 = RFXSWF_QFIX(dy1,dx);
  77   m->r1 = RFXSWF_QFIX(dx2,dy);
  78
  79   return m;
  80 }
  81
  82 void swf_SetDefineID(TAG * tag, U16 newid)
  83 {
  84   int oldlen = tag->len;
  85   tag->len = 0;
  86   swf_SetU16(tag, newid); /* set defining ID */
  87   tag->len = oldlen;
  88 }
  89
  90 U16 swf_GetDefineID(TAG * t)
  91 // up to SWF 4.0
  92 { U32 oldTagPos;
  93   U16 id = 0;
  94
  95   oldTagPos = swf_GetTagPos(t);
  96   swf_SetTagPos(t,0);
  97
  98   switch (swf_GetTagID(t))
  99   { case ST_DEFINESHAPE:
 100     case ST_DEFINESHAPE2:
 101     case ST_DEFINESHAPE3:
 102     case ST_DEFINEMORPHSHAPE:
 103     case ST_DEFINEEDITTEXT:
 104     case ST_DEFINEBITS:
 105     case ST_DEFINEBITSJPEG2:
 106     case ST_DEFINEBITSJPEG3:
 107     case ST_DEFINEBITSLOSSLESS:
 108     case ST_DEFINEBITSLOSSLESS2:
 109     case ST_DEFINEBUTTON:
 110     case ST_DEFINEBUTTON2:
 111     case ST_DEFINEBUTTONCXFORM: //pseudodefine
 112     case ST_DEFINEBUTTONSOUND: //pseudodefine
 113     case ST_DEFINEFONT:
 114     case ST_DEFINEFONT2:
 115     case ST_DEFINEFONTINFO: //pseudodefine
 116     case ST_DEFINEFONTINFO2: //pseudodefine
 117     case ST_DEFINETEXT:
 118     case ST_DEFINETEXT2:
 119     case ST_DEFINESOUND:
 120     case ST_DEFINESPRITE:
 121     case ST_DEFINEMOVIE:
 122     case ST_DEFINEVIDEOSTREAM:
 123     case ST_GLYPHNAMES: //pseudodefine
 124     case ST_VIDEOFRAME: //pseudodefine
 125     case ST_NAMECHARACTER: //pseudodefine
 126     case ST_DOINITACTION: //pseudodefine
 127       id = swf_GetU16(t);
 128       break;
 129     default:
 130       fprintf(stderr, "rfxswf: Error: tag %d (%s) has no id\n", t->id, swf_TagGetName(t));
 131   }
 132
 133   swf_SetTagPos(t,oldTagPos);
 134
 135   return id;
 136 }
 137
 138 SRECT swf_GetDefineBBox(TAG * t)
 139 {
 140   U32 oldTagPos;
 141   U16 id = 0;
 142   SRECT b1,b2;
 143   memset(&b1, 0, sizeof(b1));
 144
 145   oldTagPos = swf_GetTagPos(t);
 146   swf_SetTagPos(t,0);
 147
 148   swf_GetRect(0, &b1);
 149
 150   switch (swf_GetTagID(t))
 151   { case ST_DEFINESHAPE:
 152     case ST_DEFINESHAPE2:
 153     case ST_DEFINESHAPE3:
 154     case ST_DEFINEEDITTEXT:
 155     case ST_DEFINETEXT:
 156     case ST_DEFINETEXT2:
 157     case ST_DEFINEVIDEOSTREAM:
 158       id = swf_GetU16(t);
 159       swf_GetRect(t, &b1);
 160       break;
 161     case ST_DEFINEMORPHSHAPE:
 162       id = swf_GetU16(t);
 163       swf_GetRect(t, &b1);
 164       swf_GetRect(t, &b2);
 165       swf_ExpandRect2(&b1, &b2);
 166       break;
 167     case ST_DEFINEBITSLOSSLESS:
 168     case ST_DEFINEBITSLOSSLESS2:
 169     case ST_DEFINEBITS:
 170     case ST_DEFINEBITSJPEG2:
 171     case ST_DEFINEBITSJPEG3:
 172       // FIXME
 173       break;
 174   }
 175
 176   swf_SetTagPos(t,oldTagPos);
 177
 178   return b1;
 179 }
 180
 181 U16 swf_GetPlaceID(TAG * t)
 182 // up to SWF 4.0
 183 { U32 oldTagPos;
 184   U16 id = 0;
 185
 186   oldTagPos = swf_GetTagPos(t);
 187   swf_SetTagPos(t,0);
 188
 189   switch (swf_GetTagID(t))
 190   { case ST_PLACEOBJECT:
 191     case ST_REMOVEOBJECT:
 192     case ST_FREECHARACTER:
 193     case ST_STARTSOUND:
 194       id = swf_GetU16(t);
 195       break;
 196
 197     case ST_PLACEOBJECT2:
 198     { U8 flags = swf_GetU8(t);
 199       U16 d = swf_GetU16(t);
 200       id = (flags&PF_CHAR)?swf_GetU16(t):id;
 201     } break;
 202
 203   }
 204
 205   swf_SetTagPos(t,oldTagPos);
 206
 207   return id;
 208 }
 209
 210 static int swf_definingtagids[] =
 211 {ST_DEFINESHAPE,
 212  ST_DEFINESHAPE2,
 213  ST_DEFINESHAPE3,
 214  ST_DEFINEMORPHSHAPE,
 215  ST_DEFINEFONT,
 216  ST_DEFINEFONT2,
 217  ST_DEFINETEXT,
 218  ST_DEFINETEXT2,
 219  ST_DEFINEEDITTEXT,
 220  ST_DEFINEBITS,
 221  ST_DEFINEBITSJPEG2,
 222  ST_DEFINEBITSJPEG3,
 223  ST_DEFINEBITSLOSSLESS,
 224  ST_DEFINEBITSLOSSLESS2,
 225  ST_DEFINEMOVIE,
 226  ST_DEFINESPRITE,
 227  ST_DEFINEBUTTON,
 228  ST_DEFINEBUTTON2,
 229  ST_DEFINESOUND,
 230  ST_DEFINEVIDEOSTREAM,
 231  -1
 232 };
 233
 234 // tags which may be used inside a sprite definition
 235 static int swf_spritetagids[] =
 236 {ST_SHOWFRAME,
 237  ST_PLACEOBJECT,
 238  ST_PLACEOBJECT2,
 239  ST_REMOVEOBJECT,
 240  ST_REMOVEOBJECT2, //?
 241  ST_DOACTION,
 242  ST_STARTSOUND,
 243  ST_FRAMELABEL,
 244  ST_SOUNDSTREAMHEAD,
 245  ST_SOUNDSTREAMHEAD2,
 246  ST_SOUNDSTREAMBLOCK,
 247  ST_END,
 248  -1
 249 };
 250
 251 static int swf_pseudodefiningtagids[] =
 252 {
 253  ST_DEFINEFONTINFO,
 254  ST_DEFINEFONTINFO2,
 255  ST_DEFINEBUTTONCXFORM,
 256  ST_DEFINEBUTTONSOUND,
 257  ST_NAMECHARACTER,
 258  ST_DOINITACTION,
 259  ST_VIDEOFRAME,
 260  ST_GLYPHNAMES,
 261  -1
 262 };
 263
 264 U8 swf_isAllowedSpriteTag(TAG * tag)
 265 {
 266     int id = tag->id;
 267     int t=0;
 268     while(swf_spritetagids[t]>=0)
 269     {
 270         if(swf_spritetagids[t] == id)
 271             return 1;
 272         t++;
 273     }
 274     return 0;
 275 }
 276
 277 U8 swf_isDefiningTag(TAG * tag)
 278 {
 279     int id = tag->id;
 280     int t=0;
 281     while(swf_definingtagids[t]>=0)
 282     {
 283         if(swf_definingtagids[t] == id)
 284             return 1;
 285         t++;
 286     }
 287     return 0;
 288 }
 289
 290 U8 swf_isPseudoDefiningTag(TAG * tag)
 291 {
 292     int id = tag->id;
 293     int t=0;
 294     while(swf_pseudodefiningtagids[t]>=0)
 295     {
 296         if(swf_pseudodefiningtagids[t] == id)
 297             return 1;
 298         t++;
 299     }
 300     return 0;
 301 }
 302
 303 int swf_GetDepth(TAG * t)
 304 {
 305   int depth = -1;
 306   U32 oldTagPos;
 307   oldTagPos = swf_GetTagPos(t);
 308   swf_SetTagPos(t,0);
 309
 310   switch (swf_GetTagID(t))
 311   { case ST_PLACEOBJECT:
 312     case ST_REMOVEOBJECT:
 313       swf_GetU16(t); //id
 314       depth = swf_GetU16(t);
 315       break;
 316     case ST_REMOVEOBJECT2:
 317       depth = swf_GetU16(t);
 318       break;
 319     case ST_PLACEOBJECT2:
 320     { U8 flags = swf_GetU8(t);
 321       depth = swf_GetU16(t);
 322     } break;
 323     case ST_SETTABINDEX:
 324     {
 325       depth = swf_GetU16(t);
 326     }
 327   }
 328   swf_SetTagPos(t,oldTagPos);
 329   return depth;
 330 }
 331
 332 void swf_SetDepth(TAG * t, U16 depth)
 333 {
 334   switch (swf_GetTagID(t))
 335   { case ST_PLACEOBJECT:
 336     case ST_REMOVEOBJECT:
 337       PUT16(t->data, depth);
 338       break;
 339     case ST_REMOVEOBJECT2:
 340       PUT16(t->data, depth);
 341       break;
 342     case ST_PLACEOBJECT2:
 343       PUT16(&t->data[1], depth);
 344       break;
 345     case ST_SETTABINDEX:
 346       PUT16(t->data, depth);
 347       break;
 348     default:
 349       fprintf(stderr, "rfxswf: Error: tag %d has no depth\n", t->id);
 350   }
 351 }
 352
 353 char* swf_GetName(TAG * t)
 354 {
 355     char* name = 0;
 356     U32 oldTagPos;
 357     MATRIX m;
 358     CXFORM c;
 359     oldTagPos = swf_GetTagPos(t);
 360     swf_SetTagPos(t,0);
 361     switch(swf_GetTagID(t))
 362     {
 363         case ST_FRAMELABEL:
 364             name = &t->data[swf_GetTagPos(t)];
 365         break;
 366         case ST_PLACEOBJECT2: {
 367             U8 flags = swf_GetU8(t);
 368             swf_GetU16(t); //depth;
 369             if(flags&PF_CHAR)
 370               swf_GetU16(t); //id
 371             if(flags&PF_MATRIX)
 372               swf_GetMatrix(t, &m);
 373             if(flags&PF_CXFORM)
 374               swf_GetCXForm(t, &c, 1);
 375             if(flags&PF_RATIO)
 376               swf_GetU16(t);
 377             if(flags&PF_CLIPACTION)
 378               swf_GetU16(t);
 379             if(flags&PF_NAME) {
 380               swf_ResetReadBits(t);
 381               name = &t->data[swf_GetTagPos(t)];
 382             }
 383         }
 384         break;
 385     }
 386     swf_SetTagPos(t,oldTagPos);
 387     return name;
 388 }
 389
 390 /* used in enumerateUsedIDs */
 391 void swf_GetMorphGradient(TAG * tag, GRADIENT * gradient1, GRADIENT * gradient2)
 392 {
 393     GRADIENT dummy1;
 394     GRADIENT dummy2;
 395     int t;
 396     if(!gradient1)
 397         gradient1 = &dummy1;
 398     if(!gradient2)
 399         gradient2 = &dummy2;
 400     gradient1->num =
 401     gradient2->num = swf_GetU8(tag);
 402     for(t=0;t<gradient1->num;t++)
 403     {
 404         int s=t;
 405         if(s>=8) //FIXME
 406             s=7;
 407         gradient1->ratios[t] = swf_GetU8(tag);
 408         swf_GetRGBA(tag, &gradient1->rgba[t]);
 409         gradient2->ratios[t] = swf_GetU8(tag);
 410         swf_GetRGBA(tag, &gradient2->rgba[t]);
 411     }
 412 }
 413
 414 #define DEBUG_ENUMERATE if(0)
 415
 416 void enumerateUsedIDs_styles(TAG * tag, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
 417 {
 418     U16 count;
 419     int t;
 420     count = swf_GetU8(tag);
 421     if(count == 0xff && num>1) // defineshape2,3 only
 422         count = swf_GetU16(tag);
 423
 424     for(t=0;t<count;t++)
 425     {
 426         int type;
 427         U8*pos;
 428         swf_ResetReadBits(tag);
 429         type = swf_GetU8(tag); //type
 430         if(type == 0) {
 431             if(num == 3)
 432                 {swf_GetRGBA(tag, NULL);if(morph) swf_GetRGBA(tag, NULL);}
 433             else
 434                 {swf_GetRGB(tag, NULL);if(morph) swf_GetRGB(tag, NULL);}
 435         }
 436         else if(type == 0x10 || type == 0x12)
 437         {
 438             swf_ResetReadBits(tag);
 439             swf_GetMatrix(tag, NULL);
 440             if(morph)
 441                 swf_GetMatrix(tag, NULL);
 442             swf_ResetReadBits(tag);
 443             if(morph)
 444                 swf_GetMorphGradient(tag, NULL, NULL);
 445             else
 446                 swf_GetGradient(tag, NULL, /*alpha*/ num>=3?1:0);
 447         }
 448         else if(type == 0x40 || type == 0x41)
 449         {
 450             swf_ResetReadBits(tag);
 451             // we made it.
 452             if(tag->data[tag->pos] != 0xff ||
 453                tag->data[tag->pos+1] != 0xff)
 454             (callback)(tag, tag->pos, callback_data);
 455
 456             swf_GetU16(tag);
 457             swf_ResetReadBits(tag);
 458             swf_GetMatrix(tag, NULL);
 459             if(morph)
 460                 swf_GetMatrix(tag, NULL);
 461         }
 462         else {
 463             fprintf(stderr, "rfxswf:swftools.c Unknown fillstyle:0x%02x\n",type);
 464         }
 465     }
 466     swf_ResetReadBits(tag);
 467     count = swf_GetU8(tag); // line style array
 468     if(count == 0xff)
 469         count = swf_GetU16(tag);
 470     for(t=0;t<count;t++)
 471     {
 472         swf_GetU16(tag);
 473         if(morph)
 474             swf_GetU16(tag);
 475         if(num == 3)
 476             {swf_GetRGBA(tag, NULL);if(morph) swf_GetRGBA(tag, NULL);}
 477         else
 478             {swf_GetRGB(tag, NULL);if(morph) swf_GetRGB(tag, NULL);}
 479     }
 480 }
 481
 482 void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), void*callback_data)
 483 {
 484     int num = 1;
 485     swf_ResetReadBits(tag);
 486     tag->pos = 0;
 487     switch(tag->id)
 488     {
 489         case ST_DEFINEBUTTONSOUND: {
 490             int t;
 491             callback(tag, tag->pos + base, callback_data);
 492             for(t=0;t<4;t++) {
 493                 int flags;
 494                 callback(tag, tag->pos + base, callback_data);
 495                 swf_GetU16(tag); //sound id
 496                 flags = swf_GetU8(tag);
 497                 if(flags&1)
 498                     swf_GetU32(tag); // in point
 499                 if(flags&2)
 500                     swf_GetU32(tag); // out points
 501                 if(flags&4)
 502                     swf_GetU16(tag); // loop count
 503                 if(flags&8)
 504                 {
 505                     int npoints = swf_GetU8(tag);
 506                     int s;
 507                     for(s=0;s<npoints;s++)
 508                     {
 509                         swf_GetU32(tag);
 510                         swf_GetU16(tag);
 511                         swf_GetU16(tag);
 512                     }
 513                 }
 514             }
 515         } break;
 516         case ST_DEFINEBUTTONCXFORM:
 517             callback(tag, tag->pos + base, callback_data); //button id
 518         break;
 519
 520         case ST_EXPORTASSETS: {
 521             int num =  swf_GetU16(tag);
 522             int t;
 523             for(t=0;t<num;t++) {
 524                 callback(tag, tag->pos + base, callback_data); //button id
 525                 swf_GetU16(tag); //id
 526                 while(swf_GetU8(tag)); //name
 527             }
 528         } break;
 529
 530         case ST_FREECHARACTER: /* unusual tags, which all start with an ID */
 531         case ST_NAMECHARACTER:
 532         case ST_GENERATORTEXT:
 533             callback(tag, tag->pos + base, callback_data);
 534         break;
 535         case ST_PLACEOBJECT:
 536             callback(tag, tag->pos + base, callback_data);
 537         break;
 538         case ST_PLACEOBJECT2:
 539             // only if placeflaghascharacter
 540             if(!(tag->data[0]&2))
 541                 break;
 542             callback(tag, 3 + base, callback_data);
 543         break;
 544         case ST_REMOVEOBJECT:
 545             callback(tag, tag->pos + base, callback_data);
 546         break;
 547         case ST_STARTSOUND:
 548             callback(tag, tag->pos + base, callback_data);
 549         break;
 550         case ST_DEFINESPRITE: {
 551             if(tag->len <= 4)
 552                 break; // sprite is expanded
 553
 554             swf_GetU16(tag); // id
 555             swf_GetU16(tag); // framenum
 556
 557             while(1) {
 558                 U16 flags = swf_GetU16(tag);
 559                 U32 len;
 560                 U16 id = flags>>6;
 561                 TAG *tag2 = swf_InsertTag(NULL, id);
 562                 len = flags&0x3f;
 563                 if(len == 63)
 564                     len = swf_GetU32(tag);
 565                 if(id == ST_END)
 566                     break;
 567                 tag2->len = tag2->memsize = len;
 568                 tag2->data = rfx_alloc(len);
 569                 memcpy(tag2->data, &tag->data[tag->pos], len);
 570                 /* I never saw recursive sprites, but they are (theoretically)
 571                    possible, so better add base here again */
 572                 enumerateUsedIDs(tag2, tag->pos + base, callback, callback_data);
 573                 swf_DeleteTag(tag2);
 574                 swf_GetBlock(tag, NULL, len);
 575             }
 576         }
 577         break;
 578         case ST_DEFINEBUTTON2: // has some font ids in the button records
 579             num++;
 580         //fallthrough
 581         case ST_DEFINEBUTTON: {
 582             swf_GetU16(tag); //button id
 583             if(num>1)
 584             {
 585                 int offset;
 586                 swf_GetU8(tag); //flag
 587                 offset = swf_GetU16(tag); //offset
 588             }
 589             while(1)
 590             {
 591                 U16 charid;
 592                 if(!swf_GetU8(tag)) //flags
 593                     break;
 594                 callback(tag, tag->pos + base, callback_data);
 595                 swf_GetU16(tag); //char
 596                 swf_GetU16(tag); //layer
 597                 swf_ResetReadBits(tag);
 598                 swf_GetMatrix(tag, NULL);
 599                 if(num>1) {
 600                   swf_ResetReadBits(tag);
 601                   swf_GetCXForm(tag, NULL, 1);
 602                 }
 603             }
 604             // ...
 605         }
 606         break;
 607         case ST_DEFINEEDITTEXT:  {
 608             U8 flags1,flags2;
 609             swf_GetU16(tag); //id
 610             swf_GetRect(tag, NULL); //bounding box
 611             swf_ResetReadBits(tag);
 612             flags1 = swf_GetU8(tag);
 613             flags2 = swf_GetU8(tag);
 614             if(flags1 & 1)
 615                 callback(tag, tag->pos + base, callback_data);
 616         }
 617         break;
 618         case ST_DEFINETEXT2:
 619             num ++;
 620         case ST_DEFINETEXT: {
 621             int glyphbits, advancebits;
 622             int id;
 623             id = swf_GetU16(tag); //id
 624             swf_GetRect(tag, NULL); //bounding box
 625             swf_ResetReadBits(tag);
 626             swf_GetMatrix(tag, NULL); //matrix
 627             swf_ResetReadBits(tag);
 628             glyphbits = swf_GetU8(tag); //glyphbits
 629             advancebits = swf_GetU8(tag); //advancebits
 630             while(1) {
 631                 U16 flags;
 632                 int t;
 633                 swf_ResetReadBits(tag);
 634                 flags = swf_GetBits(tag, 8);
 635                 if(!flags) break;
 636
 637                 swf_ResetReadBits(tag);
 638                 if(flags & 8) { // hasfont
 639                     callback(tag, tag->pos + base, callback_data);
 640                     id = swf_GetU16(tag);
 641                 }
 642                 if(flags & 4) { // hascolor
 643                     if(num==1) swf_GetRGB(tag, NULL);
 644                     else       swf_GetRGBA(tag, NULL);
 645                 }
 646                 if(flags & 2) { //has x offset
 647                     swf_ResetReadBits(tag);
 648                     swf_GetU16(tag);
 649                 }
 650                 if(flags & 1) { //has y offset
 651                     swf_ResetReadBits(tag);
 652                     swf_GetU16(tag);
 653                 }
 654                 if(flags & 8) { //has height
 655                     swf_ResetReadBits(tag);
 656                     swf_GetU16(tag);
 657                 }
 658
 659                 flags = swf_GetBits(tag, 8);
 660                 if(!flags) break;
 661                 swf_ResetReadBits(tag);
 662                 for(t=0;t<flags;t++) {
 663                     swf_GetBits(tag, glyphbits);
 664                     swf_GetBits(tag, advancebits);
 665                 }
 666             }
 667             break;
 668         }
 669         case ST_GLYPHNAMES:
 670         case ST_DEFINEFONTINFO:
 671         case ST_DEFINEFONTINFO2:
 672         case ST_VIDEOFRAME:
 673             callback(tag, tag->pos + base, callback_data);
 674         break;
 675         case ST_DEFINEVIDEOSTREAM:
 676         break;
 677
 678         case ST_DOINITACTION:
 679             callback(tag, tag->pos + base, callback_data);
 680         break;
 681
 682         case ST_DEFINEMORPHSHAPE:
 683         case ST_DEFINESHAPE3:
 684         num++; //fallthrough
 685         case ST_DEFINESHAPE2:
 686         num++; //fallthrough
 687         case ST_DEFINESHAPE: {
 688             int fillbits;
 689             int linebits;
 690             int id;
 691             int numshapes = 1;
 692             int morph = 0;
 693             if(tag->id == ST_DEFINEMORPHSHAPE) {
 694                 numshapes = 2;
 695                 morph = 1;
 696             }
 697
 698             id = swf_GetU16(tag); // id;
 699             swf_GetRect(tag, NULL); // bounds
 700             if(morph) {
 701                 swf_ResetReadBits(tag);
 702                 swf_GetRect(tag, NULL); // bounds2
 703                 swf_GetU32(tag); //offset to endedges
 704             }
 705
 706             DEBUG_ENUMERATE printf("Tag:%d Name:%s ID:%d\n", tag->id, swf_TagGetName(tag), id);
 707
 708             enumerateUsedIDs_styles(tag, callback, callback_data, num, morph);
 709             DEBUG_ENUMERATE printf("-------\n");
 710             while(--numshapes>=0) /* morph shapes define two shapes */
 711             {
 712                 DEBUG_ENUMERATE printf("shape:%d\n", numshapes);
 713                 fillbits = swf_GetBits(tag, 4);
 714                 linebits = swf_GetBits(tag, 4);
 715                 DEBUG_ENUMERATE printf("%d %d\n", fillbits, linebits);
 716                 swf_ResetReadBits(tag);
 717                 while(1) {
 718                     int flags;
 719                     flags = swf_GetBits(tag, 1);
 720                     if(!flags) { //style change
 721                         flags = swf_GetBits(tag, 5);
 722                         if(!flags)
 723                             break;
 724                         if(flags&1) { //move
 725                             int n = swf_GetBits(tag, 5);
 726                             int x,y;
 727                             x = swf_GetBits(tag, n); //x
 728                             y = swf_GetBits(tag, n); //y
 729                             DEBUG_ENUMERATE printf("move %f %f\n",x/20.0,y/20.0);
 730                         }
 731                         if(flags&2) { //fill0
 732                             int fill0;
 733                             fill0 = swf_GetBits(tag, fillbits);
 734                             DEBUG_ENUMERATE printf("fill0 %d\n", fill0);
 735                         }
 736                         if(flags&4) { //fill1
 737                             int fill1;
 738                             fill1 = swf_GetBits(tag, fillbits);
 739                             DEBUG_ENUMERATE printf("fill1 %d\n", fill1);
 740                         }
 741                         if(flags&8) { //linestyle
 742                             int line;
 743                             line = swf_GetBits(tag, linebits);
 744                             DEBUG_ENUMERATE printf("linestyle %d\n",line);
 745                         }
 746                         if(flags&16) {
 747                             DEBUG_ENUMERATE printf("more fillstyles\n");
 748                             enumerateUsedIDs_styles(tag, callback, callback_data, num, 0);
 749                             fillbits = swf_GetBits(tag, 4);
 750                             linebits = swf_GetBits(tag, 4);
 751                         }
 752                     } else {
 753                         flags = swf_GetBits(tag, 1);
 754                         if(flags) { //straight edge
 755                             int n = swf_GetBits(tag, 4) + 2;
 756                             if(swf_GetBits(tag, 1)) { //line flag
 757                                 int x,y;
 758                                 x = swf_GetSBits(tag, n); //delta x
 759                                 y = swf_GetSBits(tag, n); //delta y
 760                                 DEBUG_ENUMERATE printf("line %f %f\n",x/20.0,y/20.0);
 761                             } else {
 762                                 int v=swf_GetBits(tag, 1);
 763                                 int d;
 764                                 d = swf_GetSBits(tag, n); //vert/horz
 765                                 DEBUG_ENUMERATE printf("%s %f\n",v?"vertical":"horizontal", d/20.0);
 766                             }
 767                         } else { //curved edge
 768                             int n = swf_GetBits(tag, 4) + 2;
 769                             int x1,y1,x2,y2;
 770                             x1 = swf_GetSBits(tag, n);
 771                             y1 = swf_GetSBits(tag, n);
 772                             x2 = swf_GetSBits(tag, n);
 773                             y2 = swf_GetSBits(tag, n);
 774                             DEBUG_ENUMERATE printf("curve %f %f %f %f\n", x1/20.0, y1/20.0, x2/20.0, y2/20.0);
 775                         }
 776                     }
 777                 }
 778             }
 779         }
 780         break;
 781         default:
 782         break;
 783     }
 784 }
 785
 786 void callbackCount(TAG * t,int pos, void*ptr)
 787 {
 788     (*(int*)ptr)++;
 789     DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
 790 }
 791
 792 void callbackFillin(TAG * t,int pos, void*ptr)
 793 {
 794     **(int**)ptr = pos;
 795     (*(int**)ptr)++;
 796     DEBUG_ENUMERATE printf("callback(%d) %d\n", pos, *(U16*)&t->data[pos]);
 797 }
 798
 799 int swf_GetNumUsedIDs(TAG * t)
 800 {
 801     int num = 0;
 802     enumerateUsedIDs(t, 0, callbackCount, &num);
 803     return num;
 804 }
 805
 806 void swf_GetUsedIDs(TAG * t, int * positions)
 807 {
 808     int * ptr = positions;
 809     enumerateUsedIDs(t, 0, callbackFillin, &ptr);
 810 }
 811
 812 void swf_Relocate (SWF*swf, char*bitmap)
 813 {
 814     TAG*tag;
 815     int slaveids[65536];
 816     memset(slaveids, -1, sizeof(slaveids));
 817     tag = swf->firstTag;
 818     while(tag)
 819     {
 820         int num;
 821         int *ptr;
 822         int t;
 823
 824         if(swf_isDefiningTag(tag))
 825         {
 826             int newid;
 827             int id;
 828
 829             id = swf_GetDefineID(tag); //own id
 830
 831             if(!bitmap[id]) { //free
 832                 newid = id;
 833             }
 834             else {
 835                 newid = 0;
 836                 for (t=1;t<65536;t++)
 837                 {
 838                     if(!bitmap[t])
 839                     {
 840                         newid = t;
 841                         break;
 842                     }
 843                 }
 844             }
 845             bitmap[newid] = 1;
 846             slaveids[id] = newid;
 847
 848             swf_SetDefineID(tag, newid);
 849         }
 850
 851         num = swf_GetNumUsedIDs(tag);
 852         if(num) {
 853             ptr = rfx_alloc(sizeof(int)*num);
 854             swf_GetUsedIDs(tag, ptr);
 855
 856             for(t=0;t<num;t++) {
 857                 int id = GET16(&tag->data[ptr[t]]);
 858                 if(slaveids[id]<0) {
 859                     fprintf(stderr, "swf_Relocate: Mapping id (%d) never encountered before in %s\n", id,
 860                             swf_TagGetName(tag));
 861                     return ;
 862                 }
 863                 id = slaveids[id];
 864                 PUT16(&tag->data[ptr[t]], id);
 865             }
 866         }
 867         tag=tag->next;
 868     }
 869 }
 870
 871 void swf_RelocateDepth(SWF*swf, char*bitmap)
 872 {
 873     TAG*tag;
 874     int nr;
 875     tag = swf->firstTag;
 876     for(nr=65535;nr>=0;nr--) {
 877         if(bitmap[nr] != 0)
 878             break;
 879     }
 880     // now nr is the highest used depth. So we start
 881     // assigning depths at nr+1
 882     nr++;
 883
 884     while(tag)
 885     {
 886         /* TODO * clip depths
 887                 * sprites
 888          */
 889         int depth = swf_GetDepth(tag);
 890         if(depth>=0) {
 891             int newdepth = depth+nr;
 892             if(newdepth>65535) {
 893                 fprintf(stderr, "Couldn't relocate depths: too large values\n");
 894                 newdepth = 65535;
 895             }
 896             swf_SetDepth(tag, newdepth);
 897         }
 898         tag=tag->next;
 899     }
 900 }
 901
 902 U8 swf_isShapeTag(TAG*tag)
 903 {
 904     if(tag->id == ST_DEFINESHAPE ||
 905        tag->id == ST_DEFINESHAPE2 ||
 906        tag->id == ST_DEFINESHAPE3)
 907         return 1;
 908     return 0;
 909 }
 910
 911 U8 swf_isPlaceTag(TAG*tag)
 912 {
 913     if(tag->id == ST_PLACEOBJECT ||
 914        tag->id == ST_PLACEOBJECT2)
 915         return 1;
 916     return 0;
 917 }
 918 U8 swf_isTextTag(TAG*tag)
 919 {
 920     if(tag->id == ST_DEFINETEXT ||
 921        tag->id == ST_DEFINETEXT2)
 922         return 1;
 923     return 0;
 924 }
 925
 926 U8 swf_isFontTag(TAG*tag)
 927 {
 928     if(tag->id == ST_DEFINEFONT ||
 929        tag->id == ST_DEFINEFONT2 ||
 930        tag->id == ST_DEFINEFONTINFO)
 931         return 1;
 932     return 0;
 933 }
 934
 935 U8  swf_isImageTag(TAG*tag)
 936 {
 937     if(tag->id == ST_DEFINEBITSJPEG ||
 938        tag->id == ST_DEFINEBITSJPEG2 ||
 939        tag->id == ST_DEFINEBITSJPEG3 ||
 940        tag->id == ST_DEFINEBITSLOSSLESS ||
 941        tag->id == ST_DEFINEBITSLOSSLESS2)
 942         return 1;
 943     return 0;
 944 }
 945
 946 TAG* swf_Concatenate (TAG*list1,TAG*list2)
 947 {
 948     TAG*tag=0,*lasttag=0;
 949     char bitmap[65536];
 950     char depthmap[65536];
 951     SWF swf1,swf2;
 952     memset(bitmap, 0, sizeof(bitmap));
 953     memset(depthmap, 0, sizeof(depthmap));
 954     memset(&swf1, 0, sizeof(swf1));
 955     memset(&swf2, 0, sizeof(swf2));
 956
 957     swf1.firstTag = list1;
 958     swf_FoldAll(&swf1);
 959     swf2.firstTag = list2;
 960     swf_FoldAll(&swf2);
 961
 962     tag = list1;
 963     while(tag) {
 964         if(!swf_isDefiningTag(tag)) {
 965             int id = swf_GetDefineID(tag);
 966             bitmap[id] = 1;
 967         }
 968         if(tag->id == ST_PLACEOBJECT ||
 969            tag->id == ST_PLACEOBJECT2) {
 970             int depth = swf_GetDepth(tag);
 971             depthmap[depth] = 1;
 972         }
 973         if(tag->id == ST_REMOVEOBJECT ||
 974            tag->id == ST_REMOVEOBJECT2) {
 975             int depth = swf_GetDepth(tag);
 976             depthmap[depth] = 0;
 977         }
 978         tag = tag->next;
 979         lasttag = tag;
 980     }
 981     swf_Relocate(&swf2, bitmap);
 982     swf_RelocateDepth(&swf2, depthmap);
 983     lasttag->next = swf2.firstTag;
 984     swf2.firstTag->prev = lasttag;
 985
 986     return swf1.firstTag;
 987 }
 988
 989 static int tagHash(TAG*tag)
 990 {
 991     int t, h=0;
 992     unsigned int a = 0x6b973e5a;
 993     /* start at pos 2, as 0 and 1 are the id */
 994     for(t=2;t<tag->len;t++) {
 995         unsigned int b = a;
 996         a >>= 8;
 997         a += tag->data[t]*0xefbc35a5*b*(t+1);
 998     }
 999     return a&0x7fffffff; //always return positive number
1000 }
1001
1002 void swf_Optimize(SWF*swf)
1003 {
1004     const int hash_size = 131072;
1005     char* dontremap = rfx_calloc(sizeof(char)*65536);
1006     U16* remap = rfx_alloc(sizeof(U16)*65536);
1007     TAG* id2tag = rfx_calloc(sizeof(TAG*)*65536);
1008     TAG** hashmap = rfx_calloc(sizeof(TAG*)*hash_size);
1009     TAG* tag;
1010     int t;
1011     for(t=0;t<65536;t++) {
1012         remap[t] = t;
1013     }
1014
1015     swf_FoldAll(swf);
1016
1017     tag = swf->firstTag;
1018     while(tag) {
1019         /* make sure we don't remap to this tag,
1020            as it might have different "helper tags"
1021            FIXME: a better way would be to compare
1022                   the helper tags, too.
1023          */
1024         if(swf_isPseudoDefiningTag(tag) &&
1025            tag->id != ST_NAMECHARACTER) {
1026             dontremap[swf_GetDefineID(tag)] = 1;
1027         }
1028         tag=tag->next;
1029     }
1030     tag = swf->firstTag;
1031     while(tag) {
1032         int doremap=1;
1033
1034         TAG*next = tag->next;
1035
1036         /* remap the tag */
1037         int num = swf_GetNumUsedIDs(tag);
1038         int*positions = rfx_alloc(sizeof(int)*num);
1039         int t;
1040         swf_GetUsedIDs(tag, positions);
1041         for(t=0;t<num;t++) {
1042             int id = GET16(&tag->data[positions[t]]);
1043             id = remap[id];
1044             PUT16(&tag->data[positions[t]], id);
1045         }
1046         rfx_free(positions);
1047         tag = tag->next;
1048
1049         /* now look for previous tags with the same
1050            content */
1051         if(swf_isDefiningTag(tag)) {
1052             TAG*tag2;
1053             int id = swf_GetDefineID(tag);
1054             int hash = tagHash(tag);
1055             int match=0;
1056             if(!dontremap[id])
1057             while((tag2 = hashmap[hash%hash_size])) {
1058                 if(tag2 != (TAG*)(-1) && tag->len == tag2->len) {
1059                     int t;
1060                     /* start at pos 2, as 0 and 1 are the id */
1061                     for(t=2;t<tag->len;t++) {
1062                         if(tag->data[t] != tag2->data[t])
1063                             break;
1064                     }
1065                     if(t == tag->len) {
1066                         match=1;
1067                     }
1068                 }
1069                 if(match) {
1070                     /* we found two identical tags- remap one
1071                        of them */
1072                     remap[id] = swf_GetDefineID(tag2);
1073                     break;
1074                 }
1075                 hash++;
1076             }
1077             if(!match) {
1078                 while(hashmap[hash%hash_size]) hash++;
1079                 hashmap[hash%hash_size] = tag;
1080             } else {
1081                 swf_DeleteTag(tag);
1082                 if(tag == swf->firstTag)
1083                     swf->firstTag = next;
1084                 doremap = 0;
1085             }
1086         } else if(swf_isPseudoDefiningTag(tag)) {
1087             int id = swf_GetDefineID(tag);
1088             if(remap[id]!=id) {
1089                 /* if this tag was remapped, we don't
1090                    need the helper tag anymore. Discard
1091                    it. */
1092                 swf_DeleteTag(tag);
1093                 if(tag == swf->firstTag)
1094                     swf->firstTag = next;
1095                 doremap = 0;
1096             }
1097         }
1098
1099         tag = next;
1100     }
1101     rfx_free(dontremap);
1102     rfx_free(remap);
1103     rfx_free(id2tag);
1104     rfx_free(hashmap);
1105 }
1106
1107 void swf_SetDefineBBox(TAG * tag, SRECT newbbox)
1108 {
1109     U16 id = 0;
1110     SRECT b1;
1111     swf_SetTagPos(tag,0);
1112
1113     switch (swf_GetTagID(tag))
1114     {
1115         case ST_DEFINESHAPE:
1116         case ST_DEFINESHAPE2:
1117         case ST_DEFINESHAPE3:
1118         case ST_DEFINEEDITTEXT:
1119         case ST_DEFINETEXT:
1120         case ST_DEFINETEXT2:
1121         case ST_DEFINEVIDEOSTREAM: {
1122               U32 after_bbox_offset = 0, len;
1123               U8*data;
1124               id = swf_GetU16(tag);
1125               swf_GetRect(tag, &b1);
1126               swf_ResetReadBits(tag);
1127               after_bbox_offset = tag->pos;
1128               len = tag->len - after_bbox_offset;
1129               data = malloc(len);
1130               memcpy(data, &tag->data[after_bbox_offset], len);
1131               tag->writeBit = 0;
1132               tag->len = 2;
1133               swf_SetRect(tag, &newbbox);
1134               swf_SetBlock(tag, data, len);
1135               free(data);
1136               tag->pos = tag->readBit = 0;
1137
1138         } break;
1139         default:
1140             fprintf(stderr, "rfxswf: Tag %d (%s) has no bbox\n", tag->id, swf_TagGetName(tag));
1141     }
1142 }
1143
1144 RGBA swf_GetSWFBackgroundColor(SWF*swf)
1145 {
1146     TAG*t=swf->firstTag;
1147     RGBA color;
1148     color.r = color.b = color.g = 0;
1149     color.a = 255;
1150     while(t) {
1151         if(t->id == ST_SETBACKGROUNDCOLOR) {
1152             swf_SetTagPos(t, 0);
1153             color.r = swf_GetU8(t);
1154             color.g = swf_GetU8(t);
1155             color.b = swf_GetU8(t);
1156             break;
1157         }
1158         t=t->next;
1159     }
1160     return color;
1161 }
1162