listswf.c

来自「flash swf file player」· C语言 代码 · 共 1,999 行 · 第 1/3 页

#define FONTINFO_UNICODE	(1<<5)
#define FONTINFO_SHIFTJIS	(1<<4)
#define FONTINFO_ANSI		(1<<3)
#define FONTINFO_ITALIC		(1<<2)
#define FONTINFO_BOLD		(1<<1)
#define FONTINFO_WIDE		(1<<0)

void printFontInfo(FILE *f, int length)
{
  int namelen, nGlyphs, flags, i;

  println("FontID: %i", readUInt16(f));

  namelen = readUInt8(f);
  nGlyphs = length-namelen-4;

  print("Font Name: ");

  for(; namelen>0; --namelen)
    putchar((unsigned char)readUInt8(f));

  putchar('\n');

  flags = readUInt8(f);

  if(flags & FONTINFO_UNICODE)
    println("Unicode character codes!");

  if(flags & FONTINFO_SHIFTJIS)
    println("\tShiftJIS character codes!");

  if(flags & FONTINFO_ANSI)
    println("\tANSI character codes!");

  if(flags & FONTINFO_ITALIC)
    println("\tFont is italic!");

  if(flags & FONTINFO_BOLD)
    println("\tFont is bold!");

  if(flags & FONTINFO_WIDE)
    nGlyphs /= 2;

  for(i=0; i<nGlyphs; ++i)
    if(flags & FONTINFO_WIDE)
      println("glyph %i: %i", i, readUInt16(f));
    else
      println("glyph %i: %i", i, readUInt8(f));
}

#define TEXTRECORD_STATECHANGE	(1<<7)
#define TEXTRECORD_RESERVED		(1<<6 | 1<<5 | 1<<4)
#define TEXTRECORD_HASFONT		(1<<3)
#define TEXTRECORD_HASCOLOR		(1<<2)
#define TEXTRECORD_HASYOFF		(1<<1)
#define TEXTRECORD_HASXOFF		(1<<0)
#define TEXTRECORD_NUMGLYPHS	0x7f

int printTextRecord(FILE *f, int glyphBits, int advanceBits, int type)
{
  int i, numGlyphs;
  int flags = readUInt8(f);

  if(flags == 0)
    return 0;

  if(flags & TEXTRECORD_STATECHANGE)
  {
    if(flags & TEXTRECORD_HASFONT)
      println("font id: %i", readUInt16(f));

    if(flags & TEXTRECORD_HASCOLOR)
    {
      print("color: ");

      if(type == 2)
	printRGBA(f);
      else
	printRGB(f);

      putchar('\n');
    }

    if(flags & TEXTRECORD_HASXOFF)
      println("X Offset: %i", readSInt16(f));

    if(flags & TEXTRECORD_HASYOFF)
      println("Y Offset: %i", readSInt16(f));

    if(flags & TEXTRECORD_HASFONT)
      println("font height: %i", readUInt16(f));
  }
  else
  {
    numGlyphs = flags & TEXTRECORD_NUMGLYPHS;

    for(i=0; i<numGlyphs; ++i)
    {
      println("glyph index: %i", readBits(f, glyphBits));
      println("glyph x advance: %i", readSBits(f, advanceBits));
    }
  }

  return 1;
}

void printDefineText(FILE *f, int length, int type) /* type 2 allows transparency */
{
  int glyphBits, advanceBits, end = fileOffset+length;

  println("character id: %i", readUInt16(f));
  print("bounds: ");
  printRect(f);
  putchar('\n');
  byteAlign();
  println("matrix:");
  printMatrix(f);
  glyphBits = readUInt8(f);
  advanceBits = readUInt8(f);

  while(fileOffset < end &&
	printTextRecord(f, glyphBits, advanceBits, type)) ;
}

void printSoundInfo(FILE *f)
{
  int flags = readUInt8(f), nPoints, i;

  ++gIndent;

  if(flags&0x40)
    println("Don't start if already playing");

  if(flags&0x80)
    println("Stop sound");

  if(flags&0x01)
    println("In Point: %i", readUInt32(f));

  if(flags&0x02)
    println("Out Point: %i", readUInt32(f));

  if(flags&0x04)
    println("Loops: %i", readUInt16(f));

  if(flags&0x08)
  {
    nPoints = readUInt8(f);
    for(i=0; i<nPoints; ++i)
    {
      println("Envelope point %i:", i);
      println("Mark44: %i", readUInt32(f));
      println("Level0: %i", readUInt16(f));
      println("Level1: %i", readUInt16(f));
    }
  }

  --gIndent;
}


#define MP3_FRAME_SYNC       0xFFE00000

#define MP3_VERSION          0x00180000
#define MP3_VERSION_25       0x00000000
#define MP3_VERSION_RESERVED 0x00080000
#define MP3_VERSION_2        0x00100000
#define MP3_VERSION_1        0x00180000

#define MP3_LAYER            0x00060000
#define MP3_LAYER_RESERVED   0x00000000
#define MP3_LAYER_3          0x00020000
#define MP3_LAYER_2          0x00040000
#define MP3_LAYER_1          0x00060000

#define MP3_PROTECT          0x00010000 /* 16-bit CRC after header */

#define MP3_BITRATE          0x0000F000
#define MP3_BITRATE_SHIFT    12

int mp1l1_bitrate_table[] = { 0,   32,   64,  96, 128, 160, 192, 224,
			      256, 288, 320, 352, 382, 416, 448 };

int mp1l2_bitrate_table[] = { 0,   32,   48,  56,  64,  80,  96, 112,
			      128, 160, 192, 224, 256, 320, 384 };

int mp1l3_bitrate_table[] = { 0,    32,  40,  48,  56,  64,  80,  96,
			      112, 128, 160, 192, 224, 256, 320 };

int mp2l1_bitrate_table[] = { 0,    32,  48,  56,  64,  80,  96, 112,
			      128, 144, 160, 176, 192, 224, 256 };

int mp2l23_bitrate_table[] = { 0,    8,  16,  24,  32,  40,  48,  56,
			       64,  80,  96, 112, 128, 144, 160 };

#define MP3_SAMPLERATE       0x00000C00
#define MP3_SAMPLERATE_SHIFT 10

int mp1_samplerate_table[] = { 44100, 48000, 32000 };
int mp2_samplerate_table[] = { 22050, 24000, 16000 }; /* is this right?? */
int mp25_samplerate_table[] = { 11025, 12000, 8000 }; /* less samples in > versions? */

#define MP3_PADDING          0x00000200 /* if set, add an extra slot - 4 bytes
					   for layer 1, 1 byte for 2+3 */

#define MP3_CHANNEL          0x000000C0
#define MP3_CHANNEL_STEREO   0x00000000
#define MP3_CHANNEL_JOINT    0x00000040
#define MP3_CHANNEL_DUAL     0x00000080
#define MP3_CHANNEL_MONO     0x000000C0

/* rest of the header info doesn't affect frame size.. */

void silentSkipBytes(FILE *f, int length)
{
  for(; length>0; --length)
    readUInt8(f);
}

void printMP3Headers(FILE *f, int length)
{
  unsigned long flags;
  int frameLen, frameNum = 0;
  int bitrate, bitrate_idx, samplerate, samplerate_idx;
  int version, layer, channels;
  int padding;

  while(length > 0)
  {
    ++frameNum;

    /* get 4-byte header, bigendian */
    flags = fgetc(f) << 24;
    flags += fgetc(f) << 16;
    flags += fgetc(f) << 8;
    flags += fgetc(f);

    fileOffset += 4;

    if((flags & MP3_FRAME_SYNC) != MP3_FRAME_SYNC)
      error("bad sync on MP3 block!");

    bitrate_idx = (flags & MP3_BITRATE) >> MP3_BITRATE_SHIFT;
    samplerate_idx = (flags & MP3_SAMPLERATE) >> MP3_SAMPLERATE_SHIFT;

    channels = ((flags & MP3_CHANNEL) == MP3_CHANNEL_MONO) ? 1 : 2;

    switch(flags & MP3_VERSION)
    {
      case MP3_VERSION_1:  version = 1; break;
      case MP3_VERSION_2:  version = 2; break;
      case MP3_VERSION_25: version = 25; break;
      default: error("unknown MP3 version!");
    }
    switch(flags & MP3_LAYER)
    {
      case MP3_LAYER_1: layer = 1; break;
      case MP3_LAYER_2: layer = 2; break;
      case MP3_LAYER_3: layer = 3; break;
      default: error("unknown MP3 layer!");
    }

    if(version == 1)
    {
      samplerate = mp1_samplerate_table[samplerate_idx];

      if(layer == 1)
	bitrate = mp1l1_bitrate_table[bitrate_idx];

      else if(layer == 2)
	bitrate = mp1l2_bitrate_table[bitrate_idx];

      else if(layer == 3)
	bitrate = mp1l3_bitrate_table[bitrate_idx];
    }
    else
    {
      if(version == 2)
	samplerate = mp2_samplerate_table[samplerate_idx];
      else
	samplerate = mp25_samplerate_table[samplerate_idx];

      if(layer == 1)
	bitrate = mp2l1_bitrate_table[bitrate_idx];
      else
	bitrate = mp2l23_bitrate_table[bitrate_idx];
    }

    padding = (flags & MP3_PADDING) ? 1 : 0;

    if(layer == 1)
      padding <<= 2;

    if(version == 1)
      frameLen = 144 * bitrate * 1000 / samplerate + padding;
    else
      frameLen = 72 * bitrate * 1000 / samplerate + padding;

    println("frame %i: MP%i layer %i, %i Hz, %ikbps, %s, length=%i, protect %s",
	   frameNum, version, layer, samplerate, bitrate,
	   (channels==2) ? "stereo" : "mono", frameLen,
	   (flags&MP3_PROTECT) ? "on" : "off");

    if(length < frameLen-4)
      silentSkipBytes(f, length);
    else
      silentSkipBytes(f, frameLen-4);

    length -= frameLen;
  }

  if(length>0)
    dumpBytes(f, length);
}

void printDefineSound(FILE *f, int length)
{
  int flags;

  println("Character ID: %i", readUInt16(f));

  flags = readUInt8(f);

  switch(flags&0xf0)
  {
    case 0x20: print("Sound Format: mp3 ");              break;
    case 0x10: print("Sound Format: ADPCM compressed "); break;
    case 0x00: print("Sound Format: uncompressed ");     break;
    default:   print("Sound Format: unknown compression ");
  }

  if((flags&0x0c) == 0)
    puts("5KHz ");
  else if((flags&0x0c) == 4)
    puts("11KHz ");
  else if((flags&0x0c) == 8)
    puts("22KHz ");
  else
    puts("44KHz ");

  if(flags&0x02)
    puts("16 bit ");
  else
    puts("8 bit ");

  if(flags&0x01)
    puts("stereo\n");
  else
    puts("mono\n");

  println("Number of samples: %i", readUInt32(f));

  if((flags&0xf0) == 0x20) /* mp3 */
  {
    ++gIndent;
    println("Delay: %i", readUInt16(f));
    printMP3Headers(f, length-9);
    --gIndent;
  }
  else
    dumpBytes(f, length-7);
}

int streamflags;

/* only difference is type 2 allows uncompressed data,
   and 8-bit if uncompressed */
void printSoundStreamHead(FILE *f, int type)
{
  int recFormat = readUInt8(f);
  int flags = readUInt8(f);

  streamflags = flags;

  println("Recommended Format: %02x", recFormat);
  println("flags: %02x", flags);

  if((flags&0xf0) == 0x20)
  {
    println("mp3 format");
    println("Avg. number of Samples per Block: %i", readUInt16(f));
    println("Mystery goo: %i", readUInt16(f));
  }
  else
    println("Number of Samples: %i", readUInt16(f));
}

void printSoundStreamBlock(FILE *f, int length)
{
  int samplesperframe, delay;

  if((streamflags&0xf0) == 0x00)
  {
    println("Uncompressed samples");
    skipBytes(f, length);
  }
  else if((streamflags&0xf0) == 0x10)
  {
    println("ADPCM compressed samples");
    skipBytes(f, length);
  }
  else if((streamflags&0xf0) == 0x20)
  {
    samplesperframe = readUInt16(f);
    delay = readUInt16(f);
    println("MP3 compressed samples: %i samples, delay=%i",
	    samplesperframe, delay);

    printMP3Headers(f, length-4);
  }
  else
    println("Unknown compression type!");
}

void printSprite(FILE *f, int length)
{
  int start = fileOffset;
  int block, type, l;

  println("id: %i", readUInt16(f));
  println("frame count: %i\n", readUInt16(f));

  while(fileOffset < start+length)
  {
    println("Offset %i (0x%x)", fileOffset, fileOffset);

    block = readUInt16(f);
    type = block>>6;

    println("Block type: %i (%s)", type, blockName(type));

    l = block & ((1<<6)-1);

    if(l == 63) /* it's a long block. */
      l = readUInt32(f);

    println("Block length: %i\n", l);

    ++gIndent;

    switch(type)
    {
      case PLACEOBJECT:		printPlaceObject(f, l);	break;
      case PLACEOBJECT2:	printPlaceObject2(f, l);	break;
      case REMOVEOBJECT:	printRemoveObject(f);		break;
      case REMOVEOBJECT2:	printRemoveObject2(f);		break;
      case FRAMELABEL:		printFrameLabel(f);		break;
      case DOACTION:		decompileAction(f, l, 0);       break;
      case SOUNDSTREAMHEAD:     printSoundStreamHead(f, 1);     break;
      case SOUNDSTREAMHEAD2:    printSoundStreamHead(f, 2);     break;
      case SOUNDSTREAMBLOCK:    printSoundStreamBlock(f, l);    break;
      default:			if(l>0) dumpBytes(f, l);	break;
    }

    --gIndent;
  /*
    startsound
  */
  }
}

#define TEXTFIELD_HASLENGTH (1<<1)
#define TEXTFIELD_NOEDIT    (1<<3)
#define TEXTFIELD_PASSWORD  (1<<4)
#define TEXTFIELD_MULTILINE (1<<5)
#define TEXTFIELD_WORDWRAP  (1<<6)
#define TEXTFIELD_DRAWBOX   (1<<11)
#define TEXTFIELD_NOSELECT  (1<<12)

#define TEXTFIELD_JUSTIFY_LEFT    0
#define TEXTFIELD_JUSTIFY_RIGHT   1
#define TEXTFIELD_JUSTIFY_CENTER  2
#define TEXTFIELD_JUSTIFY_JUSTIFY 3

void printTextField(FILE *f, int length)
{
  int flags, num, end = fileOffset+length;

  println("Character id: %i", readUInt16(f));
  print("Bounds: ");
  printRect(f);
  println("flags: 0x%04x", flags=readUInt16(f));

  if(flags & TEXTFIELD_HASLENGTH)
    println("Has Length");
  if(flags & TEXTFIELD_NOEDIT)
    println("Disable Editing");
  if(flags & TEXTFIELD_PASSWORD)
    println("Password Field");
  if(flags & TEXTFIELD_MULTILINE)
    println("Multiline");
  if(flags & TEXTFIELD_WORDWRAP)
    println("Word Wrap");
  if(flags & TEXTFIELD_DRAWBOX)
    println("Draw Bounding Box");
  if(flags & TEXTFIELD_NOSELECT)
    println("No Select");

  println("Font id: %i", readUInt16(f));
  println("Font height: %i", readUInt16(f));
  print("Color: ");
  printRGBA(f);
  putchar('\n');

  if(flags & TEXTFIELD_HASLENGTH)
    println("Length (max chars): %i", readUInt16(f));

  print("Alignment: ");

  switch(num = readUInt8(f))
  {
    case TEXTFIELD_JUSTIFY_LEFT:    print("left\n");    break;
    case TEXTFIELD_JUSTIFY_RIGHT:   print("right\n");   break;
    case TEXTFIELD_JUSTIFY_CENTER:  print("center\n");  break;
    case TEXTFIELD_JUSTIFY_JUSTIFY: print("justify\n"); break;
    default: println("unexpected justification: %i", num);
  }

  println("Left margin: %i", readUInt16(f));
  println("Right margin: %i", readUInt16(f));
  println("First line indentation: %i", readUInt16(f));
  println("Line spacing: %i", readUInt16(f));

  println("Variable Name: %s", readString(f));

  if(fileOffset<end)
    println("Initial Text: %s", readString(f));

  putchar('\n');

  if(fileOffset<end)
    dumpBytes(f, end-fileOffset);
}

void printLibrarySymbol(FILE *f, int length)
{
  println("mystery number: %i", readUInt16(f));
  println("character id: %i", readUInt16(f));
  println("name: %s", readString(f));
}

void printPassword(FILE *f, int length)
{
  println("mystery number: %i", readUInt16(f));
  println("encrypted password: %s", readString(f));
}

void skipBytes(FILE *f, int length)
{
  ++gIndent;
  println("<%i bytes skipped>", length);
  --gIndent;

  for(; length>0; --length)
    readUInt8(f);
}

int main(int argc, char *argv[])
{
  FILE *f;
  int size, version, block, type, length;

  if(argc > 1)
  {
    if(!(f = fopen(argv[1],"rb")))
      error("Sorry, can't seem to read that file.\n");
  }
  else
    f = stdin;

  while(!feof(f))
  {
    if(fgetc(f)=='F' && fgetc(f)=='W' && fgetc(f)=='S')
      break;
  }

  if(feof(f))
    error("Doesn't look like a swf file to me..\n");

  fileOffset = 3;

  version = readUInt8(f);

  size = readUInt32(f);

  println("File size: %i", size);

  print("Frame size: ");
  printRect(f);
  putchar('\n');

  println("Frame rate: %f / sec.", readUInt8(f)/256.0+readUInt8(f));

  println("Total frames: %i", readUInt16(f));
  putchar('\n');

  for(;;)
  {
    println("Offset: %i (0x%06x)", fileOffset, fileOffset);

    block = readUInt16(f);
    type = block>>6;

    println("Block type: %i (%s)", type, blockName(type));

    length = block & ((1<<6)-1);

    if(length == 63) /* it's a long block. */
      length = readUInt32(f);

    println("Block length: %i", length);
    putchar('\n');

    if(type == 0 || fileOffset >= size || length < 0)
      break;

    ++gIndent;

    switch(type)
    {
      case DEFINESPRITE:        printSprite(f, length);         break;
      case DEFINESHAPE3:
      case DEFINESHAPE2:
      case DEFINESHAPE:         printShape(f, length, type);	break;
      case PLACEOBJECT:		printPlaceObject(f, length);	break;
      case PLACEOBJECT2:	printPlaceObject2(f, length);	break;
      case REMOVEOBJECT:	printRemoveObject(f);		break;
      case REMOVEOBJECT2:	printRemoveObject2(f);		break;
      case SETBACKGROUNDCOLOR:	printSetBackgroundColor(f);	break;
      case FRAMELABEL:		printFrameLabel(f);		break;
      case DEFINEMORPHSHAPE:	printMorphShape(f, length);	break; 
      case DEFINEFONT:		printDefineFont(f, length);	break;
      case DEFINEFONT2:		printDefineFont2(f, length);	break;
      case DEFINEFONTINFO:	printFontInfo(f, length);	break;
      case DEFINETEXT:		printDefineText(f, length, 1);	break;
      case DEFINETEXT2:		printDefineText(f, length, 2);	break;
      case DOACTION:		decompileAction(f, length, 0);	break;
      case DEFINESOUND:         printDefineSound(f, length);    break;
      case SOUNDSTREAMHEAD:     printSoundStreamHead(f, 1);     break;
      case SOUNDSTREAMHEAD2:    printSoundStreamHead(f, 2);     break;
      case SOUNDSTREAMBLOCK:    printSoundStreamBlock(f, length); break;
      case DEFINEBUTTON:        printDefineButton(f, length);   break;
      case DEFINEBUTTON2:       printDefineButton2(f, length);  break;
      case JPEGTABLES:          printJpegStream(f, length);     break;
      case DEFINEBITS:
      case DEFINEBITSJPEG2:     printDefineBitsJpeg(f,length);  break;
      case DEFINEBITSJPEG3:     printDefineBitsJpeg3(f,length); break;
      case DEFINELOSSLESS:
      case DEFINELOSSLESS2:	printDefineBitsLossless(f,length); break;
      case TEXTFIELD:		printTextField(f, length);	break;
      case LIBRARYSYMBOL:	printLibrarySymbol(f, length);	break;
      case PASSWORD:		printPassword(f, length);	break;

      default:                  dumpBytes(f, length);	        break;
    }

    --gIndent;
    putchar('\n');
  }

  dumpBytes(f, size-fileOffset);

  return 0;
}