swfmill 0.0.1

data/ext/swfmill/src/SWFReader.cpp

@@ -0,0 +1,352 @@
+#include "SWFReader.h"
+#include "SWFTag.h"
+#include "SWFAction.h"
+#include <cstring>
+
+namespace SWF {
+
+Reader::Reader( const unsigned char *d, size_t l ) {
+	data = d;
+	length = l;
+	pos = 0;
+	buf = bits = 0;
+	err = 0;
+}
+
+bool Reader::getData( void *dst, size_t len ) {
+	if( pos+len > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return false;
+	} else {
+		memcpy( dst, &data[pos], len );
+		pos += len;
+		return true;
+	}
+}
+
+uint8_t Reader::getByte() {
+	if( pos+1 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+	return data[pos++];
+}
+
+uint16_t Reader::getWord() {
+	if( pos+2 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+	// FIXME x86-centric?
+	int r = data[pos++];
+	r += data[pos++]<<8;
+	return r;
+}
+
+uint32_t Reader::getInt() {
+	if( pos+4 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+	int r;
+
+	// FIXME x86-centric?
+	r = data[pos++];
+	r += data[pos++]<<8;
+	r += data[pos++]<<16;
+	r += data[pos++]<<24;
+
+	return r;
+}
+
+uint64_t Reader::getInt64() {
+	if( pos+8 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+	uint64_t val;
+	val = (uint64_t)getInt() << 32;
+	val |= (uint64_t)getInt();
+	return( val );
+}
+
+uint32_t Reader::getU30() {
+	uint32_t r = 0;
+	unsigned char c;
+
+	for( int i = 0; i < 5; i++ ) {
+		c = data[pos++];
+		r |= (c & 0x7F) << (7 * i);
+		
+		if( !(c & 0x80) ) {
+			return r;
+		}
+
+		if( pos > length ) {
+			err = SWFR_EOF;
+			pos = length+1;
+			return 0;
+		}
+	}
+
+	return r;
+}
+
+int Reader::getS24() {
+	if( pos+3 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+
+	int r = data[pos++];
+	r += data[pos++]<<8;
+	r += ((signed char)data[pos++])<<16;
+	return r;
+}
+
+float Reader::getFloat() {
+    /*
+	if( pos+4 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+	// FIXME x86-centric?
+	int r = data[pos++];
+	r += data[pos++]<<8;
+	r += data[pos++]<<16;
+	r += data[pos++]<<24;
+	return *((float*)&r);
+    */
+    union {
+        float f;
+        uint32_t ul;
+    } u;
+
+    u.ul = getInt();
+    return u.f;
+}
+
+double Reader::getDouble() {
+/*	if( pos+8 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+	// FIXME x86-centric?
+	char value[8];
+	value[4] = data[pos++];
+	value[5] = data[pos++];
+	value[6] = data[pos++];
+	value[7] = data[pos++];
+	value[0] = data[pos++];
+	value[1] = data[pos++];
+	value[2] = data[pos++];
+	value[3] = data[pos++];
+
+	return *(double*)value;
+*/
+    union {
+        double d;
+        uint64_t ull;
+    } u;
+
+    u.ull = getInt64();
+    return u.d;
+}
+
+double Reader::getDouble2() {
+	if( pos+8 > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+	
+	union {
+		double d;
+		char c[8];
+	} u;
+
+	
+	// FIXME x86-centric?
+	for( int i = 0; i < 8; i++ ) {
+		u.c[i] =  data[pos++];
+	}
+
+	return u.d;
+}
+
+float Reader::getHalf() {
+	uint16_t r = getWord();
+	
+	int sign = (r & 0x8000) >> 15;
+	int exp = (r & 0x7C00) >> 10;
+	int man = (r & 0x3FF);
+
+	if(exp == 0) {
+		if(man != 0) {
+			while(!(man & 0x400)) {
+				man <<= 1;
+				exp -= 1;
+			}
+			exp += 1 - 15 + 127;
+			man &= 0x3FF;
+		}
+	} else if(exp == 0x1F) {
+		exp = 0xFF;
+	} else {
+		exp += -15 + 127;
+	}
+
+    union {
+        float f;
+        uint32_t ul;
+    } u;
+
+	u.ul = (sign << 31) | (exp << 23) | (man << 13);
+	return u.f;
+}
+
+unsigned int Reader::getEncodedU32() {
+    
+    unsigned int result = data[pos++];
+    if (!(result & 0x00000080)) return result;
+
+    result = (result & 0x0000007f) | data[pos++] << 7;
+    if (!(result & 0x00004000)) return result;
+
+    result = (result & 0x00003fff) | data[pos++] << 14;
+    if (!(result & 0x00200000)) return result;
+
+    result = (result & 0x001fffff) | data[pos++] << 21;
+    if (!(result & 0x10000000)) return result;
+
+    result = (result & 0x0fffffff) | data[pos++] << 28;
+    return result;
+
+}
+
+double Reader::getFixed( int bytesize, int exp ) {
+	/* putFixed/getFixed are deprecated: they implicitly to byteAlign */
+	
+	double r = 0;
+	if( pos+bytesize > length ) {
+		err = SWFR_EOF;
+		pos = length+1;
+		return 0;
+	}
+
+	for( int i=0; i<bytesize; i++ ) {
+		r += data[pos++]<<(8*i);
+	}
+	return r / ((double)(1<<exp));
+}
+
+char *Reader::getString() {
+	byteAlign();
+	const char *src = (const char *)&data[pos];
+	size_t len = strlen(src) + 1;
+	char *dst = new char[len];
+	strcpy(dst, src);
+	pos += len;
+	return( dst );
+}
+
+char *Reader::getPString() {
+	byteAlign();
+	int len = getByte();
+	char *dst = new char[len+1];
+	getData( dst, len );
+	dst[len]=0;
+	return( dst );
+}
+
+char *Reader::getPStringU30() {
+	byteAlign();
+	uint32_t len = getU30();
+	char *dst = new char[len+1];
+	getData( dst, len );
+	dst[len]=0;
+	return( dst );
+}
+
+long Reader::getNBitInt( int n, bool is_signed ) {
+	// FIXME: unefficient, maybe incorrect!
+	int orig_n = n;
+	long r = buf;
+	if( n == bits ) {
+		bits = buf = 0;
+		goto ret;
+	}
+	if( n > bits ) {
+		n -= bits;
+		while( n > 8 ) {
+			r <<= 8;
+			r += getByte();
+			n-=8;
+		}
+		buf = getByte();
+		
+		if( n > 0 ) {
+			r <<= n;
+			bits = 8-n;
+
+			r += buf >> (8-n);
+			buf &= (1<<bits)-1;
+		}
+		goto ret;
+	}
+		
+	r = buf >> (bits-n);
+	bits -= n;
+	buf &= (1<<bits)-1;
+	
+ret:	
+	long sign = (1<<(orig_n-1));
+	if( is_signed && (r&sign)!=0 ) {
+		r |= - (long) sign;
+	}
+	
+	return r;
+}
+
+double Reader::getNBitFixed( int n, int m, bool is_signed ) {
+	double d;
+	d = getNBitInt( n, is_signed );
+	d /= (double)(1<<m);
+	return d;
+}
+
+double Reader::getNBitFixed2( int n, int m, bool is_signed ) {
+	if( n%8 != 0 ) {
+		fprintf(stderr,"WARNING: fixedpoint2 needs a size that is divisible by 8");
+		return 0;
+	}
+	return( getFixed( n/8, m ) );
+}
+
+void Reader::dump( int len, int ofs ) {
+	const unsigned char *d = &data[pos+ofs];
+	
+	int i=0;
+	printf("DumpingReader %i - %i\n", pos+ofs, pos+ofs+len );
+	while( i<len ) {
+		for( int n=0; n<4 && i<len; n++ ) {
+			for( int b=7; b>=0; b-- ) {
+				printf( d[i] & (1<<b) ? "1" : "0" );
+			}
+			printf(" 0x%02X %03i  ", d[i], d[i] );
+			printf(" ");
+			i++;
+		}
+		printf("\n");
+	}
+}
+	
+}

data/ext/swfmill/src/SWFReader.h

@@ -0,0 +1,73 @@
+#ifndef SWF_Reader_H
+#define SWF_Reader_H
+
+#include <cstdio>
+#include <stdint.h>
+#include "SWFBasic.h"
+
+namespace SWF {
+	
+#define SWFR_OK		0	
+#define SWFR_ERROR	1
+#define SWFR_EOF	2
+
+class Reader {
+	public:
+		Reader( const unsigned char *data, size_t length );
+	
+		// these implicitly do byteAlign()
+		bool getData( void *dst, size_t length );
+		uint8_t getByte();
+		uint16_t getWord();
+		uint32_t getInt();
+		uint64_t getInt64();
+		uint32_t getU30();
+		int getS24();
+		float getFloat();
+		double getDouble();
+		double getDouble2();
+		float getHalf();
+		double getFixed( int bytesize, int decimals );
+		char *getString();
+		char *getPString();
+		char *getPStringU30();
+		
+		unsigned int getEncodedU32();	
+	
+		// this one cares about the current bit position
+		long getNBitInt( int n, bool is_signed = false );
+		double getNBitFixed( int n, int m, bool is_signed = false ); // n bits total, m bits after decimal point.
+		double getNBitFixed2( int n, int m, bool is_signed = false );
+	
+		// set bit position to next byte.
+		void byteAlign() { 
+			if( buf != 0 ) fprintf(stderr,"buf is nonzero in byteAlign() @%i\n", pos );
+			buf = bits = 0; }
+				
+		int getError() { return err; }
+
+		const unsigned char *getRawData() { return data; }
+		int getPosition() { return pos; }
+		int getLength() { return length; }
+		int getBits() { return bits; }
+		void setEOF() { pos=length; }
+		void seekTo( int p ) { pos=p; }
+		
+		void dump( int n, int ofs ); // dumps n bytes from current position to stdout
+		
+	protected:
+		// the uncompressed swf data and our position within
+		const unsigned char *data;
+		int pos, length;
+	
+		// buf is the current byte when in "NBit mode"
+		// bits is the number of bits represented in buf.
+		uint8_t buf, bits;
+	
+		int err;
+
+		bool read( void *dst, size_t n );
+};
+
+}
+#endif

data/ext/swfmill/src/SWFShapeItem.cpp

@@ -0,0 +1,220 @@
+#include <SWFShapeItem.h>
+#include "SWF.h"
+#include <cstring>
+
+namespace SWF {
+
+ShapeItem::ShapeItem() {
+	type = 0;
+}
+	
+bool ShapeItem::isEnd() {
+	if( type != 0 ) return false;
+	ShapeSetup *self = (ShapeSetup*)this;
+	return( !( self->gethasNewStyles()
+			|| self->gethasLineStyle()
+			|| self->gethasFillStyle0()
+			|| self->gethasFillStyle1()
+			|| self->gethasMoveTo()) );
+}
+
+int ShapeItem::getHeaderSize(int size) {
+	switch( type ) {
+		case 0:
+			return 1;
+		case 1:
+		case 2:
+			return 2;
+	}
+	return 0;
+}
+	
+ShapeItem *ShapeItem::get( Reader *r, int end, Context *ctx ) {
+
+	if( r->getPosition() == end && r->getBits() < 6 ) {
+		return NULL;
+	}
+	
+	ShapeItem *ret;
+	int type = 0;
+	int isSetup = !r->getNBitInt(1);
+
+	if( isSetup ) {
+		ret = new ShapeSetup;
+		type = 0;
+	} else {
+		int isLine = r->getNBitInt(1);
+	
+		if( isLine ) {
+			ret = new LineTo;
+			type = 1;
+		} else {
+			ret = new CurveTo;
+			type = 2;
+		}
+	}
+
+	ret->setType( type );
+	ret->parse( r, end, ctx );
+	return ret;
+}
+
+ShapeItem *ShapeItem::getByName( const char *name ) {
+	
+	ShapeItem *ret = NULL;
+	int type = 0;
+	if( !strcmp( name, "ShapeSetup" ) ) {
+		ret = new ShapeSetup;
+		type = 0;
+	} else if( !strcmp( name, "LineTo" ) ) {
+		ret = new LineTo;
+		type = 1;
+	} else if( !strcmp( name, "CurveTo" ) ) {
+		ret = new CurveTo;
+		type = 2;
+	}
+	
+	if( ret ) {
+		ret->setType( type );
+	}
+
+	return ret;
+}
+
+void ShapeItem::writeHeader( Writer *w, Context *ctx, size_t len ) {
+	if( type == 0 ) {
+		w->putNBitInt(0,1);
+	} else {
+		w->putNBitInt(1,1);
+		if( type == 1 ) {
+			w->putNBitInt(1,1);
+		} else {
+			w->putNBitInt(0,1);
+		}
+	}
+}
+
+LineTo::LineTo() {
+	bits = x = y = 0;
+	type = 1;
+}
+
+bool LineTo::parse( Reader *r, int end, Context *ctx ) {
+	file_offset = r->getPosition();
+
+	bits = r->getNBitInt( 4 );
+	int hasBoth = r->getNBitInt(1);
+
+	x=y=0;
+	
+	if( hasBoth ) {
+		x = r->getNBitInt(bits+2,true);
+		y = r->getNBitInt(bits+2,true);
+	} else {
+		int hasY = r->getNBitInt(1);
+		if( hasY ) {
+			y = r->getNBitInt(bits+2,true);
+		} else {
+			x = r->getNBitInt(bits+2,true);
+		}
+	}
+	if( ctx->debugTrace ) {
+		fprintf(stderr,"PARSE LineTo @%i: %ibits %i/%i\n", file_offset, bits, x, y );
+	}
+	return r->getError() == SWFR_OK;
+}
+
+void LineTo::dump( int n, Context *ctx ) {
+	for( int i=0; i<n; i++ ) printf("  ");
+	printf("LineTo (%i+2bit) ", bits);
+	if( x ) printf("%i,", x); else printf("-,");
+	if( y ) printf("%i", y); else printf("-");
+	printf("\n");
+}
+
+size_t LineTo::calcSize( Context *ctx, int start_at ) {
+	int r=start_at;
+	if( x != 0 && y != 0 ) {
+		r += 4 + 1 + ((bits+2)*2);
+	} else {
+		r += 4 + 2 + (bits+2);
+	}
+	r += ShapeItem::getHeaderSize(r-start_at);
+	return r-start_at;
+}
+
+void LineTo::write( Writer *w, Context *ctx ) {
+	if( ctx->debugTrace ) {
+		printf("WRITE LineTo @%i %ibits %i/%i\n", w->getBitPosition()/8, bits, x, y  );
+		dump(1,ctx);
+	}
+
+	ShapeItem::writeHeader( w, ctx, 0 );
+	w->putNBitInt( bits, 4 );
+	
+	if( x != 0 && y != 0 ) {
+		w->putNBitInt(1,1);
+		w->putNBitInt(x,bits+2,true);
+		w->putNBitInt(y,bits+2,true);
+	} else if( x != 0 ) {
+		w->putNBitInt(0,1);
+		w->putNBitInt(0,1);
+		w->putNBitInt(x,bits+2,true);
+	} else {
+		w->putNBitInt(0,1);
+		w->putNBitInt(1,1);
+		w->putNBitInt(y,bits+2,true);
+	}
+}
+
+void LineTo::writeXML( xmlNodePtr xml, Context *ctx ) {
+	char tmp[32];
+	xmlNodePtr node = xmlNewChild( xml, NULL, (const xmlChar *)"LineTo", NULL );
+	
+	snprintf( tmp, 32, "%i", x );
+	xmlSetProp( node, (const xmlChar *)"x", (const xmlChar *)tmp );
+
+	snprintf( tmp, 32, "%i", y );
+	xmlSetProp( node, (const xmlChar *)"y", (const xmlChar *)tmp );
+}
+
+void LineTo::parseXML( xmlNodePtr node, Context *ctx ) {
+	xmlChar *tmp;
+	
+	x = y = 0;
+	bits = 0;
+	
+	tmp = xmlGetProp( node, (const xmlChar *)"x" );
+	if( tmp ) {
+		sscanf( (char*)tmp, "%i", &x);
+		xmlFree( tmp );
+		int b = SWFBitsNeeded( x, true );
+		b -= 2;
+		if( b<0 ) b=0;
+		if( b > bits ) bits = b;
+	}
+
+	tmp = xmlGetProp( node, (const xmlChar *)"y" );
+	if( tmp ) {
+		sscanf( (char*)tmp, "%i", &y);
+		xmlFree( tmp );
+		int b = SWFBitsNeeded( y, true );
+		b -= 2;
+		if( b<0 ) b=0;
+		if( b > bits ) bits = b;
+	}
+}
+
+void LineTo::setx( int _x ) {
+	int b = SWFBitsNeeded( _x, true );
+	if( b > bits ) bits = b;
+	x = _x;
+}
+
+void LineTo::sety( int _y ) {
+	int b = SWFBitsNeeded( _y, true );
+	if( b > bits ) bits = b;
+	y = _y;
+}
+
+}