lib/rfxswf.c

   1 /* vi: set sts=2 sw=2 :*/
   2 /* rfxswf.c
   3
   4    Library for creating and reading SWF files or parts of it.
   5    There's a module directory which provides some extended functionality.
   6    Most modules are included at the bottom of this file.
   7
   8    Part of the swftools package.
   9
  10    Copyright (c) 2000-2003 Rainer Böhme <rfxswf@reflex-studio.de>
  11    Copyright (c) 2003 Matthias Kramm <kramm@quiss.org>
  12
  13    This program is free software; you can redistribute it and/or modify
  14    it under the terms of the GNU General Public License as published by
  15    the Free Software Foundation; either version 2 of the License, or
  16    (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  26
  27 #include "rfxswf.h"
  28
  29 #ifdef HAVE_JPEGLIB
  30 #define HAVE_BOOLEAN
  31 #include <jpeglib.h>
  32 #endif // HAVE_JPEGLIB
  33
  34 #ifdef HAVE_ZLIB
  35 #include <zlib.h>
  36 #endif // HAVE_ZLIB
  37
  38 #ifndef RFXSWF_DISABLESOUND
  39 #ifdef HAVE_LAME
  40 #include "lame/lame.h"
  41 #endif
  42 #endif
  43
  44 #ifdef HAVE_TIME_H
  45 #include <time.h>
  46 #endif
  47
  48 #include "./bitio.h"
  49 #include "./MD5.h"
  50
  51 // internal constants
  52
  53 #define MALLOC_SIZE     128
  54 #define INSERT_RFX_TAG
  55
  56 #define MEMSIZE(l) (((l/MALLOC_SIZE)+1)*MALLOC_SIZE)
  57
  58
  59 // inline wrapper functions
  60
  61 TAG * swf_NextTag(TAG * t) { return t->next; }
  62 TAG * swf_PrevTag(TAG * t) { return t->prev; }
  63 U16   swf_GetTagID(TAG * t)    { return t->id; }
  64 U32   swf_GetTagLen(TAG * t) { return t->len; }
  65 U8*   swf_GetTagLenPtr(TAG * t) { return &(t->data[t->len]); }
  66 U32   swf_GetTagPos(TAG * t)   { return t->pos; }
  67
  68 // Basic Data Access Functions
  69
  70 #define swf_ResetReadBits(tag)   if (tag->readBit)  { tag->pos++; tag->readBit = 0; }
  71 #define swf_ResetWriteBits(tag)  if (tag->writeBit) { tag->writeBit = 0; }
  72
  73 // for future purpose: avoid high level lib functions to change tagpos/bitpos
  74
  75 #define swf_SaveTagPos(tag)
  76 #define swf_RestoreTagPos(tag)
  77
  78 void swf_SetTagPos(TAG * t,U32 pos)
  79 { swf_ResetReadBits(t);
  80   if (pos<=t->len) t->pos = pos;
  81   #ifdef DEBUG_RFXSWF
  82   else fprintf(stderr,"SetTagPos() out of bounds: TagID = %i\n",t->id);
  83   #endif
  84 }
  85
  86 char* swf_GetString(TAG*t)
  87 {
  88     char* str = ((char*)(&(t)->data[(t)->pos]));
  89     while(swf_GetU8(t));
  90     return str;
  91 }
  92
  93 U8 swf_GetU8(TAG * t)
  94 { swf_ResetReadBits(t);
  95   #ifdef DEBUG_RFXSWF
  96     if (t->pos>=t->len)
  97     { fprintf(stderr,"GetU8() out of bounds: TagID = %i\n",t->id);
  98       return 0;
  99     }
 100   #endif
 101   return t->data[t->pos++];
 102 }
 103
 104 U16 swf_GetU16(TAG * t)
 105 { U16 res;
 106   swf_ResetReadBits(t);
 107   #ifdef DEBUG_RFXSWF
 108     if (t->pos>(t->len-2))
 109     { fprintf(stderr,"GetU16() out of bounds: TagID = %i\n",t->id);
 110       return 0;
 111     }
 112   #endif
 113   res = t->data[t->pos] | (t->data[t->pos+1]<<8);
 114   t->pos+=2;
 115   return res;
 116 }
 117
 118 U32 swf_GetU32(TAG * t)
 119 { U32 res;
 120   swf_ResetReadBits(t);
 121   #ifdef DEBUG_RFXSWF
 122     if (t->pos>(t->len-4))
 123     { fprintf(stderr,"GetU32() out of bounds: TagID = %i\n",t->id);
 124       return 0;
 125     }
 126   #endif
 127   res = t->data[t->pos]        | (t->data[t->pos+1]<<8) |
 128        (t->data[t->pos+2]<<16) | (t->data[t->pos+3]<<24);
 129   t->pos+=4;
 130   return res;
 131 }
 132
 133 int swf_GetBlock(TAG * t,U8 * b,int l)
 134 // returns number of bytes written (<=l)
 135 // b = NULL -> skip data
 136 { swf_ResetReadBits(t);
 137   if ((t->len-t->pos)<l) l=t->len-t->pos;
 138   if (b && l) memcpy(b,&t->data[t->pos],l);
 139   t->pos+=l;
 140   return l;
 141 }
 142
 143 int swf_SetBlock(TAG * t,U8 * b,int l)
 144 // Appends Block to the end of Tagdata, returns size
 145 { U32 newlen = t->len + l;
 146   swf_ResetWriteBits(t);
 147   if (newlen>t->memsize)
 148   { U32  newmem  = MEMSIZE(newlen);
 149     U8 * newdata = (U8*)((t->data)?realloc(t->data,newmem):malloc(newmem));
 150     if (!newdata)
 151     {
 152       #ifdef DEBUG_RFXSWF
 153         fprintf(stderr,"Fatal Error: malloc()/realloc() failed (1). (%d bytes)\n", newmem);
 154         *(int*)0=0;
 155       #endif
 156       return 0;
 157     }
 158     t->memsize = newmem;
 159     t->data    = newdata;
 160   }
 161   if (b) memcpy(&t->data[t->len],b,l);
 162   else memset(&t->data[t->len],0x00,l);
 163   t->len+=l;
 164   return l;
 165 }
 166
 167 int swf_SetU8(TAG * t,U8 v)
 168 { swf_ResetWriteBits(t);
 169   if ((t->len+1)>t->memsize) return (swf_SetBlock(t,&v,1)==1)?0:-1;
 170   t->data[t->len++] = v;
 171   return 0;
 172 }
 173
 174 int swf_SetU16(TAG * t,U16 v)
 175 { U8 a[2];
 176   a[0] = v&0xff;
 177   a[1] = v>>8;
 178
 179   swf_ResetWriteBits(t);
 180   if ((t->len+2)>t->memsize) return (swf_SetBlock(t,a,2)==2)?0:-1;
 181   t->data[t->len++] = a[0];
 182   t->data[t->len++] = a[1];
 183   return 0;
 184 }
 185
 186 int swf_SetU32(TAG * t,U32 v)
 187 { U8 a[4];
 188   a[0] = v&0xff;        // to ensure correct handling of non-intel byteorder
 189   a[1] = (v>>8)&0xff;
 190   a[2] = (v>>16)&0xff;
 191   a[3] = (v>>24)&0xff;
 192
 193   swf_ResetWriteBits(t);
 194   if ((t->len+4)>t->memsize) return (swf_SetBlock(t,a,4)==4)?0:-1;
 195   t->data[t->len++] = a[0];
 196   t->data[t->len++] = a[1];
 197   t->data[t->len++] = a[2];
 198   t->data[t->len++] = a[3];
 199   return 0;
 200 }
 201
 202 U32 swf_GetBits(TAG * t,int nbits)
 203 { U32 res = 0;
 204   if (!nbits) return 0;
 205   if (!t->readBit) t->readBit = 0x80;
 206   while (nbits)
 207   { res<<=1;
 208     if (t->data[t->pos]&t->readBit) res|=1;
 209     t->readBit>>=1;
 210     nbits--;
 211     if (!t->readBit)
 212     { if (nbits) t->readBit = 0x80;
 213       #ifdef DEBUG_RFXSWF
 214       if (t->pos>=t->len)
 215       { fprintf(stderr,"GetBits() out of bounds: TagID = %i\n",t->id);
 216         return res;
 217       }
 218       #endif
 219       t->pos++;
 220     }
 221   }
 222   return res;
 223 }
 224
 225 S32 swf_GetSBits(TAG * t,int nbits)
 226 { U32 res = swf_GetBits(t,nbits);
 227   if (res&(1<<(nbits-1))) res|=(0xffffffff<<nbits);
 228   return (S32)res;
 229 }
 230
 231 U32 reader_GetBits(struct reader_t*reader, int nbits)
 232 { return reader_readbits(reader, nbits);
 233 }
 234 S32 reader_GetSBits(struct reader_t*reader, int nbits)
 235 { U32 res = reader_readbits(reader, nbits);
 236   if (res&(1<<(nbits-1))) res|=(0xffffffff<<nbits);
 237   return (S32)res;
 238 }
 239
 240 int swf_SetBits(TAG * t,U32 v,int nbits)
 241 { U32 bm = 1<<(nbits-1);
 242
 243   while (nbits)
 244   { if (!t->writeBit)
 245     { if (FAILED(swf_SetU8(t,0))) return -1;
 246       t->writeBit = 0x80;
 247     }
 248     if (v&bm) t->data[t->len-1] |= t->writeBit;
 249     bm>>=1;
 250     t->writeBit>>=1;
 251     nbits--;
 252   }
 253   return 0;
 254 }
 255
 256 // Advanced Data Access Functions
 257
 258 int swf_SetRGB(TAG * t,RGBA * col)
 259 { if (!t) return -1;
 260   if (col)
 261   { swf_SetU8(t,col->r);
 262     swf_SetU8(t,col->g);
 263     swf_SetU8(t,col->b);
 264   } else swf_SetBlock(t,NULL,3);
 265   return 0;
 266 }
 267 void swf_GetRGB(TAG * t, RGBA * col)
 268 {
 269     RGBA dummy;
 270     if(!col)
 271         col = &dummy;
 272     col->r = swf_GetU8(t);
 273     col->g = swf_GetU8(t);
 274     col->b = swf_GetU8(t);
 275     col->a = 255;
 276 }
 277
 278 int swf_SetRGBA(TAG * t,RGBA * col)
 279 { if (!t) return -1;
 280   if (col)
 281   { swf_SetU8(t,col->r);
 282     swf_SetU8(t,col->g);
 283     swf_SetU8(t,col->b);
 284     swf_SetU8(t,col->a);
 285   } else swf_SetBlock(t,NULL,4);
 286   return 0;
 287 }
 288 void swf_GetRGBA(TAG * t, RGBA * col)
 289 {
 290     RGBA dummy;
 291     if(!col);
 292         col = &dummy;
 293     col->r = swf_GetU8(t);
 294     col->g = swf_GetU8(t);
 295     col->b = swf_GetU8(t);
 296     col->a = swf_GetU8(t);
 297 }
 298
 299 void swf_GetGradient(TAG * tag, GRADIENT * gradient, char alpha)
 300 {
 301     GRADIENT dummy;
 302     int t;
 303     if(!tag) {
 304       memset(gradient, 0, sizeof(GRADIENT));
 305       return;
 306     }
 307     if(!gradient)
 308         gradient = &dummy;
 309     gradient->num = swf_GetU8(tag);
 310     for(t=0;t<gradient->num;t++)
 311     {
 312         int s=t;
 313         if(s>=8) //FIXME
 314             s=7;
 315         gradient->ratios[t] = swf_GetU8(tag);
 316         if(!alpha)
 317             swf_GetRGB(tag, &gradient->rgba[t]);
 318         else
 319             swf_GetRGBA(tag, &gradient->rgba[t]);
 320     }
 321 }
 322
 323 void swf_SetGradient(TAG * tag, GRADIENT * gradient, char alpha)
 324 {
 325     int t;
 326     if(!tag) {
 327       memset(gradient, 0, sizeof(GRADIENT));
 328       return;
 329     }
 330     swf_SetU8(tag, gradient->num);
 331     for(t=0; t<8 && t<gradient->num; t++)
 332     {
 333         swf_SetU8(tag, gradient->ratios[t]);
 334         if(!alpha)
 335             swf_SetRGB(tag, &gradient->rgba[t]);
 336         else
 337             swf_SetRGBA(tag, &gradient->rgba[t]);
 338     }
 339 }
 340
 341 int swf_CountUBits(U32 v,int nbits)
 342 { int n = 32;
 343   U32 m = 0x80000000;
 344   if(v == 0x00000000) n = 0;
 345   else
 346     while (!(v&m))
 347     { n--;
 348       m>>=1;
 349     }
 350   return (n>nbits)?n:nbits;
 351 }
 352
 353 int swf_CountBits(U32 v,int nbits)
 354 { int n = 33;
 355   U32 m = 0x80000000;
 356   if (v&m)
 357   { if(v == 0xffffffff) n = 1;
 358     else
 359     while (v&m)
 360     { n--;
 361       m>>=1;
 362     }
 363   }
 364   else
 365   { if(v == 0x00000000) n = 0;
 366     else
 367     while (!(v&m))
 368     { n--;
 369       m>>=1;
 370     }
 371   }
 372   return (n>nbits)?n:nbits;
 373 }
 374
 375 int swf_GetRect(TAG * t,SRECT * r)
 376 { int nbits;
 377   SRECT dummy;
 378   if(!t) {r->xmin=r->xmax=r->ymin=r->ymax=0;return 0;}
 379   if (!r) r = &dummy;
 380   nbits = (int) swf_GetBits(t,5);
 381   r->xmin = swf_GetSBits(t,nbits);
 382   r->xmax = swf_GetSBits(t,nbits);
 383   r->ymin = swf_GetSBits(t,nbits);
 384   r->ymax = swf_GetSBits(t,nbits);
 385   return 0;
 386 }
 387
 388 int reader_GetRect(struct reader_t*reader,SRECT * r)
 389 { int nbits;
 390   SRECT dummy;
 391   if (!r) r = &dummy;
 392   nbits = (int) reader_GetBits(reader,5);
 393   r->xmin = reader_GetSBits(reader,nbits);
 394   r->xmax = reader_GetSBits(reader,nbits);
 395   r->ymin = reader_GetSBits(reader,nbits);
 396   r->ymax = reader_GetSBits(reader,nbits);
 397   return 0;
 398 }
 399
 400 int swf_SetRect(TAG * t,SRECT * r)
 401 { int nbits;
 402
 403   nbits = swf_CountBits(r->xmin,0);
 404   nbits = swf_CountBits(r->xmax,nbits);
 405   nbits = swf_CountBits(r->ymin,nbits);
 406   nbits = swf_CountBits(r->ymax,nbits);
 407   if(nbits>=32) {
 408     fprintf(stderr, "rfxswf: Warning: num_bits overflow in swf_SetRect\n");
 409     nbits=31;
 410   }
 411
 412   swf_SetBits(t,nbits,5);
 413   swf_SetBits(t,r->xmin,nbits);
 414   swf_SetBits(t,r->xmax,nbits);
 415   swf_SetBits(t,r->ymin,nbits);
 416   swf_SetBits(t,r->ymax,nbits);
 417
 418   return 0;
 419 }
 420
 421 void swf_ExpandRect(SRECT*src, SPOINT add)
 422 {
 423     if(add.x < src->xmin)
 424         src->xmin = add.x;
 425     if(add.x > src->xmax)
 426         src->xmax = add.x;
 427     if(add.y < src->ymin)
 428         src->ymin = add.y;
 429     if(add.y > src->ymax)
 430         src->ymax = add.y;
 431 }
 432 void swf_ExpandRect2(SRECT*src, SRECT*add)
 433 {
 434     if((add->xmin | add->ymin | add->xmax | add->ymax)==0)
 435         return;
 436     if(add->xmin < src->xmin)
 437         src->xmin = add->xmin;
 438     if(add->ymin < src->ymin)
 439         src->ymin = add->ymin;
 440     if(add->xmax > src->xmax)
 441         src->xmax = add->xmax;
 442     if(add->ymax > src->ymax)
 443         src->ymax = add->ymax;
 444 }
 445 SPOINT swf_TurnPoint(SPOINT p, MATRIX* m)
 446 {
 447     SPOINT r;
 448     r.x = (int)(m->sx*(1/65536.0)*p.x + m->r1*(1/65536.0)*p.y + 0.5) + m->tx;
 449     r.y = (int)(m->r0*(1/65536.0)*p.x + m->sy*(1/65536.0)*p.y + 0.5) + m->ty;
 450     return r;
 451 }
 452 SRECT swf_TurnRect(SRECT r, MATRIX* m)
 453 {
 454     SRECT g;
 455     SPOINT p1,p2,p3,p4,pp1,pp2,pp3,pp4;
 456     p1.x = r.xmin;p1.y = r.ymin;
 457     p2.x = r.xmax;p2.y = r.ymin;
 458     p3.x = r.xmin;p3.y = r.ymax;
 459     p4.x = r.xmax;p4.y = r.ymax;
 460     pp1 = swf_TurnPoint(p1, m);
 461     pp2 = swf_TurnPoint(p2, m);
 462     pp3 = swf_TurnPoint(p3, m);
 463     pp4 = swf_TurnPoint(p4, m);
 464     g.xmin = g.xmax = pp1.x;
 465     g.ymin = g.ymax = pp1.y;
 466     swf_ExpandRect(&g, pp2);
 467     swf_ExpandRect(&g, pp3);
 468     swf_ExpandRect(&g, pp4);
 469     return g;
 470 }
 471
 472
 473 int swf_GetMatrix(TAG * t,MATRIX * m)
 474 { MATRIX dummy;
 475   int nbits;
 476
 477   if (!m) m = &dummy;
 478
 479   if (!t)
 480   { m->sx = m->sy = 0x10000;
 481     m->r0 = m->r1 = 0;
 482     m->tx = m->ty = 0;
 483     return -1;
 484   }
 485
 486   swf_ResetReadBits(t);
 487
 488   if (swf_GetBits(t,1))
 489   { nbits = swf_GetBits(t,5);
 490     m->sx = swf_GetSBits(t,nbits);
 491     m->sy = swf_GetSBits(t,nbits);
 492   }
 493   else m->sx = m->sy = 0x10000;
 494
 495   if (swf_GetBits(t,1))
 496   { nbits = swf_GetBits(t,5);
 497     m->r0 = swf_GetSBits(t,nbits);
 498     m->r1 = swf_GetSBits(t,nbits);
 499   }
 500   else m->r0 = m->r1 = 0x0;
 501
 502   nbits = swf_GetBits(t,5);
 503   m->tx = swf_GetSBits(t,nbits);
 504   m->ty = swf_GetSBits(t,nbits);
 505
 506   return 0;
 507 }
 508
 509 int swf_SetMatrix(TAG * t,MATRIX * m)
 510 { int nbits;
 511   MATRIX ma;
 512
 513   if (!m)
 514   { m = &ma;
 515     ma.sx = ma.sy = 0x10000;
 516     ma.r0 = ma.r1 = 0;
 517     ma.tx = ma.ty = 0;
 518   }
 519
 520   swf_ResetWriteBits(t);
 521
 522   if ((m->sx==0x10000)&&(m->sy==0x10000)) swf_SetBits(t,0,1);
 523   else
 524   { swf_SetBits(t,1,1);
 525     nbits = swf_CountBits(m->sx,0);
 526     nbits = swf_CountBits(m->sy,nbits);
 527     if(nbits>=32) {
 528         fprintf(stderr,"rfxswf: Error: matrix values too large\n");
 529         nbits = 31;
 530     }
 531     swf_SetBits(t,nbits,5);
 532     swf_SetBits(t,m->sx,nbits);
 533     swf_SetBits(t,m->sy,nbits);
 534   }
 535
 536   if ((!m->r0)&&(!m->r1)) swf_SetBits(t,0,1);
 537   else
 538   { swf_SetBits(t,1,1);
 539     nbits = swf_CountBits(m->r0,0);
 540     nbits = swf_CountBits(m->r1,nbits);
 541     if(nbits>=32) {
 542         fprintf(stderr,"rfxswf: Error: matrix values too large\n");
 543         nbits = 31;
 544     }
 545     swf_SetBits(t,nbits,5);
 546     swf_SetBits(t,m->r0,nbits);
 547     swf_SetBits(t,m->r1,nbits);
 548   }
 549
 550   nbits = swf_CountBits(m->tx,0);
 551   nbits = swf_CountBits(m->ty,nbits);
 552   if(nbits>=32) {
 553       fprintf(stderr,"rfxswf: Error: matrix values too large\n");
 554       nbits = 31;
 555   }
 556   swf_SetBits(t,nbits,5);
 557   swf_SetBits(t,m->tx,nbits);
 558   swf_SetBits(t,m->ty,nbits);
 559
 560   return 0;
 561 }
 562
 563 int swf_GetCXForm(TAG * t,CXFORM * cx,U8 alpha) //FIXME: alpha should be type bool
 564 { CXFORM cxf;
 565   int hasadd;
 566   int hasmul;
 567   int nbits;
 568
 569   if (!cx) cx = &cxf;
 570
 571   cx->a0 = cx->r0 = cx->g0 = cx->b0 = 256;
 572   cx->a1 = cx->r1 = cx->g1 = cx->b1 = 0;
 573
 574   if (!t) return 0;
 575
 576   swf_ResetReadBits(t);
 577   hasadd = swf_GetBits(t,1);
 578   hasmul = swf_GetBits(t,1);
 579   nbits  = swf_GetBits(t,4);
 580
 581   if (hasmul)
 582   { cx->r0 = (S16)swf_GetSBits(t,nbits);
 583     cx->g0 = (S16)swf_GetSBits(t,nbits);
 584     cx->b0 = (S16)swf_GetSBits(t,nbits);
 585     if (alpha)
 586       cx->a0 = (S16)swf_GetSBits(t,nbits);
 587   }
 588
 589   if (hasadd)
 590   { cx->r1 = (S16)swf_GetSBits(t,nbits);
 591     cx->g1 = (S16)swf_GetSBits(t,nbits);
 592     cx->b1 = (S16)swf_GetSBits(t,nbits);
 593     if (alpha)
 594       cx->a1 = (S16)swf_GetSBits(t,nbits);
 595   }
 596
 597   return 0;
 598 }
 599
 600 int swf_SetCXForm(TAG * t,CXFORM * cx,U8 alpha)
 601 { CXFORM cxf;
 602   int hasadd;
 603   int hasmul;
 604   int nbits;
 605
 606   if (!cx)
 607   { cx = &cxf;
 608     cx->a0 = cx->r0 = cx->g0 = cx->b0 = 256;
 609     cx->a1 = cx->r1 = cx->g1 = cx->b1 = 0;
 610   }
 611
 612   if (!alpha)
 613   { cx->a0 = 256;
 614     cx->a1 = 0;
 615   }
 616
 617   nbits = 0;
 618
 619   hasmul = (cx->a0!=256)||(cx->r0!=256)||(cx->g0!=256)||(cx->b0!=256);
 620   hasadd = cx->a1|cx->r1|cx->g1|cx->b1;
 621
 622   if (hasmul)
 623   { if (alpha) nbits = swf_CountBits((S32)cx->a0,nbits);
 624     nbits = swf_CountBits((S32)cx->r0,nbits);
 625     nbits = swf_CountBits((S32)cx->g0,nbits);
 626     nbits = swf_CountBits((S32)cx->b0,nbits);
 627   }
 628
 629   if (hasadd)
 630   { if (alpha) nbits = swf_CountBits((S32)cx->a1,nbits);
 631     nbits = swf_CountBits((S32)cx->r1,nbits);
 632     nbits = swf_CountBits((S32)cx->g1,nbits);
 633     nbits = swf_CountBits((S32)cx->b1,nbits);
 634   }
 635
 636   swf_ResetWriteBits(t);
 637   swf_SetBits(t,hasadd?1:0,1);
 638   swf_SetBits(t,hasmul?1:0,1);
 639   swf_SetBits(t,nbits,4);
 640
 641   if (hasmul)
 642   { swf_SetBits(t,cx->r0,nbits);
 643     swf_SetBits(t,cx->g0,nbits);
 644     swf_SetBits(t,cx->b0,nbits);
 645     if (alpha) swf_SetBits(t,cx->a0,nbits);
 646   }
 647
 648   if (hasadd)
 649   { swf_SetBits(t,cx->r1,nbits);
 650     swf_SetBits(t,cx->g1,nbits);
 651     swf_SetBits(t,cx->b1,nbits);
 652     if (alpha) swf_SetBits(t,cx->a1,nbits);
 653   }
 654
 655   return 0;
 656 }
 657
 658 //int swf_GetPoint(TAG * t,SPOINT * p) { return 0; }
 659 //int swf_SetPoint(TAG * t,SPOINT * p) { return 0; }
 660
 661 void  swf_SetPassword(TAG * t, const char * password)
 662 {
 663     /* WARNING: crypt_md5 is not reentrant */
 664     char salt[3];
 665     char* md5string;
 666
 667 #if defined(HAVE_LRAND48) && defined(HAVE_SRAND48) && defined(HAVE_TIME_H) && defined(HAVE_TIME)
 668     srand48(time(0));
 669     salt[0] = "abcdefghijklmnopqrstuvwxyz0123456789"[lrand48()%36];
 670     salt[1] = "abcdefghijklmnopqrstuvwxyz0123456789"[lrand48()%36];
 671 #else
 672     salt[0] = 'l';
 673     salt[1] = '8';
 674     fprintf(stderr, "rfxswf: Warning- no usable random generator found\n");
 675     fprintf(stderr, "Your password will be vulnerable to dictionary attacks\n");
 676 #endif
 677
 678     md5string = crypt_md5(password, salt);
 679
 680     swf_SetU16(t,0);
 681     swf_SetString(t, md5string);
 682 }
 683
 684 int swf_VerifyPassword(TAG * t, const char * password)
 685 {
 686     char*md5string1, *md5string2;
 687     char*x;
 688     char*md5, *salt;
 689     int n;
 690
 691     if(t->len >= 5 && t->pos==0 &&
 692        t->data[0] == 0 &&
 693        t->data[1] == 0) {
 694       swf_GetU16(t);
 695     } else {
 696       printf("%d %d %d %d\n", t->len, t->pos, t->data[0], t->data[1]);
 697     }
 698
 699     md5string1 = swf_GetString(t);
 700
 701     if(strncmp(md5string1, "$1$",3 )) {
 702         fprintf(stderr, "rfxswf: no salt in pw string\n");
 703         return 0;
 704     }
 705     x = strchr(md5string1+3, '$');
 706     if(!x) {
 707         fprintf(stderr, "rfxswf: invalid salt format in pw string\n");
 708         return 0;
 709     }
 710     n = x-(md5string1+3);
 711     salt = (char*)malloc(n+1);
 712     memcpy(salt, md5string1+3, n);
 713     salt[n] = 0;
 714
 715     md5string2 = crypt_md5(password, salt);
 716     free(salt);
 717     if(strcmp(md5string1, md5string2) != 0)
 718         return 0;
 719     return 1;
 720 }
 721
 722 // Tag List Manipulating Functions
 723
 724 TAG * swf_InsertTag(TAG * after,U16 id)
 725 { TAG * t;
 726
 727   t = (TAG *)malloc(sizeof(TAG));
 728   if (t)
 729   { memset(t,0x00,sizeof(TAG));
 730     t->id = id;
 731
 732     if (after)
 733     {
 734       t->prev  = after;
 735       t->next  = after->next;
 736       after->next = t;
 737       if (t->next) t->next->prev = t;
 738     }
 739   }
 740   return t;
 741 }
 742
 743 TAG * swf_InsertTagBefore(SWF* swf, TAG * before,U16 id)
 744 { TAG * t;
 745
 746   t = (TAG *)malloc(sizeof(TAG));
 747   if (t)
 748   { memset(t,0x00,sizeof(TAG));
 749     t->id = id;
 750
 751     if (before)
 752     {
 753       t->next  = before;
 754       t->prev  = before->prev;
 755       before->prev = t;
 756       if (t->prev) t->prev->next = t;
 757     }
 758   }
 759   if(swf && swf->firstTag == before) {
 760     swf->firstTag = t;
 761   }
 762   return t;
 763 }
 764
 765 void swf_ClearTag(TAG * t)
 766 {
 767   if (t->data) free(t->data);
 768   t->data = 0;
 769   t->pos = 0;
 770   t->len = 0;
 771   t->readBit = 0;
 772   t->writeBit = 0;
 773   t->memsize = 0;
 774 }
 775
 776 void swf_ResetTag(TAG*tag, U16 id)
 777 {
 778     tag->len = tag->pos = tag->readBit = tag->writeBit = 0;
 779     tag->id = id;
 780 }
 781
 782 int swf_DeleteTag(TAG * t)
 783 { if (!t) return -1;
 784
 785   if (t->prev) t->prev->next = t->next;
 786   if (t->next) t->next->prev = t->prev;
 787
 788   if (t->data) free(t->data);
 789   free(t);
 790   return 0;
 791 }
 792
 793 TAG * swf_ReadTag(struct reader_t*reader, TAG * prev)
 794 { TAG * t;
 795   U16 raw;
 796   U32 len;
 797   int id;
 798
 799   if (reader->read(reader, &raw, 2) !=2 ) return NULL;
 800   raw = SWAP16(raw);
 801
 802   len = raw&0x3f;
 803   id  = raw>>6;
 804
 805   if (len==0x3f)
 806   {
 807       if (reader->read(reader, &len, 4) != 4) return NULL;
 808       len = SWAP32(len);
 809   }
 810
 811   if (id==ST_DEFINESPRITE) len = 2*sizeof(U16);
 812   // Sprite handling fix: Flatten sprite tree
 813
 814   t = (TAG *)malloc(sizeof(TAG));
 815
 816   if (!t)
 817   {
 818     #ifdef DEBUG_RFXSWF
 819       fprintf(stderr,"Fatal Error: malloc()/realloc() failed (2). (%d bytes)\n", sizeof(TAG));
 820     #endif
 821     return NULL;
 822   }
 823
 824   memset(t,0x00,sizeof(TAG));
 825
 826   t->len = len;
 827   t->id  = id;
 828
 829   if (t->len)
 830   { t->data = (U8*)malloc(t->len);
 831     if (!t->data)
 832     {
 833       #ifdef DEBUG_RFXSWF
 834         fprintf(stderr,"Fatal Error: malloc()/realloc() failed (3). (%d bytes)\n", t->len);
 835       #endif
 836       return NULL;
 837     }
 838     t->memsize = t->len;
 839     if (reader->read(reader, t->data, t->len) != t->len) return NULL;
 840   }
 841
 842   if (prev)
 843   {
 844     t->prev  = prev;
 845     prev->next = t;
 846   }
 847
 848   return t;
 849 }
 850
 851 int swf_DefineSprite_GetRealSize(TAG * t);
 852
 853 int swf_WriteTag2(struct writer_t*writer, TAG * t)
 854 // returns tag length in bytes (incl. Header), -1 = Error
 855 // writer = 0 -> no output
 856 { U16 raw[3];
 857   U32 len;
 858   int short_tag;
 859
 860   if (!t) return -1;
 861
 862   len = (t->id==ST_DEFINESPRITE)?swf_DefineSprite_GetRealSize(t):t->len;
 863
 864   short_tag = len<0x3f;
 865
 866   if (writer)
 867   { if (short_tag)
 868     { raw[0] = SWAP16(len|((t->id&0x3ff)<<6));
 869       if (writer->write(writer,raw,2)!=2)
 870       {
 871         #ifdef DEBUG_RFXSWF
 872           fprintf(stderr,"WriteTag() failed: Short Header.\n");
 873         #endif
 874         return -1;
 875       }
 876     }
 877     else
 878     {
 879       raw[0] = SWAP16((t->id<<6)|0x3f);
 880       if (writer->write(writer,raw,2)!=2)
 881       {
 882 #ifdef DEBUG_RFXSWF
 883           fprintf(stderr,"WriteTag() failed: Long Header (1).\n");
 884 #endif
 885           return -1;
 886       }
 887
 888       len = SWAP32(len);
 889       if (writer->write(writer,&len,4)!=4)
 890       {
 891         #ifdef DEBUG_RFXSWF
 892           fprintf(stderr,"WriteTag() failed: Long Header (2).\n");
 893         #endif
 894         return -1;
 895       }
 896     }
 897
 898     if (t->data)
 899     { if (writer->write(writer,t->data,t->len)!=t->len)
 900       {
 901         #ifdef DEBUG_RFXSWF
 902           fprintf(stderr,"WriteTag() failed: Data.\n");
 903         #endif
 904         return -1;
 905       }
 906     }
 907     #ifdef DEBUG_RFXSWF
 908       else if (t->len) fprintf(stderr,"WriteTag(): Tag Data Error, id=%i\n",t->id);
 909     #endif
 910   }
 911
 912   return t->len+(short_tag?2:6);
 913 }
 914
 915 int swf_WriteTag(int handle, TAG * t)
 916 {
 917   struct writer_t writer;
 918   int len = 0;
 919   if(handle<0)
 920     return swf_WriteTag2(0, t);
 921   writer_init_filewriter(&writer, handle);
 922   len = swf_WriteTag2(&writer, t);
 923   writer.finish(&writer);
 924   return len;
 925 }
 926
 927 int swf_DefineSprite_GetRealSize(TAG * t)
 928 // Sprite Handling: Helper function to pack DefineSprite-Tag
 929 { U32 len = t->len;
 930   if(len>4) { // folded sprite
 931       return t->len;
 932   }
 933   do
 934   { t = swf_NextTag(t);
 935     if (t && t->id!=ST_DEFINESPRITE) len += swf_WriteTag(-1, t);
 936     else t = NULL;
 937   } while (t&&(t->id!=ST_END));
 938   return len;
 939 }
 940
 941 void swf_UnFoldSprite(TAG * t)
 942 {
 943   U16 id,tmp;
 944   U32 len;
 945   TAG*next = t;
 946   U16 spriteid,spriteframes;
 947   int level;
 948   if(t->id!=ST_DEFINESPRITE)
 949     return;
 950   if(t->len<=4) // not folded
 951     return;
 952
 953   swf_SetTagPos(t,0);
 954
 955   spriteid = swf_GetU16(t); //id
 956   spriteframes = swf_GetU16(t); //frames
 957
 958   level = 1;
 959
 960   while(1)
 961   {
 962     TAG*it = 0;
 963     tmp = swf_GetU16(t);
 964     len = tmp&0x3f;
 965     id  = tmp>>6;
 966     if(id == ST_END)
 967         level--;
 968     if(id == ST_DEFINESPRITE && len<=4)
 969         level++;
 970
 971     if (len==0x3f)
 972         len = swf_GetU32(t);
 973     it = swf_InsertTag(next, id);
 974     next = it;
 975     it->len = len;
 976     it->id  = id;
 977     if (it->len)
 978     { it->data = (U8*)malloc(it->len);
 979       it->memsize = it->len;
 980       swf_GetBlock(t, it->data, it->len);
 981     }
 982
 983     if(!level)
 984         break;
 985   }
 986
 987   free(t->data); t->data = 0;
 988   t->memsize = t->len = t->pos = 0;
 989
 990   swf_SetU16(t, spriteid);
 991   swf_SetU16(t, spriteframes);
 992 }
 993
 994 void swf_FoldSprite(TAG * t)
 995 {
 996   TAG*sprtag=t,*tmp;
 997   U16 id,frames,tmpid;
 998   int level;
 999   if(t->id!=ST_DEFINESPRITE)
1000       return;
1001   if(!t->len) {
1002       fprintf(stderr, "Error: Sprite has no ID!");
1003       return;
1004   }
1005   if(t->len>4) {
1006     /* sprite is already folded */
1007       return;
1008   }
1009
1010   t->pos = 0;
1011   id = swf_GetU16(t);
1012   free(t->data);
1013   t->len = t->pos = t->memsize = 0;
1014   t->data = 0;
1015
1016   frames = 0;
1017
1018   t = swf_NextTag(sprtag);
1019   level = 1;
1020
1021   do
1022   {
1023     if(t->id==ST_SHOWFRAME) frames++;
1024     if(t->id == ST_DEFINESPRITE && t->len<=4)
1025         level++;
1026     if(t->id == ST_END)
1027         level--;
1028     t = swf_NextTag(t);
1029   } while(t && level);
1030   if(level)
1031     fprintf(stderr, "rfxswf error: sprite doesn't end(1)\n");
1032
1033   swf_SetU16(sprtag, id);
1034   swf_SetU16(sprtag, frames);
1035
1036   t = swf_NextTag(sprtag);
1037   level = 1;
1038
1039   do
1040   {
1041     if(t->len<0x3f) {
1042         swf_SetU16(sprtag,t->len|(t->id<<6));
1043     } else {
1044         swf_SetU16(sprtag,0x3f|(t->id<<6));
1045         swf_SetU32(sprtag,t->len);
1046     }
1047     if(t->len)
1048         swf_SetBlock(sprtag,t->data, t->len);
1049     tmp = t;
1050     if(t->id == ST_DEFINESPRITE && t->len<=4)
1051         level++;
1052     if(t->id == ST_END)
1053         level--;
1054     t = swf_NextTag(t);
1055     swf_DeleteTag(tmp);
1056   }
1057   while (t && level);
1058   if(level)
1059     fprintf(stderr, "rfxswf error: sprite doesn't end(2)\n");
1060
1061 //  sprtag->next = t;
1062 //  t->prev = sprtag;
1063 }
1064
1065 int swf_IsFolded(TAG * t)
1066 {
1067     return (t->id == ST_DEFINESPRITE && t->len>4);
1068 }
1069
1070 void swf_FoldAll(SWF*swf)
1071 {
1072     TAG*tag = swf->firstTag;
1073     //swf_DumpSWF(stdout, swf);
1074     while(tag) {
1075         if(tag->id == ST_DEFINESPRITE) {
1076             swf_FoldSprite(tag);
1077             //swf_DumpSWF(stdout, swf);
1078         }
1079         tag = swf_NextTag(tag);
1080     }
1081 }
1082
1083 void swf_UnFoldAll(SWF*swf)
1084 {
1085     TAG*tag = swf->firstTag;
1086     while(tag) {
1087         if(tag->id == ST_DEFINESPRITE)
1088             swf_UnFoldSprite(tag);
1089         tag = tag->next;
1090     }
1091 }
1092
1093 void swf_OptimizeTagOrder(SWF*swf)
1094 {
1095   TAG*tag,*next;
1096   TAG*level0;
1097   int level;
1098   int changes;
1099   swf_UnFoldAll(swf);
1100   /* at the moment, we don't actually do optimizing,
1101      only fixing of non-spec-conformant things like
1102      sprite tags */
1103
1104   do {
1105     changes = 0;
1106     level = 0;
1107     level0 = 0;
1108     tag = swf->firstTag;
1109     while(tag) {
1110       next = tag->next;
1111       if(tag->id == ST_DEFINESPRITE) {
1112         if(tag->len>4) {
1113           /* ??? all sprites are supposed to be unfolded */
1114           fprintf(stderr, "librfxswf error - internal error in OptimizeTagOrder/UnfoldAll\n");
1115         }
1116         level++;
1117         if(level==1) {
1118           level0 = tag;
1119           tag = next;
1120           continue;
1121         }
1122       }
1123       if(level>=1) {
1124         /* move non-sprite tags out of sprite */
1125         if(!swf_isAllowedSpriteTag(tag) || level>=2) {
1126           /* remove tag from current position */
1127           tag->prev->next = tag->next;
1128           if(tag->next)
1129             tag->next->prev = tag->prev;
1130
1131           /* insert before tag level0 */
1132           tag->next = level0;
1133           tag->prev = level0->prev;
1134           level0->prev = tag;
1135           tag->prev->next = tag;
1136           changes = 1;
1137         }
1138       }
1139       if(tag->id == ST_END) {
1140         level--;
1141       }
1142
1143       tag = next;
1144     }
1145   } while(changes);
1146 }
1147
1148 // Movie Functions
1149
1150 int swf_ReadSWF2(struct reader_t*reader, SWF * swf)   // Reads SWF to memory (malloc'ed), returns length or <0 if fails
1151 {
1152   if (!swf) return -1;
1153   memset(swf,0x00,sizeof(SWF));
1154
1155   { char b[32];                         // read Header
1156     int len;
1157     TAG * t;
1158     TAG t1;
1159     struct reader_t zreader;
1160
1161     if ((len = reader->read(reader ,b,8))<8) return -1;
1162
1163     if (b[0]!='F' && b[0]!='C') return -1;
1164     if (b[1]!='W') return -1;
1165     if (b[2]!='S') return -1;
1166     swf->fileVersion = b[3];
1167     swf->compressed  = (b[0]=='C')?1:0;
1168     swf->fileSize    = GET32(&b[4]);
1169
1170     if(swf->compressed) {
1171         reader_init_zlibinflate(&zreader, reader);
1172         reader = &zreader;
1173     }
1174
1175     reader_GetRect(reader, &swf->movieSize);
1176     reader->read(reader, &swf->frameRate, 2);
1177     swf->frameRate = SWAP16(swf->frameRate);
1178     reader->read(reader, &swf->frameCount, 2);
1179     swf->frameCount = SWAP16(swf->frameCount);
1180
1181     /* read tags and connect to list */
1182     t = &t1;
1183     while (t) t = swf_ReadTag(reader,t);
1184     swf->firstTag = t1.next;
1185     t1.next->prev = NULL;
1186   }
1187
1188   return reader->pos;
1189 }
1190
1191 int swf_ReadSWF(int handle, SWF * swf)
1192 {
1193   struct reader_t reader;
1194   reader_init_filereader(&reader, handle);
1195   return swf_ReadSWF2(&reader, swf);
1196 }
1197
1198 int  swf_WriteSWF2(struct writer_t*writer, SWF * swf)     // Writes SWF to file, returns length or <0 if fails
1199 { U32 len;
1200   TAG * t;
1201   int frameCount=0;
1202   struct writer_t zwriter;
1203   int fileSize = 0;
1204   int inSprite = 0;
1205   int writer_lastpos = 0;
1206
1207   if (!swf) return -1;
1208   if (!writer) return -1; // the caller should provide a nullwriter, not 0, for querying SWF size
1209
1210   if(writer) writer_lastpos = writer->pos;
1211
1212   // Insert REFLEX Tag
1213
1214 #ifdef INSERT_RFX_TAG
1215
1216   if (swf->firstTag && swf_NextTag(swf->firstTag))
1217     if (swf_GetTagID(swf_NextTag(swf->firstTag))!=ST_REFLEX)
1218       swf_SetBlock(swf_InsertTagBefore(swf, swf->firstTag,ST_REFLEX),"rfx",3);
1219
1220 #endif // INSERT_RFX_TAG
1221
1222   // Count Frames + File Size
1223
1224   len = 0;
1225   t = swf->firstTag;
1226   frameCount = 0;
1227
1228   while(t) {
1229       len += swf_WriteTag(-1,t);
1230       if(t->id == ST_DEFINESPRITE) inSprite++;
1231       else if(t->id == ST_END && inSprite) inSprite--;
1232       else if(t->id == ST_SHOWFRAME && !inSprite) frameCount++;
1233       t = swf_NextTag(t);
1234   }
1235
1236   { TAG t1;
1237     char b[64],b4[4];
1238     U32 l;
1239
1240     memset(&t1,0x00,sizeof(TAG));
1241     t1.data    = (U8*)b;
1242     t1.memsize = 64;
1243
1244     { // measure header file size
1245       TAG t2;
1246       char b2[64];
1247       memset(&t2,0x00,sizeof(TAG));
1248       t2.data    = (U8*)b2;
1249       t2.memsize = 64;
1250       swf_SetRect(&t2, &swf->movieSize);
1251       swf_SetU16(&t2, swf->frameRate);
1252       swf_SetU16(&t2, swf->frameCount);
1253       l = swf_GetTagLen(&t2)+8;
1254     }
1255     if(swf->compressed == 8) {
1256       l -= 8;
1257     }
1258
1259     fileSize = l+len;
1260     if(len) {// don't touch headers without tags
1261         swf->fileSize = fileSize;
1262         swf->frameCount = frameCount;
1263     }
1264
1265     if(swf->compressed != 8) {
1266     /* compressed flag set to 8 means "skip first 8
1267        header bytes". This is necessary if the caller wants to
1268        create compressed SWFs himself .
1269        It also means that we don't initialize our own zlib
1270        writer, but assume the caller provided one.
1271      */
1272       if(swf->compressed) {
1273         char*id = "CWS";
1274         writer->write(writer, id, 3);
1275       }
1276       else {
1277         char*id = "FWS";
1278         writer->write(writer, id, 3);
1279       }
1280
1281       writer->write(writer, &swf->fileVersion, 1);
1282       PUT32(b4, swf->fileSize);
1283       writer->write(writer, b4, 4);
1284
1285       if(swf->compressed) {
1286         writer_init_zlibdeflate(&zwriter, writer);
1287         writer = &zwriter;
1288       }
1289     }
1290
1291     swf_SetRect(&t1,&swf->movieSize);
1292     swf_SetU16(&t1,swf->frameRate);
1293     swf_SetU16(&t1,swf->frameCount);
1294
1295     int ret = writer->write(writer,b,swf_GetTagLen(&t1));
1296     if (ret!=swf_GetTagLen(&t1))
1297     {
1298       #ifdef DEBUG_RFXSWF
1299         fprintf(stderr, "ret:%d\n",ret);
1300         perror("write:");
1301         fprintf(stderr,"WriteSWF() failed: Header.\n");
1302       #endif
1303       return -1;
1304     }
1305
1306     t = swf->firstTag;
1307     while (t)
1308     { if (swf_WriteTag2(writer, t)<0) return -1;
1309       t = swf_NextTag(t);
1310     }
1311     if(swf->compressed) {
1312       if(swf->compressed != 8) {
1313         zwriter.finish(&zwriter);
1314         return writer->pos - writer_lastpos;
1315       }
1316       return (int)fileSize;
1317     } else {
1318       return (int)fileSize;
1319     }
1320   }
1321 }
1322
1323 int  swf_WriteSWF(int handle, SWF * swf)     // Writes SWF to file, returns length or <0 if fails
1324 {
1325   struct writer_t writer;
1326   int len = 0;
1327   swf->compressed = 0;
1328
1329   if(handle<0) {
1330     writer_init_nullwriter(&writer);
1331     len = swf_WriteSWF2(&writer, swf);
1332   }
1333   writer_init_filewriter(&writer, handle);
1334   len = swf_WriteSWF2(&writer, swf);
1335   writer.finish(&writer);
1336   return len;
1337 }
1338
1339 int  swf_WriteSWC(int handle, SWF * swf)     // Writes SWF to file, returns length or <0 if fails
1340 {
1341   struct writer_t writer;
1342   int len = 0;
1343   swf->compressed = 1;
1344
1345   if(handle<0) {
1346     writer_init_nullwriter(&writer);
1347     len = swf_WriteSWF2(&writer, swf);
1348   }
1349   writer_init_filewriter(&writer, handle);
1350   len = swf_WriteSWF2(&writer, swf);
1351   writer.finish(&writer);
1352   return len;
1353 }
1354
1355 int swf_WriteHeader2(struct writer_t*writer,SWF * swf)
1356 {
1357   SWF myswf;
1358   memcpy(&myswf,swf,sizeof(SWF));
1359   myswf.firstTag = 0;
1360   return swf_WriteSWF2(writer, &myswf);
1361 }
1362
1363 int swf_WriteHeader(int handle,SWF * swf)
1364 {
1365   SWF myswf;
1366   memcpy(&myswf,swf,sizeof(SWF));
1367   myswf.firstTag = 0;
1368   return swf_WriteSWF(handle, &myswf);
1369 }
1370
1371 int swf_WriteCGI(SWF * swf)
1372 { int len;
1373   char s[1024];
1374
1375   len = swf_WriteSWF(-1,swf);
1376
1377   if (len<0) return -1;
1378
1379   sprintf(s,"Content-type: application/x-shockwave-flash\n"
1380             "Accept-Ranges: bytes\n"
1381             "Content-Length: %lu\n"
1382             "Expires: Thu, 13 Apr 2000 23:59:59 GMT\n"
1383             "\n",len);
1384
1385   write(fileno(stdout),s,strlen(s));
1386   return swf_WriteSWF(fileno(stdout),swf);
1387 }
1388
1389 void swf_FreeTags(SWF * swf)                 // Frees all malloc'ed memory for tags
1390 { TAG * t = swf->firstTag;
1391
1392   while (t)
1393   { TAG * tnew = t->next;
1394     if (t->data) free(t->data);
1395     free(t);
1396     t = tnew;
1397   }
1398   swf->firstTag = 0;
1399 }
1400
1401 // include advanced functions
1402
1403 #include "modules/swfdump.c"
1404 #include "modules/swfshape.c"
1405 #include "modules/swftext.c"
1406 #include "modules/swffont.c"
1407 #include "modules/swfobject.c"
1408 #include "modules/swfbutton.c"
1409 #include "modules/swftools.c"
1410 #include "modules/swfcgi.c"
1411 #include "modules/swfbits.c"
1412 #include "modules/swfaction.c"
1413 #include "modules/swfsound.c"
1414 #include "modules/swfdraw.c"