lib/rfxswf.c

   1 /* rfxswf.c
   2
   3    Library for creating and reading SWF files or parts of it.
   4    There's a module directory which provides some extended functionality.
   5    Most modules are included at the bottom of this file.
   6
   7    Part of the swftools package.
   8
   9    Copyright (c) 2000, 2001 Rainer Böhme <rfxswf@reflex-studio.de>
  10
  11    This file is distributed under the GPL, see file COPYING for details
  12
  13 */
  14
  15 #include "rfxswf.h"
  16
  17 #ifdef HAVE_LIBJPEG
  18 #ifdef HAVE_JPEGLIB_H
  19 #include <jpeglib.h>
  20 #define _JPEGLIB_INCLUDED_
  21 #endif // HAVE_JPEGLIB_H
  22 #endif // HAVE_LIBJPEG
  23
  24 #ifdef HAVE_LIBZ
  25 #ifdef HAVE_ZLIB_H
  26 #include <zlib.h>
  27 #define _ZLIB_INCLUDED_
  28 #endif // HAVE_ZLIB_H
  29 #endif // HAVE_LIBZ
  30
  31 // Win32 support may be broken since it was only tested in an older version for Watcom C
  32 #ifdef __NT__
  33 #  include <io.h>
  34 #  include <malloc.h>
  35 #  include <string.h>
  36 #  ifdef DEBUG_RFXSWF
  37 #    include <stdio.h>
  38 #  endif
  39 #else
  40 #endif
  41
  42 // internal constants
  43
  44 #define MALLOC_SIZE     128
  45 #define INSERT_RFX_TAG
  46
  47 #define MEMSIZE(l) (((l/MALLOC_SIZE)+1)*MALLOC_SIZE)
  48
  49 // inline wrapper functions
  50
  51 TAG * swf_NextTag(TAG * t) { return t->next; }
  52 TAG * swf_PrevTag(TAG * t) { return t->prev; }
  53 int   swf_GetFrameNo(TAG * t)  { return t->frame; }
  54 U16   swf_GetTagID(TAG * t)    { return t->id; }
  55 U32   swf_GetDataSize(TAG * t) { return t->len; }
  56 U8*   swf_GetDataSizePtr(TAG * t) { return &(t->data[t->len]); }
  57 U32   swf_GetTagPos(TAG * t)   { return t->pos; }
  58
  59 // Basic Data Access Functions
  60
  61 #define swf_ResetReadBits(tag)   if (tag->readBit)  { tag->pos++; tag->readBit = 0; }
  62 #define swf_ResetWriteBits(tag)  if (tag->writeBit) { tag->writeBit = 0; }
  63
  64 // for future purpose: avoid high level lib functions to change tagpos/bitpos
  65
  66 #define swf_SaveTagPos(tag)
  67 #define swf_RestoreTagPos(tag)
  68
  69 void swf_SetTagPos(TAG * t,U32 pos)
  70 { swf_ResetReadBits(t);
  71   if (pos<=t->len) t->pos = pos;
  72   #ifdef DEBUG_RFXSWF
  73   else fprintf(stderr,"SetTagPos() out of bounds: TagID = %i\n",t->id);
  74   #endif
  75 }
  76
  77 U8 swf_GetU8(TAG * t)
  78 { swf_ResetReadBits(t);
  79   #ifdef DEBUG_RFXSWF
  80     if (t->pos>=t->len)
  81     { fprintf(stderr,"GetU8() out of bounds: TagID = %i\n",t->id);
  82       return 0;
  83     }
  84   #endif
  85   return t->data[t->pos++];
  86 }
  87
  88 U16 swf_GetU16(TAG * t)
  89 { U16 res;
  90   swf_ResetReadBits(t);
  91   #ifdef DEBUG_RFXSWF
  92     if (t->pos>(t->len-2))
  93     { fprintf(stderr,"GetU16() out of bounds: TagID = %i\n",t->id);
  94       return 0;
  95     }
  96   #endif
  97   res = t->data[t->pos] | (t->data[t->pos+1]<<8);
  98   t->pos+=2;
  99   return res;
 100 }
 101
 102 U32 swf_GetU32(TAG * t)
 103 { U32 res;
 104   swf_ResetReadBits(t);
 105   #ifdef DEBUG_RFXSWF
 106     if (t->pos>(t->len-4))
 107     { fprintf(stderr,"GetU32() out of bounds: TagID = %i\n",t->id);
 108       return 0;
 109     }
 110   #endif
 111   res = t->data[t->pos]        | (t->data[t->pos+1]<<8) |
 112        (t->data[t->pos+2]<<16) | (t->data[t->pos+3]<<24);
 113   t->pos+=4;
 114   return res;
 115 }
 116
 117 int swf_GetBlock(TAG * t,U8 * b,int l)
 118 // returns number of bytes written (<=l)
 119 // b = NULL -> skip data
 120 { swf_ResetReadBits(t);
 121   if ((t->len-t->pos)<l) l=t->len-t->pos;
 122   if (b && l) memcpy(b,&t->data[t->pos],l);
 123   t->pos+=l;
 124   return l;
 125 }
 126
 127 int swf_SetBlock(TAG * t,U8 * b,int l)
 128 // Appends Block to the end of Tagdata, returns size
 129 { U32 newlen = t->len + l;
 130   swf_ResetWriteBits(t);
 131   if (newlen>t->memsize)
 132   { U32  newmem  = MEMSIZE(newlen);
 133     U8 * newdata = (U8*)((t->data)?realloc(t->data,newmem):malloc(newmem));
 134     if (!newdata)
 135     {
 136       #ifdef DEBUG_RFXSWF
 137         fprintf(stderr,"Fatal Error: malloc()/realloc() failed.\n");
 138       #endif
 139       return 0;
 140     }
 141     t->memsize = newmem;
 142     t->data    = newdata;
 143   }
 144   if (b) memcpy(&t->data[t->len],b,l);
 145   else memset(&t->data[t->len],0x00,l);
 146   t->len+=l;
 147   return l;
 148 }
 149
 150 int swf_SetU8(TAG * t,U8 v)
 151 { swf_ResetWriteBits(t);
 152   if ((t->len+1)>t->memsize) return (swf_SetBlock(t,&v,1)==1)?0:-1;
 153   t->data[t->len++] = v;
 154   return 0;
 155 }
 156
 157 int swf_SetU16(TAG * t,U16 v)
 158 { U8 a[2];
 159   a[0] = v&0xff;
 160   a[1] = v>>8;
 161
 162   swf_ResetWriteBits(t);
 163   if ((t->len+2)>t->memsize) return (swf_SetBlock(t,a,2)==2)?0:-1;
 164   t->data[t->len++] = a[0];
 165   t->data[t->len++] = a[1];
 166   return 0;
 167 }
 168
 169 int swf_SetU32(TAG * t,U32 v)
 170 { U8 a[4];
 171   a[0] = v&0xff;        // to ensure correct handling of non-intel byteorder
 172   a[1] = (v>>8)&0xff;
 173   a[2] = (v>>16)&0xff;
 174   a[3] = (v>>24)&0xff;
 175
 176   swf_ResetWriteBits(t);
 177   if ((t->len+4)>t->memsize) return (swf_SetBlock(t,a,4)==4)?0:-1;
 178   t->data[t->len++] = a[0];
 179   t->data[t->len++] = a[1];
 180   t->data[t->len++] = a[2];
 181   t->data[t->len++] = a[3];
 182   return 0;
 183 }
 184
 185 U32 swf_GetBits(TAG * t,int nbits)
 186 { U32 res = 0;
 187   if (!nbits) return 0;
 188   if (!t->readBit) t->readBit = 0x80;
 189   while (nbits)
 190   { res<<=1;
 191     if (t->data[t->pos]&t->readBit) res|=1;
 192     t->readBit>>=1;
 193     nbits--;
 194     if (!t->readBit)
 195     { if (nbits) t->readBit = 0x80;
 196       #ifdef DEBUG_RFXSWF
 197       if (t->pos>=t->len)
 198       { fprintf(stderr,"GetBits() out of bounds: TagID = %i\n",t->id);
 199         return res;
 200       }
 201       #endif
 202       t->pos++;
 203     }
 204   }
 205   return res;
 206 }
 207
 208 S32 swf_GetSBits(TAG * t,int nbits)
 209 { U32 res = swf_GetBits(t,nbits);
 210   if (res&(1<<(nbits-1))) res|=(0xffffffff<<nbits);
 211   return (S32)res;
 212 }
 213
 214 int swf_SetBits(TAG * t,U32 v,int nbits)
 215 { U32 bm = 1<<(nbits-1);
 216
 217   while (nbits)
 218   { if (!t->writeBit)
 219     { if (FAILED(swf_SetU8(t,0))) return -1;
 220       t->writeBit = 0x80;
 221     }
 222     if (v&bm) t->data[t->len-1] |= t->writeBit;
 223     bm>>=1;
 224     t->writeBit>>=1;
 225     nbits--;
 226   }
 227   return 0;
 228 }
 229
 230 // Advanced Data Access Functions
 231
 232 int swf_SetRGB(TAG * t,RGBA * col)
 233 { if (!t) return -1;
 234   if (col)
 235   { swf_SetU8(t,col->r);
 236     swf_SetU8(t,col->g);
 237     swf_SetU8(t,col->b);
 238   } else swf_SetBlock(t,NULL,3);
 239   return 0;
 240 }
 241
 242 int swf_SetRGBA(TAG * t,RGBA * col)
 243 { if (!t) return -1;
 244   if (col)
 245   { swf_SetU8(t,col->r);
 246     swf_SetU8(t,col->g);
 247     swf_SetU8(t,col->b);
 248     swf_SetU8(t,col->a);
 249   } else swf_SetBlock(t,NULL,4);
 250   return 0;
 251 }
 252
 253 int swf_CountBits(U32 v,int nbits)
 254 { int n = 33;
 255   U32 m = 0x80000000;
 256   if (!v) n = 0; else
 257   if (v&m)
 258   { while (v&m)
 259     { n--;
 260       m>>=1;
 261       if (!m) break;
 262     }
 263   }
 264   else
 265   { while (!(v&m))
 266     { n--;
 267       m>>=1;
 268       if (!m) break;
 269     }
 270   }
 271   return (n>nbits)?n:nbits;
 272 }
 273
 274 int swf_GetRect(TAG * t,SRECT * r)
 275 { int nbits;
 276   SRECT dummy;
 277   if (!r) r = &dummy;
 278   nbits = (int) swf_GetBits(t,5);
 279   r->xmin = swf_GetSBits(t,nbits);
 280   r->xmax = swf_GetSBits(t,nbits);
 281   r->ymin = swf_GetSBits(t,nbits);
 282   r->ymax = swf_GetSBits(t,nbits);
 283   return 0;
 284 }
 285
 286 int swf_SetRect(TAG * t,SRECT * r)
 287 { int nbits;
 288
 289   nbits = swf_CountBits(r->xmin,0);
 290   nbits = swf_CountBits(r->xmax,nbits);
 291   nbits = swf_CountBits(r->ymin,nbits);
 292   nbits = swf_CountBits(r->ymax,nbits);
 293
 294   swf_SetBits(t,nbits,5);
 295   swf_SetBits(t,r->xmin,nbits);
 296   swf_SetBits(t,r->xmax,nbits);
 297   swf_SetBits(t,r->ymin,nbits);
 298   swf_SetBits(t,r->ymax,nbits);
 299
 300   return 0;
 301 }
 302
 303 int swf_GetMatrix(TAG * t,MATRIX * m)
 304 { MATRIX dummy;
 305   int nbits;
 306
 307   if (!m) m = &dummy;
 308
 309   if (!t)
 310   { m->sx = m->sy = 0x10000;
 311     m->r0 = m->r1 = 0;
 312     m->tx = m->ty = 0;
 313     return -1;
 314   }
 315
 316   swf_ResetReadBits(t);
 317
 318   if (swf_GetBits(t,1))
 319   { nbits = swf_GetBits(t,5);
 320     m->sx = swf_GetSBits(t,nbits);
 321     m->sy = swf_GetSBits(t,nbits);
 322   }
 323   else m->sx = m->sy = 0x10000;
 324
 325   if (swf_GetBits(t,1))
 326   { nbits = swf_GetBits(t,5);
 327     m->r0 = swf_GetSBits(t,nbits);
 328     m->r1 = swf_GetSBits(t,nbits);
 329   }
 330   else m->r0 = m->r1 = 0x0;
 331
 332   nbits = swf_GetBits(t,5);
 333   m->tx = swf_GetSBits(t,nbits);
 334   m->ty = swf_GetSBits(t,nbits);
 335
 336   return 0;
 337 }
 338
 339 int swf_SetMatrix(TAG * t,MATRIX * m)
 340 { int nbits;
 341   MATRIX ma;
 342
 343   if (!m)
 344   { m = &ma;
 345     ma.sx = ma.sy = 0x10000;
 346     ma.r0 = ma.r1 = 0;
 347     ma.tx = ma.ty = 0;
 348   }
 349
 350   swf_ResetWriteBits(t);
 351
 352   if ((m->sx==0x10000)&&(m->sy==0x10000)) swf_SetBits(t,0,1);
 353   else
 354   { swf_SetBits(t,1,1);
 355     nbits = swf_CountBits(m->sx,0);
 356     nbits = swf_CountBits(m->sy,nbits);
 357     if(nbits>=32) {
 358         fprintf(stderr,"rfxswf: Error: matrix values too large\n");
 359         nbits = 31;
 360     }
 361     swf_SetBits(t,nbits,5);
 362     swf_SetBits(t,m->sx,nbits);
 363     swf_SetBits(t,m->sy,nbits);
 364   }
 365
 366   if ((!m->r0)&&(!m->r1)) swf_SetBits(t,0,1);
 367   else
 368   { swf_SetBits(t,1,1);
 369     nbits = swf_CountBits(m->r0,0);
 370     nbits = swf_CountBits(m->r1,nbits);
 371     if(nbits>=32) {
 372         fprintf(stderr,"rfxswf: Error: matrix values too large\n");
 373         nbits = 31;
 374     }
 375     swf_SetBits(t,nbits,5);
 376     swf_SetBits(t,m->r0,nbits);
 377     swf_SetBits(t,m->r1,nbits);
 378   }
 379
 380   nbits = swf_CountBits(m->tx,0);
 381   nbits = swf_CountBits(m->ty,nbits);
 382   if(nbits>=32) {
 383       fprintf(stderr,"rfxswf: Error: matrix values too large\n");
 384       nbits = 31;
 385   }
 386   swf_SetBits(t,nbits,5);
 387   swf_SetBits(t,m->tx,nbits);
 388   swf_SetBits(t,m->ty,nbits);
 389
 390   return 0;
 391 }
 392
 393 int swf_GetCXForm(TAG * t,CXFORM * cx,U8 alpha) //FIXME: alpha should be type bool
 394 { CXFORM cxf;
 395   int hasadd;
 396   int hasmul;
 397   int nbits;
 398
 399   if (!cx) cx = &cxf;
 400
 401   cx->a0 = cx->r0 = cx->g0 = cx->b0 = 256;
 402   cx->a1 = cx->r1 = cx->g1 = cx->b1 = 0;
 403
 404   if (!t) return 0;
 405
 406   swf_ResetReadBits(t);
 407   hasadd = swf_GetBits(t,1);
 408   hasmul = swf_GetBits(t,1);
 409   nbits  = swf_GetBits(t,4);
 410
 411   if (hasmul)
 412   { cx->r0 = (S16)swf_GetSBits(t,nbits);
 413     cx->g0 = (S16)swf_GetSBits(t,nbits);
 414     cx->b0 = (S16)swf_GetSBits(t,nbits);
 415     if (alpha)
 416       cx->a0 = (S16)swf_GetSBits(t,nbits);
 417   }
 418
 419   if (hasadd)
 420   { cx->r1 = (S16)swf_GetSBits(t,nbits);
 421     cx->g1 = (S16)swf_GetSBits(t,nbits);
 422     cx->b1 = (S16)swf_GetSBits(t,nbits);
 423     if (alpha)
 424       cx->a1 = (S16)swf_GetSBits(t,nbits);
 425   }
 426
 427   return 0;
 428 }
 429
 430 int swf_SetCXForm(TAG * t,CXFORM * cx,U8 alpha)
 431 { CXFORM cxf;
 432   int hasadd;
 433   int hasmul;
 434   int nbits;
 435
 436   if (!cx)
 437   { cx = &cxf;
 438     cx->a0 = cx->r0 = cx->g0 = cx->b0 = 256;
 439     cx->a1 = cx->r1 = cx->g1 = cx->b1 = 0;
 440   }
 441
 442   if (!alpha)
 443   { cx->a0 = 256;
 444     cx->a1 = 0;
 445   }
 446
 447   nbits = 0;
 448
 449   hasmul = (cx->a0!=256)||(cx->r0!=256)||(cx->g0!=256)||(cx->b0!=256);
 450   hasadd = cx->a1|cx->r1|cx->g1|cx->b1;
 451
 452   if (hasmul)
 453   { if (alpha) nbits = swf_CountBits((S32)cx->a0,nbits);
 454     nbits = swf_CountBits((S32)cx->r0,nbits);
 455     nbits = swf_CountBits((S32)cx->g0,nbits);
 456     nbits = swf_CountBits((S32)cx->b0,nbits);
 457   }
 458
 459   if (hasadd)
 460   { if (alpha) nbits = swf_CountBits((S32)cx->a1,nbits);
 461     nbits = swf_CountBits((S32)cx->r1,nbits);
 462     nbits = swf_CountBits((S32)cx->g1,nbits);
 463     nbits = swf_CountBits((S32)cx->b1,nbits);
 464   }
 465
 466   swf_ResetWriteBits(t);
 467   swf_SetBits(t,hasadd?1:0,1);
 468   swf_SetBits(t,hasmul?1:0,1);
 469   swf_SetBits(t,nbits,4);
 470
 471   if (hasmul)
 472   { swf_SetBits(t,cx->r0,nbits);
 473     swf_SetBits(t,cx->g0,nbits);
 474     swf_SetBits(t,cx->b0,nbits);
 475     if (alpha) swf_SetBits(t,cx->a0,nbits);
 476   }
 477
 478   if (hasadd)
 479   { swf_SetBits(t,cx->r1,nbits);
 480     swf_SetBits(t,cx->g1,nbits);
 481     swf_SetBits(t,cx->b1,nbits);
 482     if (alpha) swf_SetBits(t,cx->a1,nbits);
 483   }
 484
 485   return 0;
 486 }
 487
 488 int swf_GetPoint(TAG * t,SPOINT * p) { return 0; }
 489 int swf_SetPoint(TAG * t,SPOINT * p) { return 0; }
 490
 491 // Tag List Manipulating Functions
 492
 493 int RFXSWF_UpdateFrame(TAG * t,S8 delta)
 494 // returns number of frames
 495 { int res = -1;
 496   while (t)
 497   { t->frame+=delta;
 498     res = t->frame;
 499     t = t->next;
 500   }
 501   return res;
 502 }
 503
 504 #define swf_UpdateFrame(a,b) RFXSWF_UpdateFrame(a,b)
 505
 506 TAG * swf_InsertTag(TAG * after,U16 id)     // updates frames, if nescessary
 507 { TAG * t;
 508
 509   t = (TAG *)malloc(sizeof(TAG));
 510   if (t)
 511   { memset(t,0x00,sizeof(TAG));
 512     t->id = id;
 513
 514     if (after)
 515     { t->frame = after->frame;
 516       t->prev  = after;
 517       t->next  = after->next;
 518       after->next = t;
 519       if (t->next) t->next->prev = t;
 520
 521       if (id==ST_SHOWFRAME) swf_UpdateFrame(t->next,+1);
 522     }
 523   }
 524   return t;
 525 }
 526
 527 int swf_DeleteTag(TAG * t)
 528 { if (!t) return -1;
 529
 530   if (t->id==ST_SHOWFRAME) swf_UpdateFrame(t->next,-1);
 531
 532   if (t->prev) t->prev->next = t->next;
 533   if (t->next) t->next->prev = t->prev;
 534
 535   if (t->data) free(t->data);
 536   free(t);
 537   return 0;
 538 }
 539
 540 TAG * RFXSWF_ReadTag(int handle,TAG * prev)
 541 { TAG * t;
 542   U16 raw;
 543   U32 len;
 544   int id;
 545
 546   if (read(handle,&raw,2)!=2) return NULL;
 547
 548   len = raw&0x3f;
 549   id  = raw>>6;
 550
 551   if (len==0x3f)
 552   { if (read(handle,&len,4)!=4) return NULL;
 553   }
 554
 555   if (id==ST_DEFINESPRITE) len = 2*sizeof(U16);
 556   // Sprite handling fix: Flaten sprite tree
 557
 558   t = (TAG *)malloc(sizeof(TAG));
 559
 560   if (!t)
 561   {
 562     #ifdef DEBUG_RFXSWF
 563       fprintf(stderr,"Fatal Error: malloc()/realloc() failed.\n");
 564     #endif
 565     return NULL;
 566   }
 567
 568   memset(t,0x00,sizeof(TAG));
 569
 570   t->len = len;
 571   t->id  = id;
 572
 573   if (t->len)
 574   { t->data = (U8*)malloc(t->len);
 575     if (!t->data)
 576     {
 577       #ifdef DEBUG_RFXSWF
 578         fprintf(stderr,"Fatal Error: malloc()/realloc() failed.\n");
 579       #endif
 580       return NULL;
 581     }
 582     t->memsize = t->len;
 583     if (read(handle,t->data,t->len)!=t->len) return NULL;
 584   }
 585
 586   if (prev)
 587   { t->frame = prev->frame+((prev->id==ST_SHOWFRAME)?1:0);
 588     t->prev  = prev;
 589     prev->next = t;
 590   }
 591
 592   return t;
 593 }
 594
 595 int RFXSWF_DefineSprite_GetRealSize(TAG * t);
 596
 597 int RFXSWF_WriteTag(int handle,TAG * t)
 598 // returns tag length in bytes (incl. Header), -1 = Error
 599 // handle = -1 -> no output
 600 { U16 raw[3];
 601   U32 len;
 602   int short_tag;
 603
 604   if (!t) return -1;
 605
 606   len = (t->id==ST_DEFINESPRITE)?RFXSWF_DefineSprite_GetRealSize(t):t->len;
 607
 608   short_tag = len<0x3f;
 609
 610   if (handle>=0)
 611   { if (short_tag)
 612     { raw[0] = len|((t->id&0x3ff)<<6);
 613       if (write(handle,raw,2)!=2)
 614       {
 615         #ifdef DEBUG_RFXSWF
 616           fprintf(stderr,"WriteTag() failed: Short Header.\n");
 617         #endif
 618         return -1;
 619       }
 620     }
 621     else
 622     { raw[0] = (t->id<<6)|0x3f;
 623       raw[1] = (U16)(len&0xffff);
 624       raw[2] = (U16)(len>>16);
 625       if (write(handle,raw,6)!=6)
 626       {
 627         #ifdef DEBUG_RFXSWF
 628           fprintf(stderr,"WriteTag() failed: Long Header.\n");
 629         #endif
 630         return -1;
 631       }
 632     }
 633
 634     if (t->data)
 635     { if (write(handle,t->data,t->len)!=t->len)
 636       {
 637         #ifdef DEBUG_RFXSWF
 638           fprintf(stderr,"WriteTag() failed: Data.\n");
 639         #endif
 640         return -1;
 641       }
 642     }
 643     #ifdef DEBUG_RFXSWF
 644       else if (t->len) fprintf(stderr,"WriteTag(): Tag Data Error, id=%i\n",t->id);
 645     #endif
 646   }
 647
 648   return t->len+(short_tag?2:6);
 649 }
 650
 651 int RFXSWF_DefineSprite_GetRealSize(TAG * t)
 652 // Sprite Handling: Helper function to pack DefineSprite-Tag
 653 { U32 len = t->len;
 654   do
 655   { t = swf_NextTag(t);
 656     if (t->id!=ST_DEFINESPRITE) len += RFXSWF_WriteTag(-1,t);
 657     else t = NULL;
 658   } while (t&&(t->id!=ST_END));
 659   return len;
 660 }
 661
 662 #define swf_ReadTag(a,b)  RFXSWF_ReadTag(a,b)
 663 #define swf_WriteTag(a,b) RFXSWF_WriteTag(a,b)
 664
 665 // Movie Functions
 666
 667 int swf_ReadSWF(int handle,SWF * swf)   // Reads SWF to memory (malloc'ed), returns length or <0 if fails
 668 {
 669   if (!swf) return -1;
 670   memset(swf,0x00,sizeof(SWF));
 671
 672   { char b[32];                         // read Header
 673     TAG t1;
 674     TAG * t;
 675
 676     memset(&t1,0x00,sizeof(TAG));
 677
 678     if ((t1.len=read(handle,b,32))<21) return -1;
 679     t1.data = (U8*)b;
 680
 681     if (swf_GetU8(&t1)!=(U8)'F') return -1;
 682     if (swf_GetU8(&t1)!=(U8)'W') return -1;
 683     if (swf_GetU8(&t1)!=(U8)'S') return -1;
 684
 685     swf->fileVersion = swf_GetU8(&t1);
 686     swf->fileSize    = swf_GetU32(&t1);
 687     swf_GetRect(&t1,&swf->movieSize);
 688     swf->frameRate   = swf_GetU16(&t1);
 689     swf->frameCount  = swf_GetU16(&t1);
 690
 691     swf_GetU8(&t1);
 692     lseek(handle,swf_GetTagPos(&t1)-1,SEEK_SET);
 693
 694                                         // reda tags and connect to list
 695     t = &t1;
 696     while (t) t = swf_ReadTag(handle,t);
 697     swf->firstTag = t1.next;
 698     t1.next->prev = NULL;
 699   }
 700
 701   return 0;
 702 }
 703 int  swf_WriteSWF(int handle,SWF * swf)     // Writes SWF to file, returns length or <0 if fails
 704 { U32 len;
 705   TAG * t;
 706
 707   if (!swf) return -1;
 708
 709   // Insert REFLEX Tag
 710
 711 #ifdef INSERT_RFX_TAG
 712
 713   if (swf_NextTag(swf->firstTag))
 714     if (swf_GetTagID(swf_NextTag(swf->firstTag))!=ST_REFLEX)
 715       swf_SetBlock(swf_InsertTag(swf->firstTag,ST_REFLEX),"rfx",3);
 716
 717 #endif // INSERT_RFX_TAG
 718
 719   // Count Frames + File Size
 720
 721   len = 0;
 722   t = swf->firstTag;
 723   swf->frameCount = 0;
 724
 725   while(t)
 726   { len += swf_WriteTag(-1,t);
 727     if (t->id==ST_SHOWFRAME) swf->frameCount++;
 728     t = swf_NextTag(t);
 729   }
 730
 731   { TAG t1;
 732     char b[64];
 733     U32 l;
 734
 735     memset(&t1,0x00,sizeof(TAG));
 736     t1.data    = (U8*)b;
 737     t1.memsize = 64;
 738
 739     swf_SetU8(&t1,'F');
 740     swf_SetU8(&t1,'W');
 741     swf_SetU8(&t1,'S');
 742     swf_SetU8(&t1,swf->fileVersion);
 743
 744     swf_SetU32(&t1,0);                      // Keep space for filesize
 745     swf_SetRect(&t1,&swf->movieSize);
 746     swf_SetU16(&t1,swf->frameRate);
 747     swf_SetU16(&t1,swf->frameCount);
 748
 749     l = swf_GetDataSize(&t1);
 750     swf->fileSize = l+len;
 751     t1.len = 4;                         // bad & ugly trick !
 752     swf_SetU32(&t1,swf->fileSize);
 753
 754     if (handle>=0)
 755     {
 756       int ret = write(handle,b,l);
 757       if (ret!=l)
 758       {
 759         #ifdef DEBUG_RFXSWF
 760           printf("ret:%d (fd:%d)\n",ret, handle);
 761           perror("write:");
 762           fprintf(stderr,"WriteSWF() failed: Header.\n");
 763         #endif
 764         return -1;
 765       }
 766
 767       t = swf->firstTag;
 768       while (t)
 769       { if (swf_WriteTag(handle,t)<0) return -1;
 770         t = swf_NextTag(t);
 771       }
 772     }
 773   }
 774   return (int)swf->fileSize;
 775 }
 776
 777 int swf_WriteCGI(SWF * swf)
 778 { int len;
 779   char s[1024];
 780
 781   len = swf_WriteSWF(-1,swf);
 782
 783   if (len<0) return -1;
 784
 785   sprintf(s,"Content-type: application/x-shockwave-flash\n"
 786             "Accept-Ranges: bytes\n"
 787             "Content-Length: %lu\n"
 788             "Expires: Thu, 13 Apr 2000 23:59:59 GMT\n"
 789             "\n",len);
 790
 791   write(fileno(stdout),s,strlen(s));
 792   return swf_WriteSWF(fileno(stdout),swf);
 793 }
 794
 795 void swf_FreeTags(SWF * swf)                 // Frees all malloc'ed memory for tags
 796 { TAG * t = swf->firstTag;
 797
 798   while (t)
 799   { TAG * tnew = t->next;
 800     if (t->data) free(t->data);
 801     free(t);
 802     t = tnew;
 803   }
 804 }
 805
 806 // include advanced functions
 807
 808 #ifdef __NT__
 809
 810 #include "modules\swfdump.c"
 811 #include "modules\swfshape.c"
 812 #include "modules\swftext.c"
 813 #include "modules\swfobject.c"
 814 #include "modules\swfbutton.c"
 815 #include "modules\swftools.c"
 816 #include "modules\swfcgi.c"
 817 #include "modules\swfbits.c"
 818 #include "modules\swfaction.c"
 819
 820 #else
 821
 822 #include "modules/swfdump.c"
 823 #include "modules/swfshape.c"
 824 #include "modules/swftext.c"
 825 #include "modules/swfobject.c"
 826 #include "modules/swfbutton.c"
 827 #include "modules/swftools.c"
 828 #include "modules/swfcgi.c"
 829 #include "modules/swfbits.c"
 830 #include "modules/swfaction.c"
 831
 832 #endif
 833
 834