swfmill 0.0.1

data/ext/swfmill/src/SWFTag.cpp

@@ -0,0 +1,49 @@
+#include <SWFTag.h>
+#include "SWF.h"
+#include <cstring>
+
+namespace SWF {
+
+Tag *Tag::get( Reader *r, int end, Context *ctx ) {
+	uint16_t h = r->getWord();
+	int type = h>>6;
+	int len = h&0x3F;
+	if( len == 0x3F ) { // long size
+		len = r->getInt();
+	}
+	
+	// sanity check
+	if( len > 100000000 ) {
+		fprintf(stderr,"ridiculous tag size: %i, ignoring.\n", len );
+//		r->setEOF();
+		return NULL;
+	}
+
+	Tag *ret = getByType( type );
+	
+	if( !ret ) {
+		ret = new UnknownTag;
+	}
+	
+	ret->setType( type );
+	ret->setLength( len );
+	ret->parse( r, r->getPosition()+len, ctx );
+
+	return ret;
+}
+
+void Tag::writeHeader( Writer *w, Context *ctx, size_t len ) {
+//	printf("write tag %02X, len %i, recorded %i(+header, 2 or 6), position %i\n", type, len, this->len, w->getPosition() );
+	// shouldnt this be 0x3f - macromedia flash seems to use long length for > 1F...
+	len -= (len >= SWF_LONG_TAG + 6) ? 6 : 2;
+	uint16_t h = type<<6;
+	if( len >= SWF_LONG_TAG ) {
+		h |= 0x3F;
+		w->putWord(h);
+		w->putInt(len);
+	} else {
+		h |= len;
+		w->putWord(h);
+	}
+}
+}

data/ext/swfmill/src/SWFTag.h

@@ -0,0 +1,20 @@
+#ifndef SWF_TAG_H
+#define SWF_TAG_H
+
+#include <SWFIdItem.h>
+
+namespace SWF {
+	
+#define SWF_LONG_TAG 8
+class Tag : public IdItem<Tag> {
+	protected:
+		int getHeaderSize( int size ) { return (size/8)>=SWF_LONG_TAG ? (6*8) : (2*8); }
+		void writeHeader( Writer *w, Context *ctx, size_t len );
+	
+	// static stuff
+	public:
+		static Tag* get( Reader *r, int end, Context *ctx );
+};
+	
+}
+#endif

data/ext/swfmill/src/SWFTrait.cpp

@@ -0,0 +1,35 @@
+#include <SWFAction.h>
+#include "SWF.h"
+#include <cstring>
+
+namespace SWF {
+
+Trait *Trait::get( Reader *r, int end, Context *ctx ) {
+	int type = r->getNBitInt( 4 );
+	int len = end - r->getPosition();
+	
+	Trait* ret = getByType( type );
+
+	if( !ret ) {
+		ret = handleError( type );
+	}
+
+	if( ret ) {
+		ret->setType( type );
+		ret->setLength( len );
+		ret->parse( r, end, ctx );
+	} 
+
+	return ret;
+}	
+
+void Trait::writeHeader( Writer *w, Context *ctx, size_t len ) {
+	w->putNBitInt( type, 4 );
+}
+
+Trait* Trait::handleError( int type ) {
+	fprintf(stderr,"WARNING: unknown trait type 0x%02X\n", type );
+	return NULL;
+}
+
+}

data/ext/swfmill/src/SWFTrait.h

@@ -0,0 +1,22 @@
+#ifndef SWF_TRAIT_H
+#define SWF_TRAIT_H
+
+#include <SWFIdItem.h>
+
+namespace SWF {
+	
+class Trait : public IdItem<Trait> {
+	protected:
+		int getHeaderSize( int size ) { return 4; }
+		void writeHeader( Writer *w, Context *ctx, size_t len );
+	
+	// static stuff
+	public:
+		static Trait* get( Reader *r, int end, Context *ctx );
+
+	protected:
+		static Trait* handleError( int type );
+};
+
+}
+#endif

data/ext/swfmill/src/SWFWriter.cpp

@@ -0,0 +1,312 @@
+#include "SWFWriter.h"
+#include <cstring>
+#include <cstdlib>
+
+namespace SWF {
+
+Writer::Writer( unsigned char *d, size_t l ) {
+	data = d;
+	length = l;
+	pos = 0;
+	buf = bits = 0;
+	err = 0;
+}
+
+Writer::Writer( size_t l ) {
+	data = new unsigned char[l];
+	length = l;
+	pos = 0;
+	buf = bits = 0;
+	err = 0;
+}
+
+void Writer::putData( void *src, size_t len ) {
+	byteAlign();
+	if( !assure( len ) ) return;
+	memcpy( &data[pos], src, len );
+	pos += len;
+}
+
+void Writer::putByte( uint8_t value ) {
+	byteAlign();
+	writeByte(value);
+}
+
+void Writer::putWord( uint16_t value ) {
+	byteAlign();
+	if( !assure( 2 ) ) return;
+	// FIXME x86-centric?
+	data[pos++] = value&0xFF;
+	data[pos++] = value>>8;
+}
+
+void Writer::putInt( uint32_t value ) {
+	byteAlign();
+	if( !assure( 4 ) ) return;
+	// FIXME x86-centric?
+	data[pos++] = value&0xFF;
+	data[pos++] = (value>>8)&0xFF;
+	data[pos++] = (value>>16)&0xFF;
+	data[pos++] = (value>>24)&0xFF;
+}
+
+void Writer::putInt64( uint64_t value ) {
+	byteAlign();
+	if( !assure( 8 ) ) return;
+
+	putInt( value >> 32 );
+	putInt( value & 0xffffffff );
+}
+
+void Writer::putU30( uint32_t value ) {
+	byteAlign();
+		
+	int bytes = 1;
+	uint32_t limit = 0x80;
+	for(; value > limit - 1; limit *= 0x80) {
+		bytes++;
+	}
+
+	if( !assure( bytes ) ) return;
+	// FIXME x86-centric?
+	
+	for(; bytes > 0; bytes--) {
+		data[pos] = value & 0x7F;
+		
+		if(bytes > 1) {
+			value = value >> 7;
+			data[pos] |= 0x80;
+		}
+		pos++;
+	}
+}
+
+void Writer::putS24( int value ) {
+	byteAlign();
+	if( !assure( 3 ) ) return;
+	// FIXME x86-centric?
+	value = (unsigned int)value;
+	data[pos++] = value&0xFF;
+	data[pos++] = (value>>8)&0xFF;
+	data[pos++] = (value>>16)&0xFF;
+}
+
+void Writer::putEncodedU32(unsigned int value) {
+	for (size_t i = 0; i < 5; ++i) {
+		if (value < 0x80) {
+			data[pos++] = value;
+			return;
+		}
+		data[pos++] = (value & 0x7f) | 0x80;
+		value >>= 7;
+	}
+}
+
+void Writer::putFloat( float v ) {
+    /*
+	byteAlign();
+	if( !assure( 4 ) ) return;
+
+	// FIXME x86-centric?
+	int value = *((int*)&v);
+	data[pos++] = value&0xFF;
+	data[pos++] = (value>>8)&0xFF;
+	data[pos++] = (value>>16)&0xFF;
+	data[pos++] = (value>>24)&0xFF;
+    */
+	union {
+		float f;
+		uint32_t ul;
+	} u;
+	u.f = v;
+	putInt(u.ul);
+}
+
+void Writer::putDouble( double v ) {
+	union {
+		double d;
+		uint64_t ull;
+	} u;
+	u.d = v;
+	putInt64(u.ull);
+}
+
+void Writer::putDouble2( double v ) {
+	union {
+		double d;
+		char c[8];
+	} u;
+	u.d = v;
+	for( int i=0; i < 8; i++ ) {
+		data[pos++] = u.c[i];
+	}
+}
+
+void Writer::putHalf( float v ) {
+	union {
+		float f;
+		uint32_t ul;
+	} u;
+	u.f = v;
+
+	int sign = u.ul >> 31;
+	int exp = (u.ul >> 23) & 0xFF;
+	int man = (u.ul & 0x007FFFFF);
+
+	if( exp == 0 ) {
+		man = 0;
+	} else if( exp == 0xFF ) {
+		exp = 0x1F;
+		if( man != 0 ) {
+			man = 1;
+		}
+	} else {
+		exp -= 127;
+		if( exp < -14 ) {
+			if( exp >= -24 ) {
+				man = (man | 0x800000) >> (-exp - 14 + 13);
+			} else {
+				man = 0;
+			}
+			exp = 0;
+		} else if( exp > 15 ) {
+			exp = 0x1F;
+			man = 0;
+		} else {
+			exp += 15;
+			man >>= 13;
+		}
+	}
+
+	putWord((sign << 15) | (exp << 10) | man);
+}
+
+void Writer::putFixed( double value, int bytesize, int exp ) {
+	/* putFixed/getFixed are deprecated: they implicitly to byteAlign */
+	
+	if( !assure( bytesize ) ) return;
+
+	value *= ((double)(1<<exp));
+	uint64_t v = (uint64_t)value;
+	for( int i=0; i<bytesize; i++ ) {
+		data[pos++] = v>>(8*i);
+	}
+}
+
+void Writer::putString( const char *value ) {
+	byteAlign();
+	int len = strlen(value);
+	if( !assure( len+1 ) ) return;
+	memcpy( &data[pos], value, len+1 );
+	pos += len+1;
+}
+
+void Writer::putPString( const char *value ) {
+	byteAlign();
+	int len = strlen(value);
+	if( !assure( len+1 ) ) return;
+	putByte(len);
+	memcpy( &data[pos], value, len );
+	pos += len;
+}
+
+void Writer::putPStringU30( const char *value ) {
+	byteAlign();
+	int len = strlen(value);
+	if( !assure( len+1 ) ) return;
+	putU30(len);
+	memcpy( &data[pos], value, len );
+	pos += len;
+}
+
+void Writer::putNBitInt( int64_t value, int n, bool is_signed ) {
+	// FIXME: unefficient, maybe incorrect!
+	if( !assure( ((n+bits)/8)+1 ) ) return;
+		
+	if( is_signed ) {
+		uint64_t *v = (uint64_t*)&value;
+		uint64_t sign = (1<<(n-1));
+		if( *v & sign ) {
+			value = (*v&(sign-1)) | (1<<(n-1));
+		}
+	}
+
+	// sanity check
+	if( !is_signed || value >= 0 ) {
+		if( value >= (uint64_t)1<<(n+(is_signed?2:1) ) ) {
+			fprintf(stderr,"WARNING: (%ssigned) value %i is too big to be represented in %i bits (max %i)\n", is_signed?"":"un", value, n, 1<<(n+(is_signed?1:0) ) );
+		}
+	} else {
+		if( value < ((uint64_t)-1)<<(n+(is_signed?2:1) ) ) {
+			fprintf(stderr,"WARNING: (%ssigned) value %i is too small to be represented in %i bits (max %i)\n", is_signed?"":"un", value, n, 1<<(n+(is_signed?1:0) ) );
+		}
+	}
+	
+	if( n==(8-bits) ) {
+		writeByte( buf | value );
+		buf = bits = 0;
+		return;
+	}
+	
+	if( n > (8-bits) ) {
+		int bs = n-(8-bits);
+		writeByte( buf | value>>bs );
+		n-=(8-bits);
+		
+		while( n>=8 ) {
+			bs-=8;
+			writeByte( value >> bs );
+			n-=8;
+		}
+		
+		if( n>0 ) {
+			bits = n;
+			buf = value << (8-bits);
+		} else {
+			bits = buf = 0;
+		}
+		return;
+	}
+	
+	// n < (8-bits)
+	bits += n;
+	buf |= value << (8-bits);
+	return;
+}
+
+void Writer::putNBitFixed( double v, int n, int m, bool is_signed ) {
+	v *= ((double)(1<<m)); 
+	putNBitInt( (int64_t)v, n, is_signed ); 
+}
+
+void Writer::putNBitFixed2( double v, int n, int m, bool is_signed ) {
+	if( n%8 != 0 ) {
+		fprintf(stderr,"WARNING: fixedpoint2 needs a size that is divisible by 8");
+		return;
+	}
+	putFixed( v, n / 8, m ); 
+}
+
+void Writer::writeByte( uint8_t value ) {
+	data[pos++] = value;
+}
+
+void Writer::dump( int len, int ofs ) {
+	const unsigned char *d = &data[pos+ofs];
+	
+	int i=0;
+	printf("DumpingWriter %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/SWFWriter.h

@@ -0,0 +1,84 @@
+#ifndef SWF_Writer_H
+#define SWF_Writer_H
+
+#include <cstdio>
+#include <stdint.h>
+#include "SWFBasic.h"
+
+namespace SWF {
+	
+#define SWFW_OK		0	
+#define SWFW_ERROR	1
+#define SWFW_FULL	2
+	
+class Writer {
+	public:
+		Writer( unsigned char *data, size_t length );
+		Writer( size_t length );
+	
+		// these implicitly do byteAlign()
+		void putData( void *src, size_t length );
+		void putByte(uint8_t);
+		void putWord(uint16_t);
+		void putInt(uint32_t);
+		void putInt64(uint64_t);
+		void putU30(uint32_t);
+		void putS24(int);
+		void putFloat(float);
+		void putDouble(double);
+		void putDouble2(double);
+		void putHalf(float);
+		void putFixed( double v, int bytesize, int decimals );
+		void putString( const char * );
+		void putPString( const char * );
+		void putPStringU30( const char * );
+		void putEncodedU32(unsigned int);
+	
+		// this one cares about the current bit position
+		void putNBitInt( int64_t v, int n, bool is_signed = false );
+		void putNBitFixed( double v, int n, int m, bool is_signed = false );
+		void putNBitFixed2( double v, int n, int m, bool is_signed = false );
+	
+		// set bit position to next byte.
+		void byteAlign() {
+			if( bits ) writeByte( buf );
+			buf = 0; bits=0;
+		}
+				
+		int getError() { return err; }
+			
+		void dump( int n, int ofs ); // dumps n bytes from current position to stdout
+		bool assure( int l, int before=-1 ) { 
+			int b = (before==-1?length:before);
+			if( pos+l > b ) {
+				fprintf(stderr,"Write buffer full (%i+%i >= %i)\n", pos, l, b );
+				err = SWFW_FULL;
+				return false;
+			}
+			return true;
+		}
+		
+		size_t getLength() { return length; }
+		unsigned char *getData() { return data; }
+		int getPosition() { return pos; }
+		int getBits() { return bits; }
+		int getBitPosition() { return (pos*8)+( bits ); }
+		
+	protected:
+		void writeByte( uint8_t value );
+	
+		// the uncompressed swf data and our position within
+		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 write( void *dst, size_t n );
+};
+
+}
+#endif