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