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