src/swfextract.c

   1 /* swfextract.c
   2    Allows to extract parts of the swf into a new file.
   3
   4    Part of the swftools package.
   5
   6    Copyright (c) 2001 Matthias Kramm <kramm@quiss.org>
   7
   8    This file is distributed under the GPL, see file COPYING for details */
   9
  10 #include <unistd.h>
  11 #include <stdio.h>
  12 #include <fcntl.h>
  13 #include "../lib/rfxswf.h"
  14 #include "../lib/args.h"
  15 #include "../lib/log.h"
  16 #include "reloc.h"
  17 #ifdef HAVE_ZLIB_H
  18 #ifdef HAVE_LIBZ
  19 #include "zlib.h"
  20 #define _ZLIB_INCLUDED_
  21 #endif
  22 #endif
  23
  24 char * filename = 0;
  25 char * destfilename = "output.swf";
  26 int verbose = 3;
  27
  28 char* extractids = 0;
  29 char* extractframes = 0;
  30 char* extractjpegids = 0;
  31 char* extractpngids = 0;
  32 char extractmp3 = 0;
  33
  34 char* extractname = 0;
  35
  36 char hollow = 0;
  37
  38 int numextracts = 0;
  39
  40 struct options_t options[] =
  41 {
  42  {"o","output"},
  43  {"w","hollow"},
  44  {"v","verbose"},
  45  {"i","id"},
  46  {"j","jpegs"},
  47  {"p","pngs"},
  48  {"m","mp3"},
  49  {"n","name"},
  50  {"f","frame"},
  51  {"V","version"},
  52  {0,0}
  53 };
  54
  55
  56 int args_callback_option(char*name,char*val)
  57 {
  58     if(!strcmp(name, "V")) {
  59         printf("swfextract - part of %s %s\n", PACKAGE, VERSION);
  60         exit(0);
  61     }
  62     else if(!strcmp(name, "o")) {
  63         destfilename = val;
  64         return 1;
  65     }
  66     else if(!strcmp(name, "i")) {
  67         extractids = val;
  68         numextracts++;
  69         if(extractname) {
  70             fprintf(stderr, "You can only supply either name or id\n");
  71             exit(1);
  72         }
  73         return 1;
  74     }
  75     else if(!strcmp(name, "n")) {
  76         extractname = val;
  77         numextracts++;
  78         if(extractids) {
  79             fprintf(stderr, "You can only supply either name or id\n");
  80             exit(1);
  81         }
  82         return 1;
  83     }
  84     else if(!strcmp(name, "v")) {
  85         verbose ++;
  86         return 0;
  87     }
  88     else if(!strcmp(name, "m")) {
  89         extractmp3 = 1;
  90         numextracts++;
  91         return 0;
  92     }
  93     else if(!strcmp(name, "j")) {
  94         if(extractjpegids) {
  95             fprintf(stderr, "Only one --jpegs argument is allowed. (Try to use a range, e.g. -j 1,2,3)\n");
  96             exit(1);
  97         }
  98         numextracts++;
  99         extractjpegids = val;
 100         return 1;
 101     }
 102 #ifdef _ZLIB_INCLUDED_
 103     else if(!strcmp(name, "p")) {
 104         if(extractpngids) {
 105             fprintf(stderr, "Only one --pngs argument is allowed. (Try to use a range, e.g. -p 1,2,3)\n");
 106             exit(1);
 107         }
 108         numextracts++;
 109         extractpngids = val;
 110         return 1;
 111     }
 112 #endif
 113     else if(!strcmp(name, "f")) {
 114         numextracts++;
 115         extractframes = val;
 116         return 1;
 117     }
 118     else if(!strcmp(name, "w")) {
 119         hollow = 1;
 120         return 0;
 121     }
 122     else {
 123         printf("Unknown option: -%s\n", name);
 124         return 0;
 125     }
 126
 127     return 0;
 128 }
 129 int args_callback_longoption(char*name,char*val)
 130 {
 131     return args_long2shortoption(options, name, val);
 132 }
 133 void args_callback_usage(char*name)
 134 {
 135     printf("Usage: %s [-v] [-n name] [-ijf ids] file.swf\n", name);
 136     printf("\t-v , --verbose\t\t\t Be more verbose\n");
 137     printf("\t-o , --output filename\t\t set output filename\n");
 138     printf("\t-n , --name name\t\t instance name of the object to extract\n");
 139     printf("\t-i , --id IDs\t\t\t ID of the object to extract\n");
 140     printf("\t-j , --jpeg IDs\t\t\t IDs of the JPEG pictures to extract\n");
 141 #ifdef _ZLIB_INCLUDED_
 142     printf("\t-p , --pngs IDs\t\t\t IDs of the PNG pictures to extract\n");
 143 #endif
 144     printf("\t-m , --mp3\t\t\t Extract main mp3 stream\n");
 145     printf("\t-f , --frame frames\t\t frame numbers to extract\n");
 146     printf("\t-w , --hollow\t\t\t hollow mode: don't remove empty frames\n");
 147     printf("\t             \t\t\t (use with -f)\n");
 148     printf("\t-V , --version\t\t\t Print program version and exit\n");
 149 }
 150 int args_callback_command(char*name,char*val)
 151 {
 152     if(filename) {
 153         fprintf(stderr, "Only one file allowed. You supplied at least two. (%s and %s)\n",
 154                  filename, name);
 155     }
 156     filename = name;
 157     return 0;
 158 }
 159
 160 U8 mainr,maing,mainb;
 161 /* 1 = used, not expanded,
 162    3 = used, expanded
 163    5 = wanted, not expanded
 164    7 = wanted, expanded
 165  */
 166 char used[65536];
 167 TAG*tags[65536];
 168 int changed;
 169 char * tagused;
 170
 171 void idcallback(void*data)
 172 {
 173     if(!(used[GET16(data)]&1)) {
 174         changed = 1;
 175         used[GET16(data)] |= 1;
 176     }
 177 }
 178
 179 void enumerateIDs(TAG*tag, void(*callback)(void*))
 180 {
 181     U8*data;
 182     int len = tag->len;
 183     if(tag->len>=64) {
 184         len += 6;
 185         data = (U8*)malloc(len);
 186         PUT16(data, (tag->id<<6)+63);
 187         *(U8*)&data[2] = tag->len;
 188         *(U8*)&data[3] = tag->len>>8;
 189         *(U8*)&data[4] = tag->len>>16;
 190         *(U8*)&data[5] = tag->len>>24;
 191         memcpy(&data[6], tag->data, tag->len);
 192     } else {
 193         len += 2;
 194         data = (U8*)malloc(len);
 195         PUT16(data, (tag->id<<6)+tag->len);
 196         memcpy(&data[2], tag->data, tag->len);
 197     }
 198     map_ids_mem(data, len, callback);
 199 }
 200
 201 void extractTag(SWF*swf, char*filename)
 202 {
 203     SWF newswf;
 204     TAG*desttag;
 205     TAG*srctag;
 206     RGBA rgb;
 207     char sprite;
 208     int f;
 209     int t;
 210     int tagnum;
 211     int copy = 0;
 212     memset(&newswf,0x00,sizeof(SWF));        // set global movie parameters
 213
 214     newswf.fileVersion    = swf->fileVersion;
 215     newswf.frameRate      = swf->frameRate;
 216     newswf.movieSize      = swf->movieSize;
 217
 218     newswf.firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
 219     desttag = newswf.firstTag;
 220     rgb.r = mainr;
 221     rgb.g = maing;
 222     rgb.b = mainb;
 223     swf_SetRGB(desttag,&rgb);
 224
 225     do {
 226        changed = 0;
 227        for(t=0;t<65536;t++) {
 228            if(used[t] && !(used[t]&2)) {
 229              if(tags[t]->id==ST_DEFINESPRITE) {
 230                  TAG*tag = tags[t];
 231                  while(tag->id != ST_END)
 232                  {
 233                      enumerateIDs(tag, idcallback);
 234                      tag = tag->next;
 235                  }
 236              }
 237              else
 238                enumerateIDs(tags[t], idcallback);
 239              used[t] |= 2;
 240            }
 241        }
 242     }
 243     while(changed);
 244
 245     srctag = swf->firstTag;
 246     tagnum = 0;
 247     sprite = 0;
 248     while(srctag && (srctag->id || sprite)) {
 249         int reset = 0;
 250         if(!sprite) {
 251             copy = 0;
 252         }
 253         if(srctag->id == ST_END) {
 254             sprite = 0;
 255         }
 256         if(srctag->id == ST_DEFINESPRITE)
 257             sprite = 1;
 258         if(swf_isDefiningTag(srctag)) {
 259             int id = swf_GetDefineID(srctag);
 260             if(used[id])
 261                 copy = 1;
 262         } else
 263         if (((srctag->id == ST_PLACEOBJECT ||
 264               srctag->id == ST_PLACEOBJECT2 ||
 265               srctag->id == ST_STARTSOUND) && (used[swf_GetPlaceID(srctag)]&4) ) ||
 266               (swf_isPseudoDefiningTag(srctag) && used[swf_GetDefineID(srctag)]) ||
 267               (tagused[tagnum]))
 268         {
 269                 if(copy == 0)
 270                     reset = 1;
 271                 copy = 1;
 272         }
 273         if(srctag->id == ST_REMOVEOBJECT) {
 274             if(!used[swf_GetPlaceID(srctag)])
 275                 copy = 0;
 276         }
 277
 278         if(copy) {
 279             TAG*ttag = (TAG*)malloc(sizeof(TAG));
 280             desttag = swf_InsertTag(desttag, srctag->id);
 281             desttag->len = desttag->memsize = srctag->len;
 282             desttag->data = malloc(srctag->len);
 283             memcpy(desttag->data, srctag->data, srctag->len);
 284             if(reset)
 285                 copy = 0;
 286         }
 287
 288         srctag = srctag->next;
 289         tagnum ++;
 290     }
 291     if(!extractframes && !hollow)
 292         desttag = swf_InsertTag(desttag,ST_SHOWFRAME);
 293
 294     desttag = swf_InsertTag(desttag,ST_END);
 295
 296     f = open(filename, O_TRUNC|O_WRONLY|O_CREAT, 0644);
 297     if FAILED(swf_WriteSWF(f,&newswf)) fprintf(stderr,"WriteSWF() failed.\n");
 298     close(f);
 299
 300     swf_FreeTags(&newswf);                       // cleanup
 301 }
 302
 303 void listObjects(SWF*swf)
 304 {
 305     TAG*tag;
 306     char first;
 307     int t;
 308     int frame = 0;
 309     char*names[] = {"Shapes","MovieClips","JPEGs","PNGs","Sounds","Frames"};
 310     printf("Objects in file %s:\n",filename);
 311     for(t=0;t<6;t++) {
 312         tag = swf->firstTag;
 313         first = 1;
 314         while(tag) {
 315             char show = 0;
 316             char text[80];
 317             if(t == 0 &&
 318                (tag->id == ST_DEFINESHAPE ||
 319                 tag->id == ST_DEFINESHAPE2 ||
 320                 tag->id == ST_DEFINESHAPE3)) {
 321                 show = 1;
 322                 sprintf(text,"%d", swf_GetDefineID(tag));
 323             }
 324
 325             if(tag->id == ST_DEFINESPRITE) {
 326                 if (t == 1)  {
 327                     show = 1;
 328                     sprintf(text,"%d", swf_GetDefineID(tag));
 329                 }
 330
 331                 while(tag->id != ST_END)
 332                     tag = tag->next;
 333             }
 334
 335             if(t == 2 && (tag->id == ST_DEFINEBITS ||
 336                 tag->id == ST_DEFINEBITSJPEG2 ||
 337                 tag->id == ST_DEFINEBITSJPEG3)) {
 338                 show = 1;
 339                 sprintf(text,"%d", swf_GetDefineID(tag));
 340             }
 341
 342             if(t == 3 && (tag->id == ST_DEFINEBITSLOSSLESS ||
 343                 tag->id == ST_DEFINEBITSLOSSLESS2)) {
 344                 show = 1;
 345                 sprintf(text,"%d", swf_GetDefineID(tag));
 346             }
 347
 348
 349             if(t == 4 && (tag->id == ST_DEFINESOUND)) {
 350                 show = 1;
 351                 sprintf(text,"%d", swf_GetDefineID(tag));
 352             }
 353
 354             if(t == 5 && (tag->id == ST_SHOWFRAME)) {
 355                 show = 1;
 356                 sprintf(text,"%d", frame);
 357                 frame ++;
 358             }
 359
 360             if(show) {
 361                 if(!first)
 362                     printf(", ");
 363                 else
 364                     printf("%s: ", names[t]);
 365                 printf("%s", text);
 366                 first = 0;
 367             }
 368             tag=tag->next;
 369         }
 370         if(!first)
 371             printf("\n");
 372     }
 373 }
 374
 375 U8*jpegtables = 0;
 376 int jpegtablessize;
 377
 378 void handlejpegtables(TAG*tag)
 379 {
 380     if(tag->id == ST_JPEGTABLES) {
 381         jpegtables = tag->data;
 382         jpegtablessize = tag->len;
 383     }
 384 }
 385
 386 FILE* save_fopen(char* name, char* mode)
 387 {
 388     FILE*fi = fopen(name, mode);
 389     if(!fi) {
 390         fprintf(stderr, "Error: Couldn't open %s\n", name);
 391         exit(1);
 392     }
 393     return fi;
 394 }
 395
 396 int findjpegboundary(U8*data, int len)
 397 {
 398     int t;
 399     int pos=-1;
 400     for(t=0;t<len;t++) {
 401         if(data[t  ]==0xff &&
 402            data[t+1]==0xd9 &&
 403            data[t+2]==0xff &&
 404            data[t+3]==0xd8) {
 405             pos = t;
 406         }
 407     }
 408     return pos;
 409 }
 410
 411 /* extract jpeg data out of a tag */
 412 void handlejpeg(TAG*tag)
 413 {
 414     char name[80];
 415     FILE*fi;
 416     sprintf(name, "pic%d.jpeg", GET16(tag->data));
 417     /* swf jpeg images have two streams, which both start with ff d8 and
 418        end with ff d9. The following code handles sorting the middle
 419        <ff d9 ff d8> bytes out, so that one stream remains */
 420     if(tag->id == ST_DEFINEBITS && tag->len>2 && jpegtables) {
 421         fi = save_fopen(name, "wb");
 422         fwrite(jpegtables, 1, jpegtablessize-2, fi); //don't write end tag (ff,d8)
 423         fwrite(&tag->data[2+2], tag->len-2-2, 1, fi); //don't write start tag (ff,d9)
 424         fclose(fi);
 425     }
 426     if(tag->id == ST_DEFINEBITSJPEG2 && tag->len>2) {
 427         int end = tag->len;
 428         int pos = findjpegboundary(&tag->data[2], tag->len-2);
 429         if(pos<0)
 430             return;
 431         pos+=2;
 432         fi = save_fopen(name, "wb");
 433         fwrite(&tag->data[2], pos-2, 1, fi);
 434         fwrite(&tag->data[pos+4], end-(pos+4), 1, fi);
 435         fclose(fi);
 436     }
 437     if(tag->id == ST_DEFINEBITSJPEG3 && tag->len>6) {
 438         U32 end = GET32(&tag->data[2])+6;
 439         int pos = findjpegboundary(&tag->data[6], tag->len-6);
 440         if(pos<0)
 441             return;
 442         pos+=6;
 443         fi = save_fopen(name, "wb");
 444         fwrite(&tag->data[6], pos-6, 1, fi);
 445         fwrite(&tag->data[pos+4], end-(pos+4), 1, fi);
 446         fclose(fi);
 447     }
 448 }
 449
 450 #ifdef _ZLIB_INCLUDED_
 451 static U32 mycrc32;
 452
 453 static U32*crc32_table = 0;
 454 static void make_crc32_table(void)
 455 {
 456   int t;
 457   if(crc32_table)
 458       return;
 459   crc32_table = (U32*)malloc(1024);
 460
 461   for (t = 0; t < 256; t++) {
 462     U32 c = t;
 463     int s;
 464     for (s = 0; s < 8; s++) {
 465       c = (0xedb88320L*(c&1)) ^ (c >> 1);
 466     }
 467     crc32_table[t] = c;
 468   }
 469 }
 470 static void png_write_byte(FILE*fi, U8 byte)
 471 {
 472     fwrite(&byte,1,1,fi);
 473     mycrc32 = crc32_table[(mycrc32 ^ byte) & 0xff] ^ (mycrc32 >> 8);
 474 }
 475 static void png_start_chunk(FILE*fi, char*type, int len)
 476 {
 477     U8 mytype[4]={0,0,0,0};
 478     U32 mylen = REVERSESWAP32(len);
 479     memcpy(mytype,type,strlen(type));
 480     fwrite(&mylen, 4, 1, fi);
 481     mycrc32=0xffffffff;
 482     png_write_byte(fi,mytype[0]);
 483     png_write_byte(fi,mytype[1]);
 484     png_write_byte(fi,mytype[2]);
 485     png_write_byte(fi,mytype[3]);
 486 }
 487 static void png_write_bytes(FILE*fi, U8*bytes, int len)
 488 {
 489     int t;
 490     for(t=0;t<len;t++)
 491         png_write_byte(fi,bytes[t]);
 492 }
 493 static void png_write_dword(FILE*fi, U32 dword)
 494 {
 495     png_write_byte(fi,dword>>24);
 496     png_write_byte(fi,dword>>16);
 497     png_write_byte(fi,dword>>8);
 498     png_write_byte(fi,dword);
 499 }
 500 static void png_end_chunk(FILE*fi)
 501 {
 502     U32 tmp = REVERSESWAP32((mycrc32^0xffffffff));
 503     fwrite(&tmp,4,1,fi);
 504 }
 505
 506
 507 /* extract a lossless image (png) out of a tag
 508    This routine was originally meant to be a one-pager. I just
 509    didn't know png is _that_ much fun. :) -mk
 510  */
 511 void handlelossless(TAG*tag)
 512 {
 513     char name[80];
 514     FILE*fi;
 515     int width, height;
 516     int crc;
 517     int id;
 518     int t;
 519     U8 bpp = 1;
 520     U8 format;
 521     U8 tmp;
 522     U8* data=0;
 523     U8* data2=0;
 524     U8* data3=0;
 525     U32 datalen;
 526     U32 datalen2;
 527     U32 datalen3;
 528     U8 head[] = {137,80,78,71,13,10,26,10};
 529     int cols;
 530     char alpha = tag->id == ST_DEFINEBITSLOSSLESS2;
 531     RGBA* palette;
 532     int pos;
 533     int error;
 534     U32 tmp32;
 535
 536     make_crc32_table();
 537
 538     if(tag->id != ST_DEFINEBITSLOSSLESS &&
 539        tag->id != ST_DEFINEBITSLOSSLESS2)
 540         return;
 541
 542     id =swf_GetU16(tag);
 543     format = swf_GetU8(tag);
 544     if(format == 3) bpp = 8;
 545     if(format == 4) bpp = 16;
 546     if(format == 5) bpp = 32;
 547     if(format!=3 && format!=5) {
 548         if(format==4)
 549         fprintf(stderr, "Can't handle 16-bit palette images yet (image %d)\n",id);
 550         else
 551         fprintf(stderr, "Unknown image type %d in image %d\n", format, id);
 552         return;
 553     }
 554     width = swf_GetU16(tag);
 555     height = swf_GetU16(tag);
 556     if(format == 3) cols = swf_GetU8(tag) + 1;
 557 // this is what format means according to the flash specification. (which is
 558 // clearly wrong)
 559 //    if(format == 4) cols = swf_GetU16(tag) + 1;
 560 //    if(format == 5) cols = swf_GetU32(tag) + 1;
 561     else cols = 0;
 562
 563     logf("<verbose> Width %d", width);
 564     logf("<verbose> Height %d", height);
 565     logf("<verbose> Format %d", format);
 566     logf("<verbose> Cols %d", cols);
 567     logf("<verbose> Bpp %d", bpp);
 568
 569     datalen = (width*height*bpp/8+cols*8);
 570     do {
 571         if(data)
 572             free(data);
 573         datalen+=4096;
 574         data = malloc(datalen);
 575         error = uncompress (data, &datalen, &tag->data[tag->pos], tag->len-tag->pos);
 576     } while(error == Z_BUF_ERROR);
 577     if(error != Z_OK) {
 578         fprintf(stderr, "Zlib error %d (image %d)\n", error, id);
 579         return;
 580     }
 581     logf("<verbose> Uncompressed image is %d bytes (%d colormap)", datalen, (3+alpha)*cols);
 582     pos = 0;
 583     datalen2 = datalen;
 584     data2 = malloc(datalen2);
 585     palette = (RGBA*)malloc(cols*sizeof(RGBA));
 586
 587     for(t=0;t<cols;t++) {
 588         palette[t].r = data[pos++];
 589         palette[t].g = data[pos++];
 590         palette[t].b = data[pos++];
 591         if(alpha) {
 592             palette[t].a = data[pos++];
 593         }
 594     }
 595
 596     sprintf(name, "pic%d.png", id);
 597     fi = save_fopen(name, "wb");
 598     fwrite(head,sizeof(head),1,fi);
 599
 600     png_start_chunk(fi, "IHDR", 13);
 601      png_write_dword(fi,width);
 602      png_write_dword(fi,height);
 603      png_write_byte(fi,8);
 604      if(format == 3)
 605      png_write_byte(fi,3); //indexed
 606      else if(format == 5)
 607      png_write_byte(fi,2); //rgb
 608      else return;
 609
 610      png_write_byte(fi,0); //compression mode
 611      png_write_byte(fi,0); //filter mode
 612      png_write_byte(fi,0); //interlace mode
 613     png_end_chunk(fi);
 614
 615     if(format == 3) {
 616         png_start_chunk(fi, "PLTE", 768);
 617          for(t=0;t<256;t++) {
 618              png_write_byte(fi,palette[t].r);
 619              png_write_byte(fi,palette[t].g);
 620              png_write_byte(fi,palette[t].b);
 621          }
 622         png_end_chunk(fi);
 623     }
 624     {
 625         int pos2 = 0;
 626         int x,y;
 627         int srcwidth = width * (bpp/8);
 628         datalen3 = width*height*4;
 629         data3 = (U8*)malloc(datalen3);
 630         for(y=0;y<height;y++)
 631         {
 632            data3[pos2++]=0; //filter type
 633            if(bpp==32) {
 634             // 32 bit to 24 bit "conversion"
 635             for(x=0;x<width;x++) {
 636                 data3[pos2++]=data[pos+1];
 637                 data3[pos2++]=data[pos+2];
 638                 data3[pos2++]=data[pos+3];
 639                 pos+=4; //ignore padding byte
 640             }
 641            }
 642            else {
 643                 for(x=0;x<srcwidth;x++)
 644                     data3[pos2++]=data[pos++];
 645            }
 646
 647            pos+=((srcwidth+3)&~3)-srcwidth; //align
 648         }
 649         datalen3=pos2;
 650     }
 651
 652     if(compress (data2, &datalen2, data3, datalen3) != Z_OK) {
 653         fprintf(stderr, "zlib error in pic %d\n", id);
 654         return;
 655     }
 656     logf("<verbose> Compressed data is %d bytes", datalen2);
 657     png_start_chunk(fi, "IDAT", datalen2);
 658     png_write_bytes(fi,data2,datalen2);
 659     png_end_chunk(fi);
 660     png_start_chunk(fi, "IEND", 0);
 661     png_end_chunk(fi);
 662
 663     free(data);
 664     free(data2);
 665     free(data3);
 666 }
 667 #endif
 668
 669 FILE*mp3file;
 670 void handlesoundstream(TAG*tag)
 671 {
 672     char*filename = "output.mp3";
 673     if(numextracts==1) {
 674         filename = destfilename;
 675         if(!strcmp(filename,"output.swf"))
 676             filename = "output.mp3";
 677     }
 678     switch(tag->id) {
 679         case ST_SOUNDSTREAMHEAD:
 680             if((tag->data[1]&0x30) == 0x20) { //mp3 compression
 681                 mp3file = fopen(filename, "wb");
 682                 logf("<notice> Writing mp3 data to %s",filename);
 683             }
 684             else
 685                 logf("<error> Soundstream is not mp3");
 686         break;
 687         case ST_SOUNDSTREAMHEAD2:
 688             if((tag->data[1]&0x30) == 0x20) {//mp3 compression
 689                 mp3file = fopen("mainstream.mp3", "wb");
 690                 logf("<notice> Writing mp3 data to %s",filename);
 691             }
 692             else
 693                 logf("<error> Soundstream is not mp3 (2)");
 694         break;
 695         case ST_SOUNDSTREAMBLOCK:
 696             if(mp3file)
 697                 fwrite(&tag->data[4],tag->len-4,1,mp3file);
 698         break;
 699     }
 700 }
 701
 702 int main (int argc,char ** argv)
 703 {
 704     TAG*tag;
 705     SWF swf;
 706     int f;
 707     int found = 0;
 708     int frame = 0;
 709     int tagnum = 0;
 710     char depths[65536];
 711     char listavailable = 0;
 712     processargs(argc, argv);
 713
 714     if(!extractframes && !extractids && ! extractname && !extractjpegids && !extractpngids
 715         && !extractmp3)
 716         listavailable = 1;
 717
 718     if(!filename)
 719     {
 720         fprintf(stderr, "You must supply a filename.\n");
 721         return 1;
 722     }
 723     initLog(0,-1,0,0,-1, verbose);
 724
 725     f = open(filename,O_RDONLY);
 726
 727     if (f<0)
 728     {
 729         perror("Couldn't open file: ");
 730         exit(1);
 731     }
 732     if (swf_ReadSWF(f,&swf) < 0)
 733     {
 734         fprintf(stderr, "%s is not a valid SWF file or contains errors.\n",filename);
 735         close(f);
 736         exit(1);
 737     }
 738     close(f);
 739
 740     if(listavailable) {
 741         listObjects(&swf);
 742         swf_FreeTags(&swf);
 743         return 0;
 744     }
 745
 746     tag = swf.firstTag;
 747     tagnum = 0;
 748     while(tag) {
 749         tagnum ++;
 750         tag = tag->next;
 751     }
 752
 753     tagused = (char*)malloc(tagnum);
 754     memset(tagused, 0, tagnum);
 755     memset(used, 0, 65536);
 756     memset(depths, 0, 65536);
 757
 758     tag = swf.firstTag;
 759     tagnum = 0;
 760     while(tag) {
 761         if(swf_isAllowedSpriteTag(tag)) {
 762             int write = 0;
 763             if(extractframes && is_in_range(frame, extractframes)) {
 764                 write = 1;
 765                 if(tag->id == ST_PLACEOBJECT || tag->id == ST_PLACEOBJECT2) {
 766                     depths[swf_GetDepth(tag)] = 1;
 767                 }
 768                 if(tag->id == ST_REMOVEOBJECT || tag->id == ST_REMOVEOBJECT2) {
 769                     int depth = swf_GetDepth(tag);
 770                     if(!depths[depth])
 771                         write = 0;
 772                     depths[swf_GetDepth(tag)] = 0;
 773                 }
 774             } else {
 775                 if((tag->id == ST_REMOVEOBJECT || tag->id == ST_REMOVEOBJECT2) &&
 776                     (depths[swf_GetDepth(tag)]) && hollow) {
 777                     write = 1;
 778                     depths[swf_GetDepth(tag)] = 0;
 779                 }
 780             }
 781             if(write) {
 782                 enumerateIDs(tag, idcallback);
 783                 found = 1;
 784                 tagused[tagnum] = 1;
 785             }
 786         }
 787
 788         if(tag->id == ST_SOUNDSTREAMHEAD ||
 789            tag->id == ST_SOUNDSTREAMHEAD2 ||
 790            tag->id == ST_SOUNDSTREAMBLOCK) {
 791             handlesoundstream(tag);
 792         }
 793
 794         if(tag->id == ST_JPEGTABLES)
 795             handlejpegtables(tag);
 796
 797         if(swf_isDefiningTag(tag)) {
 798             int id = swf_GetDefineID(tag);
 799             tags[id] = tag;
 800             if(extractids && is_in_range(id, extractids)) {
 801                 used[id] = 5;
 802                 found = 1;
 803             }
 804             if(extractjpegids && is_in_range(id, extractjpegids)) {
 805                 handlejpeg(tag);
 806             }
 807 #ifdef _ZLIB_INCLUDED_
 808             if(extractpngids && is_in_range(id, extractpngids)) {
 809                 handlelossless(tag);
 810             }
 811 #endif
 812         }
 813         else if (tag->id == ST_SETBACKGROUNDCOLOR) {
 814             mainr = tag->data[0];
 815             maing = tag->data[1];
 816             mainb = tag->data[2];
 817         }
 818         else if(tag->id == ST_PLACEOBJECT2) {
 819             char*name = swf_GetName(tag);
 820             if(name && extractname && !strcmp(name, extractname)) {
 821                 int id = swf_GetPlaceID(tag);
 822                 used[id] = 5;
 823                 found = 1;
 824                 tagused[tagnum] = 1;
 825                 depths[swf_GetDepth(tag)] = 1;
 826             }
 827         }
 828         else if(tag->id == ST_SHOWFRAME) {
 829             frame ++;
 830             if(hollow) {
 831                 tagused[tagnum] = 1;
 832                 found = 1;
 833             }
 834         }
 835
 836         if(tag->id == ST_DEFINESPRITE) {
 837             while(tag->id != ST_END) {
 838                 tag = tag->next;
 839                 tagnum ++;
 840             }
 841         }
 842         tag = tag->next;
 843         tagnum ++;
 844     }
 845     if (found)
 846         extractTag(&swf, destfilename);
 847
 848     if(mp3file)
 849         fclose(mp3file);
 850
 851     swf_FreeTags(&swf);
 852     return 0;
 853 }
 854