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