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     FILE*fi;
 438     sprintf(name, "pic%d.jpeg", GET16(tag->data));
 439     /* swf jpeg images have two streams, which both start with ff d8 and
 440        end with ff d9. The following code handles sorting the middle
 441        <ff d9 ff d8> bytes out, so that one stream remains */
 442     if(tag->id == ST_DEFINEBITS && tag->len>2 && jpegtables) {
 443         fi = save_fopen(name, "wb");
 444         fwrite(jpegtables, 1, jpegtablessize-2, fi); //don't write end tag (ff,d8)
 445         fwrite(&tag->data[2+2], tag->len-2-2, 1, fi); //don't write start tag (ff,d9)
 446         fclose(fi);
 447     }
 448     else if(tag->id == ST_DEFINEBITSJPEG2 && tag->len>2) {
 449         int end = tag->len;
 450         int pos = findjpegboundary(&tag->data[2], tag->len-2);
 451         if(pos<0)
 452             return;
 453         pos+=2;
 454         fi = save_fopen(name, "wb");
 455         fwrite(&tag->data[2], pos-2, 1, fi);
 456         fwrite(&tag->data[pos+4], end-(pos+4), 1, fi);
 457         fclose(fi);
 458     }
 459     else if(tag->id == ST_DEFINEBITSJPEG3 && tag->len>6) {
 460         U32 end = GET32(&tag->data[2])+6;
 461         int pos = findjpegboundary(&tag->data[6], tag->len-6);
 462         if(pos<0)
 463             return;
 464         pos+=6;
 465         fi = save_fopen(name, "wb");
 466         fwrite(&tag->data[6], pos-6, 1, fi);
 467         fwrite(&tag->data[pos+4], end-(pos+4), 1, fi);
 468         fclose(fi);
 469     }
 470     else {
 471         int id = GET16(tag->data);
 472         fprintf(stderr, "Object %d is not a JPEG picture!\n",id);
 473         exit(1);
 474     }
 475 }
 476
 477 #ifdef _ZLIB_INCLUDED_
 478 static U32 mycrc32;
 479
 480 static U32*crc32_table = 0;
 481 static void make_crc32_table(void)
 482 {
 483   int t;
 484   if(crc32_table)
 485       return;
 486   crc32_table = (U32*)malloc(1024);
 487
 488   for (t = 0; t < 256; t++) {
 489     U32 c = t;
 490     int s;
 491     for (s = 0; s < 8; s++) {
 492       c = (0xedb88320L*(c&1)) ^ (c >> 1);
 493     }
 494     crc32_table[t] = c;
 495   }
 496 }
 497 static void png_write_byte(FILE*fi, U8 byte)
 498 {
 499     fwrite(&byte,1,1,fi);
 500     mycrc32 = crc32_table[(mycrc32 ^ byte) & 0xff] ^ (mycrc32 >> 8);
 501 }
 502 static void png_start_chunk(FILE*fi, char*type, int len)
 503 {
 504     U8 mytype[4]={0,0,0,0};
 505     U32 mylen = REVERSESWAP32(len);
 506     memcpy(mytype,type,strlen(type));
 507     fwrite(&mylen, 4, 1, fi);
 508     mycrc32=0xffffffff;
 509     png_write_byte(fi,mytype[0]);
 510     png_write_byte(fi,mytype[1]);
 511     png_write_byte(fi,mytype[2]);
 512     png_write_byte(fi,mytype[3]);
 513 }
 514 static void png_write_bytes(FILE*fi, U8*bytes, int len)
 515 {
 516     int t;
 517     for(t=0;t<len;t++)
 518         png_write_byte(fi,bytes[t]);
 519 }
 520 static void png_write_dword(FILE*fi, U32 dword)
 521 {
 522     png_write_byte(fi,dword>>24);
 523     png_write_byte(fi,dword>>16);
 524     png_write_byte(fi,dword>>8);
 525     png_write_byte(fi,dword);
 526 }
 527 static void png_end_chunk(FILE*fi)
 528 {
 529     U32 tmp = REVERSESWAP32((mycrc32^0xffffffff));
 530     fwrite(&tmp,4,1,fi);
 531 }
 532
 533
 534 /* extract a lossless image (png) out of a tag
 535    This routine was originally meant to be a one-pager. I just
 536    didn't know png is _that_ much fun. :) -mk
 537  */
 538 void handlelossless(TAG*tag)
 539 {
 540     char name[80];
 541     FILE*fi;
 542     int width, height;
 543     int crc;
 544     int id;
 545     int t;
 546     U8 bpp = 1;
 547     U8 format;
 548     U8 tmp;
 549     U8* data=0;
 550     U8* data2=0;
 551     U8* data3=0;
 552     U32 datalen;
 553     U32 datalen2;
 554     U32 datalen3;
 555     U8 head[] = {137,80,78,71,13,10,26,10};
 556     int cols;
 557     char alpha = tag->id == ST_DEFINEBITSLOSSLESS2;
 558     RGBA* palette;
 559     int pos;
 560     int error;
 561     U32 tmp32;
 562
 563     make_crc32_table();
 564
 565     if(tag->id != ST_DEFINEBITSLOSSLESS &&
 566        tag->id != ST_DEFINEBITSLOSSLESS2) {
 567         int id = GET16(tag->data);
 568         fprintf(stderr, "Object %d is not a PNG picture!\n",id);
 569         exit(1);
 570     }
 571
 572     id =swf_GetU16(tag);
 573     format = swf_GetU8(tag);
 574     if(format == 3) bpp = 8;
 575     if(format == 4) bpp = 16;
 576     if(format == 5) bpp = 32;
 577     if(format!=3 && format!=5) {
 578         if(format==4)
 579         fprintf(stderr, "Can't handle 16-bit palette images yet (image %d)\n",id);
 580         else
 581         fprintf(stderr, "Unknown image type %d in image %d\n", format, id);
 582         return;
 583     }
 584     width = swf_GetU16(tag);
 585     height = swf_GetU16(tag);
 586     if(format == 3) cols = swf_GetU8(tag) + 1;
 587 // this is what format means according to the flash specification. (which is
 588 // clearly wrong)
 589 //    if(format == 4) cols = swf_GetU16(tag) + 1;
 590 //    if(format == 5) cols = swf_GetU32(tag) + 1;
 591     else cols = 0;
 592
 593     logf("<verbose> Width %d", width);
 594     logf("<verbose> Height %d", height);
 595     logf("<verbose> Format %d", format);
 596     logf("<verbose> Cols %d", cols);
 597     logf("<verbose> Bpp %d", bpp);
 598
 599     datalen = (width*height*bpp/8+cols*8);
 600     do {
 601         if(data)
 602             free(data);
 603         datalen+=4096;
 604         data = malloc(datalen);
 605         error = uncompress (data, &datalen, &tag->data[tag->pos], tag->len-tag->pos);
 606     } while(error == Z_BUF_ERROR);
 607     if(error != Z_OK) {
 608         fprintf(stderr, "Zlib error %d (image %d)\n", error, id);
 609         return;
 610     }
 611     logf("<verbose> Uncompressed image is %d bytes (%d colormap)", datalen, (3+alpha)*cols);
 612     pos = 0;
 613     datalen2 = datalen;
 614     data2 = malloc(datalen2);
 615     palette = (RGBA*)malloc(cols*sizeof(RGBA));
 616
 617     for(t=0;t<cols;t++) {
 618         palette[t].r = data[pos++];
 619         palette[t].g = data[pos++];
 620         palette[t].b = data[pos++];
 621         if(alpha) {
 622             palette[t].a = data[pos++];
 623         }
 624     }
 625
 626     sprintf(name, "pic%d.png", id);
 627     fi = save_fopen(name, "wb");
 628     fwrite(head,sizeof(head),1,fi);
 629
 630     png_start_chunk(fi, "IHDR", 13);
 631      png_write_dword(fi,width);
 632      png_write_dword(fi,height);
 633      png_write_byte(fi,8);
 634      if(format == 3)
 635      png_write_byte(fi,3); //indexed
 636      else if(format == 5)
 637      png_write_byte(fi,2); //rgb
 638      else return;
 639
 640      png_write_byte(fi,0); //compression mode
 641      png_write_byte(fi,0); //filter mode
 642      png_write_byte(fi,0); //interlace mode
 643     png_end_chunk(fi);
 644
 645     if(format == 3) {
 646         png_start_chunk(fi, "PLTE", 768);
 647          for(t=0;t<256;t++) {
 648              png_write_byte(fi,palette[t].r);
 649              png_write_byte(fi,palette[t].g);
 650              png_write_byte(fi,palette[t].b);
 651          }
 652         png_end_chunk(fi);
 653     }
 654     {
 655         int pos2 = 0;
 656         int x,y;
 657         int srcwidth = width * (bpp/8);
 658         datalen3 = width*height*4;
 659         data3 = (U8*)malloc(datalen3);
 660         for(y=0;y<height;y++)
 661         {
 662            data3[pos2++]=0; //filter type
 663            if(bpp==32) {
 664             // 32 bit to 24 bit "conversion"
 665             for(x=0;x<width;x++) {
 666                 data3[pos2++]=data[pos+1];
 667                 data3[pos2++]=data[pos+2];
 668                 data3[pos2++]=data[pos+3];
 669                 pos+=4; //ignore padding byte
 670             }
 671            }
 672            else {
 673                 for(x=0;x<srcwidth;x++)
 674                     data3[pos2++]=data[pos++];
 675            }
 676
 677            pos+=((srcwidth+3)&~3)-srcwidth; //align
 678         }
 679         datalen3=pos2;
 680     }
 681
 682     if(compress (data2, &datalen2, data3, datalen3) != Z_OK) {
 683         fprintf(stderr, "zlib error in pic %d\n", id);
 684         return;
 685     }
 686     logf("<verbose> Compressed data is %d bytes", datalen2);
 687     png_start_chunk(fi, "IDAT", datalen2);
 688     png_write_bytes(fi,data2,datalen2);
 689     png_end_chunk(fi);
 690     png_start_chunk(fi, "IEND", 0);
 691     png_end_chunk(fi);
 692
 693     free(data);
 694     free(data2);
 695     free(data3);
 696 }
 697 #endif
 698
 699 FILE*mp3file;
 700 void handlesoundstream(TAG*tag)
 701 {
 702     char*filename = "output.mp3";
 703     if(numextracts==1) {
 704         filename = destfilename;
 705         if(!strcmp(filename,"output.swf"))
 706             filename = "output.mp3";
 707     }
 708     switch(tag->id) {
 709         case ST_SOUNDSTREAMHEAD:
 710             if((tag->data[1]&0x30) == 0x20) { //mp3 compression
 711                 mp3file = fopen(filename, "wb");
 712                 logf("<notice> Writing mp3 data to %s",filename);
 713             }
 714             else
 715                 logf("<error> Soundstream is not mp3");
 716         break;
 717         case ST_SOUNDSTREAMHEAD2:
 718             if((tag->data[1]&0x30) == 0x20) {//mp3 compression
 719                 mp3file = fopen(filename, "wb");
 720                 logf("<notice> Writing mp3 data to %s",filename);
 721             }
 722             else
 723                 logf("<error> Soundstream is not mp3 (2)");
 724         break;
 725         case ST_SOUNDSTREAMBLOCK:
 726             if(mp3file)
 727                 fwrite(&tag->data[4],tag->len-4,1,mp3file);
 728         break;
 729     }
 730 }
 731
 732 void handledefinesound(TAG*tag)
 733 {
 734     U8 flags;
 735     U32 samples;
 736     char buf[128];
 737     char*filename = buf;
 738     FILE*fi;
 739     U16 id;
 740     id = swf_GetU16(tag); //id
 741     sprintf(buf, "sound%d.mp3", id);
 742
 743     if(numextracts==1) {
 744         filename = destfilename;
 745         if(!strcmp(filename,"output.swf"))
 746             filename = "output.mp3";
 747     }
 748     flags = swf_GetU8(tag);
 749     if((flags>>4)!=2) {
 750         printf("Sorry, can only extract MP3 sounds. Sound %d is ADPCM or RAW.\n", id);
 751         /* not mp3 */
 752         return;
 753     }
 754     samples = swf_GetU32(tag);
 755
 756     swf_GetU16(tag); //(only for mp3) numsamples_seek
 757
 758     fi = save_fopen(filename, "wb");
 759     fwrite(&tag->data[tag->pos], tag->len - tag->pos, 1, fi);
 760     fclose(fi);
 761 }
 762
 763 int main (int argc,char ** argv)
 764 {
 765     TAG*tag;
 766     SWF swf;
 767     int f;
 768     int found = 0;
 769     int frame = 0;
 770     int tagnum = 0;
 771     char depths[65536];
 772     char listavailable = 0;
 773     processargs(argc, argv);
 774
 775     if(!extractframes && !extractids && ! extractname && !extractjpegids && !extractpngids
 776         && !extractmp3 && !extractsoundids)
 777         listavailable = 1;
 778
 779     if(!filename)
 780     {
 781         fprintf(stderr, "You must supply a filename.\n");
 782         return 1;
 783     }
 784     initLog(0,-1,0,0,-1, verbose);
 785
 786     f = open(filename,O_RDONLY);
 787
 788     if (f<0)
 789     {
 790         perror("Couldn't open file: ");
 791         exit(1);
 792     }
 793     if (swf_ReadSWF(f,&swf) < 0)
 794     {
 795         fprintf(stderr, "%s is not a valid SWF file or contains errors.\n",filename);
 796         close(f);
 797         exit(1);
 798     }
 799     close(f);
 800
 801     if(listavailable) {
 802         listObjects(&swf);
 803         swf_FreeTags(&swf);
 804         return 0;
 805     }
 806
 807     tag = swf.firstTag;
 808     tagnum = 0;
 809     while(tag) {
 810         tagnum ++;
 811         tag = tag->next;
 812     }
 813
 814     tagused = (char*)malloc(tagnum);
 815     memset(tagused, 0, tagnum);
 816     memset(used, 0, 65536);
 817     memset(depths, 0, 65536);
 818
 819     tag = swf.firstTag;
 820     tagnum = 0;
 821     while(tag) {
 822         if(swf_isAllowedSpriteTag(tag)) {
 823             int write = 0;
 824             if(extractframes && is_in_range(frame, extractframes)) {
 825                 write = 1;
 826                 if(tag->id == ST_PLACEOBJECT || tag->id == ST_PLACEOBJECT2) {
 827                     depths[swf_GetDepth(tag)] = 1;
 828                 }
 829                 if(tag->id == ST_REMOVEOBJECT || tag->id == ST_REMOVEOBJECT2) {
 830                     int depth = swf_GetDepth(tag);
 831                     if(!depths[depth])
 832                         write = 0;
 833                     depths[swf_GetDepth(tag)] = 0;
 834                 }
 835             } else {
 836                 if((tag->id == ST_REMOVEOBJECT || tag->id == ST_REMOVEOBJECT2) &&
 837                     (depths[swf_GetDepth(tag)]) && hollow) {
 838                     write = 1;
 839                     depths[swf_GetDepth(tag)] = 0;
 840                 }
 841             }
 842             if(write) {
 843                 enumerateIDs(tag, idcallback);
 844                 found = 1;
 845                 tagused[tagnum] = 1;
 846             }
 847         }
 848
 849         if(tag->id == ST_SOUNDSTREAMHEAD ||
 850            tag->id == ST_SOUNDSTREAMHEAD2 ||
 851            tag->id == ST_SOUNDSTREAMBLOCK) {
 852             if(extractmp3)
 853                 handlesoundstream(tag);
 854         }
 855
 856         if(tag->id == ST_JPEGTABLES)
 857             handlejpegtables(tag);
 858
 859         if(swf_isDefiningTag(tag)) {
 860             int id = swf_GetDefineID(tag);
 861             tags[id] = tag;
 862             if(extractids && is_in_range(id, extractids)) {
 863                 used[id] = 5;
 864                 found = 1;
 865             }
 866             if(extractjpegids && is_in_range(id, extractjpegids)) {
 867                 handlejpeg(tag);
 868             }
 869             if(extractsoundids && is_in_range(id, extractsoundids)) {
 870                 handledefinesound(tag);
 871             }
 872 #ifdef _ZLIB_INCLUDED_
 873             if(extractpngids && is_in_range(id, extractpngids)) {
 874                 handlelossless(tag);
 875             }
 876 #endif
 877         }
 878         else if (tag->id == ST_SETBACKGROUNDCOLOR) {
 879             mainr = tag->data[0];
 880             maing = tag->data[1];
 881             mainb = tag->data[2];
 882         }
 883         else if(tag->id == ST_PLACEOBJECT2) {
 884             char*name = swf_GetName(tag);
 885             if(name && extractname && !strcmp(name, extractname)) {
 886                 int id = swf_GetPlaceID(tag);
 887                 used[id] = 5;
 888                 found = 1;
 889                 tagused[tagnum] = 1;
 890                 depths[swf_GetDepth(tag)] = 1;
 891             }
 892         }
 893         else if(tag->id == ST_SHOWFRAME) {
 894             frame ++;
 895             if(hollow) {
 896                 tagused[tagnum] = 1;
 897                 found = 1;
 898             }
 899         }
 900
 901         if(tag->id == ST_DEFINESPRITE) {
 902             while(tag->id != ST_END) {
 903                 tag = tag->next;
 904                 tagnum ++;
 905             }
 906         }
 907         tag = tag->next;
 908         tagnum ++;
 909     }
 910     if (found)
 911         extractTag(&swf, destfilename);
 912
 913     if(mp3file)
 914         fclose(mp3file);
 915
 916     swf_FreeTags(&swf);
 917     return 0;
 918 }
 919