listswf.c

flash swf file player

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>

#include "blocktypes.h"
#include "action.h"
#include "read.h"
#include "decompile.h"


#ifdef NODECOMPILE
#define decompileAction(f,l,n) printDoAction((f),(l))
#endif

/*#define decompileAction(f,l) dumpBytes((f),(l))*/

#define puts(s) fputs((s),stdout)

/* char *blockName(Blocktype type); */
void skipBytes(FILE *f, int length);

#define INDENT_LEVEL 3

void print(const char *s, ...)
{
  va_list ap;
  int n = gIndent*INDENT_LEVEL;

  while(n-- > 0)
    putchar(' ');

  va_start(ap, s);
  vprintf(s, ap);
  va_end(ap);
}
void println(const char *s, ...)
{
  va_list ap;
  int n = gIndent*INDENT_LEVEL;

  while(n-- > 0)
    putchar(' ');

  va_start(ap, s);
  vprintf(s, ap);
  va_end(ap);

  putchar('\n');
}

void printMatrix(FILE *f)
{
  int nBits;
  float num;

  byteAlign();

  if(readBits(f, 1)) /* has scale */
  {
    nBits = readBits(f, 5);
    num = (float)readSBits(f, nBits)/0x10000;
    println("xScale: %f", num);
    num = (float)readSBits(f, nBits)/0x10000;
    println("yScale: %f", num);
  }
  if(readBits(f, 1)) /* has rotate */
  {
    nBits = readBits(f, 5);
    num = (float)readSBits(f, nBits)/0x10000;
    println("rotate0: %f", num);
    num = (float)readSBits(f, nBits)/0x10000;
    println("rotate1: %f", num);
  }

  nBits = readBits(f, 5);
  println("x: %i", readSBits(f, nBits));
  println("y: %i", readSBits(f, nBits));
}

void printCXForm(FILE *f, boolean hasAlpha)
{
  int hasAdd, hasMult, nBits;

  byteAlign();

  hasAdd = readBits(f, 1);
  hasMult = readBits(f, 1);
  nBits = readBits(f, 4);

  if(hasMult)
  {
    puts("x(");
    printf("%i,", readSBits(f, nBits));
    printf("%i,", readSBits(f, nBits));
    printf("%i)", readSBits(f, nBits));
    if(hasAlpha)
      printf("%i,", readSBits(f, nBits));
  }
  else puts("x()");

  if(hasAdd)
  {
    puts("+(");
    printf("%i,", readSBits(f, nBits));
    printf("%i,", readSBits(f, nBits));
    printf("%i)", readSBits(f, nBits));
    if(hasAlpha)
      printf("%i,", readSBits(f, nBits));
  }
  else puts("+()");

  putchar('\n');
}


void printRect(FILE *f)
{
  int nBits, xMin, xMax, yMin, yMax;

  byteAlign();

  nBits = readBits(f, 5);
  xMin = readSBits(f, nBits);
  xMax = readSBits(f, nBits);
  yMin = readSBits(f, nBits);
  yMax = readSBits(f, nBits);

  printf("(%i,%i)x(%i,%i)", xMin, xMax, yMin, yMax);
}

void printRGB(FILE *f)
{
  int r = readUInt8(f);
  int g = readUInt8(f);
  int b = readUInt8(f);

  printf("(%02x,%02x,%02x)", r, g, b);
}

void printRGBA(FILE *f)
{
  int r = readUInt8(f);
  int g = readUInt8(f);
  int b = readUInt8(f);
  int a = readUInt8(f);

  printf("(%02x,%02x,%02x,%02x)", r, g, b, a);
}

void printGradient(FILE *f, int shapeType)
{
  int i;
  int numGrads = readUInt8(f);

  for(i=0; i<numGrads; ++i)
  {
    print("Grad[%i]: ratio=%i, ", i, readUInt8(f));
    puts("color=");

    if(shapeType==DEFINESHAPE3)
      printRGBA(f);
    else
      printRGB(f);

    putchar('\n');
  }
}

void printMorphGradient(FILE *f)
{
  int i;
  int numGrads = readUInt8(f);

  for(i=0; i<numGrads; ++i)
  {
    print("Shape 1, Grad[%i]: ratio=%i, ", i, readUInt8(f));
    puts("color=");
    printRGBA(f);
    putchar('\n');

    print("Shape 2, Grad[%i]: ratio=%i, ", i, readUInt8(f));
    puts("color=");
    printRGBA(f);
    putchar('\n');
  }
}

void printLineStyleArray(FILE *f, int shapeType)
{
  int count, i;

  count = readUInt8(f);

  if(count==255)
    count = readUInt16(f);

  for(i=0; i<count; ++i)
  {
    print("LineStyle %i: ", i+1);
    printf("width=%i ", readUInt16(f));

    if(shapeType==DEFINEMORPHSHAPE)
      printf("width2=%i ", readUInt16(f));

    puts("color=");

    if(shapeType==DEFINESHAPE3 || shapeType==DEFINEMORPHSHAPE)
      printRGBA(f);
    else
      printRGB(f);

    if(shapeType==DEFINEMORPHSHAPE)
    {
      puts("color2=");
      printRGBA(f);
    }

    putchar('\n');
  }
}

void printFillStyle(FILE *f, int shapeType)
{
  int type;
	
  type = readUInt8(f);

  if(type==0) /* solid fill */
  {
    print("color=");

    if(shapeType==DEFINESHAPE3 || shapeType==DEFINEMORPHSHAPE)
      printRGBA(f);
    else
      printRGB(f);

    if(shapeType==DEFINEMORPHSHAPE)
    {
      print("color2=");
      printRGBA(f);
    }

    putchar('\n');
  }
  else if(type==0x10 || type==0x12) /* linear (0x10) or radial (0x10) gradient */
  {
    println("Matrix:");
    ++gIndent;
    printMatrix(f);
    --gIndent;

    if(shapeType==DEFINEMORPHSHAPE)
    {
      println("Matrix2:");
      ++gIndent;
      printMatrix(f);
      --gIndent;
    }

    println("Gradient:");
    ++gIndent;
    if(shapeType==DEFINEMORPHSHAPE)
      printMorphGradient(f);
    else
      printGradient(f, shapeType);
    --gIndent;
  }
  else if(type==0x40 || type==0x41) /* tiled bitmap (0x40) or clipped bitmap (0x41) fill */
  {
    println("Bitmap id: %i", readUInt16(f));
    println("Bitmap matrix:");
    ++gIndent;
    printMatrix(f);
    --gIndent;

    if(shapeType==DEFINEMORPHSHAPE)
    {
      println("Bitmap matrix:");
      ++gIndent;
      printMatrix(f);
      --gIndent;
    }
  }
  else
    println("Unknown fill type: %i", type);
}

void printFillStyleArray(FILE *f, int shapeType)
{
  int count, i;

  count = readUInt8(f);

  if(count==255)
    count = readUInt16(f);

  for(i=0; i<count; ++i)
  {
    println("FillStyle %i:", i+1);
    ++gIndent;
    printFillStyle(f, shapeType);
    --gIndent;
    putchar('\n');
  }
}

int printShapeRec(FILE *f, int *lineBits, int *fillBits, int shapeType)
{
  int type;

  //  printf("(%i:%i)",fileOffset,bufbits);

  type = readBits(f, 1);

  if(type==0) /* state change */
  {
    int newStyles = readBits(f, 1);
    int lineStyle = readBits(f, 1);
    int fillStyle1 = readBits(f, 1);
    int fillStyle0 = readBits(f, 1);
    int moveTo = readBits(f, 1);

    if(newStyles==0 && lineStyle==0 && fillStyle1==0 && fillStyle0==0 && moveTo==0)
    {
      println("EndShape");
      return 0;
    }

    if(moveTo==1)
    {
      int moveBits = readBits(f, 5);
      int x = readSBits(f, moveBits);
      int y = readSBits(f, moveBits);

      println("MoveTo (%i) - (%i,%i)", moveBits, x, y);
    }

    if(fillStyle0==1)
      println("FillStyle0: %i", readBits(f, *fillBits));

    if(fillStyle1==1)
      println("FillStyle1: %i", readBits(f, *fillBits));

    if(lineStyle==1)
      println("LineStyle1: %i", readBits(f, *lineBits));

    if(newStyles==1)
    {
      println("NewStyles:");
      printFillStyleArray(f, shapeType);
      printLineStyleArray(f, shapeType);
      *fillBits = readBits(f, 4);
      *lineBits = readBits(f, 4);
    }
  }
  else /* it's an edge record */
  {
    int straight = readBits(f, 1);
    int numBits = readBits(f, 4)+2;

    if(straight==1)
    {
      if(readBits(f, 1)) /* general line */
      {
	int x = readSBits(f, numBits);
	int y = readSBits(f, numBits);

	println("StraightEdge: (%i) - (%i,%i)", numBits, x, y);
      }
      else
	if(readBits(f, 1)) /* vert = 1 */
	  println("StraightEdge: (%i) - (0,%i)", numBits, readSBits(f, numBits));
	else
	  println("StraightEdge: (%i) - (%i,0)", numBits, readSBits(f, numBits));
    }
    else
    {
      int controlX = readSBits(f, numBits);
      int controlY = readSBits(f, numBits);
      int anchorX = readSBits(f, numBits);
      int anchorY = readSBits(f, numBits);
      println("CurvedEdge: (%i) - (%i,%i)->(%i,%i)", numBits, controlX, controlY, anchorX, anchorY);
    }
  }

  return 1;
}

void printShape(FILE *f, int length, Blocktype type)
{
  int start = fileOffset;
  int fillBits, lineBits;

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

  print("Bounds: ");
  printRect(f);

  putchar('\n');
  putchar('\n');

  printFillStyleArray(f, type);
  printLineStyleArray(f, type);

  putchar('\n');

  byteAlign();

  fillBits = readBits(f,4);
  lineBits = readBits(f,4);

  while(fileOffset < length+start &&
	printShapeRec(f, &lineBits, &fillBits, type)) ;

  /* go for end tag..
  if(fileOffset == length+start && bufbits > 5)
    printShapeRec(f, &lineBits, &fillBits, type);
  */

  putchar('\n');
}

void printMorphShape(FILE *f, int length)
{
  int offset, start = fileOffset;
  int fillBits, lineBits, here;

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

  print("Bounds1: ");
  printRect(f);
  putchar('\n');
  print("Bounds2: ");
  printRect(f);
  putchar('\n');

  offset = readUInt32(f);
  println("(%i)\toffset = %i", fileOffset, offset);

  here = fileOffset;

  printFillStyleArray(f, DEFINEMORPHSHAPE);
  printLineStyleArray(f, DEFINEMORPHSHAPE);

  fillBits = readBits(f, 4);
  lineBits = readBits(f, 4);

  putchar('\n');
  println("Shape1:");
  while(fileOffset < here+offset)
    printShapeRec(f, &lineBits, &fillBits, DEFINESHAPE3);

  byteAlign();

  /* ??? */
  fillBits = readBits(f, 4);
  lineBits = readBits(f, 4);

  putchar('\n');
  println("Shape2:");
  while(fileOffset < start+length)
    printShapeRec(f, &lineBits, &fillBits, DEFINESHAPE3);
}

/* JPEG stream markers: */
#define JPEG_MARKER 0xFF

/* Start of Image, End of Image */
#define JPEG_SOI  0xD8
#define JPEG_EOI  0xD9

#define JPEG_JFIF 0xE0

/* encoding markers, quantization tables and Huffman tables */
#define JPEG_QUANT 0xDB
#define JPEG_HUFF  0xC4

/* image markers, start of frame and start of scan */
#define JPEG_SOF0 0xC0
#define JPEG_SOF1 0xC1
#define JPEG_SOF2 0xC2
#define JPEG_SOS  0xDA

void printJpegStream(FILE *f, int length)
{
  int end = fileOffset+length;
  int c, l;

  while(fileOffset < end)
  {
    if(readUInt8(f) != JPEG_MARKER)
    {
      println("Jpeg marker not found!");
      break;
    }

    switch(c=readUInt8(f))
    {
      case JPEG_SOI:   println("SOI"); break;
      case JPEG_EOI:   println("EOI"); break;
      case JPEG_JFIF:  println("JFIF"); break;
      case JPEG_QUANT: println("Quantization table"); break;
      case JPEG_HUFF:  println("Huffman table"); break;
      case JPEG_SOF0:  println("Start of frame 0"); break;
      case JPEG_SOF1:  println("Start of frame 1"); break;
      case JPEG_SOF2:  println("Start of frame 2"); break;
      case JPEG_SOS:   println("Start of scan"); break;
      default:         println("Unknown JPEG block: %02x", c);
    }

    if(c==JPEG_SOS)
      break;

    if(c != JPEG_SOI && c != JPEG_EOI)
    {
      l = (readUInt8(f)<<8) + readUInt8(f);
      skipBytes(f, l-2);
    }
  }

  skipBytes(f, end-fileOffset);
}

void printDefineBitsJpeg(FILE *f, int length)
{
  println("Bitmap id: %i", readUInt16(f));
  printJpegStream(f, length-2);
}

void printDefineBitsJpeg3(FILE *f, int length)
{
  int offset;

  println("Bitmap id: %i", readUInt16(f));

  offset = readUInt32(f);

  printJpegStream(f, offset);

  putchar('\n');
  println("zlib-compressed alpha data:");

  skipBytes(f, length-offset-6);
}

void printDefineBitsLossless(FILE *f, int length)
{
  int format, start = fileOffset;
  int width, height, tablesize;

  println("Bitmap id: %i", readUInt16(f));

  print("Format: ");
  switch(format = readUInt8(f))
  {
    case 3: puts("8 bpp\n"); break;
    case 4: puts("16 bpp\n"); break;
    case 5: puts("32 bpp\n"); break;
    default: error("unknown bit format: %i", format); break;
  }

  println("Width: %i", width = readUInt16(f));
  println("Height: %i", height = readUInt16(f));

  if(format == 3)
    println("Number of palette entries: %i", tablesize = readUInt8(f)+1);

  putchar('\n');
  println("zlib-compressed image data:");

  {
    unsigned char *data, *buffer;
    long size = width*height;
    long bufsize = start+length-fileOffset;
    int i, res;

    buffer = malloc(bufsize);

    for(i=0; i<bufsize; ++i)
      buffer[i] = readUInt8(f);

    if(format == 3)
      size += tablesize*4;
    else
      size *= 4;

    data = malloc(size);

    /*
    if((res = uncompress(data, &size, buffer, bufsize)) != Z_OK)
      error("Couldn't uncompress bits! (err: %i)\n", res);

    dumpBuffer(data, size);
    */
  }

  skipBytes(f, start+length-fileOffset);
  //  dumpBytes(f, start+length-fileOffset);
}

void printDoAction(FILE *f, int length);

char *dictionary[256];

int printActionRecord(FILE *f)
{
  int length = 0, type = readUInt8(f);

  if((type&0x80) == 0x80)
    length = readUInt16(f);

  switch(type)
  {
    case SWFACTION_ADD:
      println("Add");
      break;
    case SWFACTION_SUBTRACT:
      println("Subtract");
      break;
    case SWFACTION_MULTIPLY:
      println("Multiply");
      break;
    case SWFACTION_DIVIDE:
      println("Divide");
      break;
    case SWFACTION_EQUAL:
      println("Equals");
      break;
    case SWFACTION_LESSTHAN:
      println("Less Than");
      break;
    case SWFACTION_LOGICALAND:
      println("And");
      break;
    case SWFACTION_LOGICALOR:
      println("Or");
      break;
    case SWFACTION_LOGICALNOT:
      println("Not");
      break;
    case SWFACTION_STRINGEQ:
      println("String eq");
      break;
    case SWFACTION_STRINGLENGTH:
      println("String Length");
      break;
    case SWFACTION_SUBSTRING:
      println("Substring");
      break;
    case SWFACTION_INT:
      println("Int");
      break;
    case SWFACTION_POP:
      println("Pop");
      break;
    case SWFACTION_SWAP:
      println("Swap");
      break;
    case SWFACTION_INITOBJECT:
      println("Init Object");
      break;
    case SWFACTION_INITARRAY:
      println("Init Array");
      break;
    case SWFACTION_GETVARIABLE:
      println("Get Variable");