From 7ddcc6604ef3a6004c8fefb59d2ecdedc440b2bc Mon Sep 17 00:00:00 2001
From: kramm <kramm>
Date: Mon, 7 Jan 2002 14:44:13 +0000
Subject: [PATCH] * some endianess fixes * bitwise reader functions are now
 object oriented style

---
 src/bitio.c      |  102 +++++++++++------------
 src/bitio.h      |   44 +++++-----
 src/combine.c    |   33 +++++---
 src/flash.c      |  191 ++++++++++++++++++++++---------------------
 src/flash.h      |   22 ++---
 src/reloc.c      |  240 ++++++++++++++++++++++++++++--------------------------
 src/swfcombine.c |   46 ++++++-----
 7 files changed, 349 insertions(+), 329 deletions(-)

diff --git a/src/bitio.c b/src/bitio.c
index 417e7b5..8a494b2 100644
--- a/src/bitio.c
+++ b/src/bitio.c
@@ -9,82 +9,74 @@
 
 #include "bitio.h"
 
-static uchar*data;
-static int datalength;
-static int datapos;
 
-void resetbits();
-
-void reader_init(uchar*newdata, int newlength)
+void reader_init(struct reader_t*r, uchar*newdata, int newlength)
 {
-    data = newdata;
-    datalength = newlength;
-    datapos = 0;
-    resetbits();
+    r->data = newdata;
+    r->datalength = newlength;
+    r->datapos = 0;
+    reader_resetbits(r);
 }
-void skip(int length)
+void reader_skip(struct reader_t*r, int length)
 {
-    datapos += length;
+    r->datapos += length;
 }
-static u8 bitpos=8,mybyte;
-static u8 bitmem=0;
-void resetbits()
+void reader_resetbits(struct reader_t*r)
 {
-    bitpos=8;
+    r->bitpos = 8;
 }
 
-void input1(void*target)
+void reader_input1(struct reader_t*r, void*target)
 {
-    *(uchar*)target = *(uchar*)&data[datapos];
-    datapos ++;
+    *(uchar*)target = *(uchar*)&r->data[r->datapos];
+    r->datapos ++;
 }
-void input2(void*target)
+void reader_input2(struct reader_t*r, void*target)
 {
-    *(unsigned short int*)target = *(unsigned short int*)&data[datapos];
-    datapos += 2;
+    *(unsigned short int*)target = *(unsigned short int*)&r->data[r->datapos];
+    r->datapos += 2;
 }
-void input4(void*target)
+void reader_input4(struct reader_t*r, void*target)
 {
-    *(unsigned int*)target = *(unsigned int*)&data[datapos];
-    datapos += 4;
+    *(unsigned int*)target = *(unsigned int*)&r->data[r->datapos];
+    r->datapos += 4;
 }
-uchar*getinputpos()
+uchar*reader_getinputpos(struct reader_t*r)
 {
-    return &data[datapos];
+    return &r->data[r->datapos];
 }
-int getinputlength()
+int reader_getinputlength(struct reader_t*r)
 {
-    return datalength;
+    return r->datalength;
 }
-void setinputpos(uchar*pos)
+void reader_setinputpos(struct reader_t*r, uchar*pos)
 {
-    datapos = pos-data;
+    r->datapos = pos-r->data;
 }
-
-u32 readbit()
+u32 reader_readbit(struct reader_t*r)
 {
-    if(bitpos==8) 
+    if(r->bitpos==8) 
     {
-	bitpos=0;
-        input1(&mybyte);
+	r->bitpos=0;
+        reader_input1(r, &r->mybyte);
     }
-    return (mybyte>>(7-bitpos++))&1;
+    return (r->mybyte>>(7-r->bitpos++))&1;
 }
-void readbits(u32*val,int num)
+void reader_readbits(struct reader_t*r, u32*val,int num)
 {
     int t;
     *val=0;
     for(t=0;t<num;t++)
     {
 	*val<<=1;
-	*val|=readbit();
+	*val|=reader_readbit(r);
     }
 }
 
-void readsbits(s32*val,int num)
+void reader_readsbits(struct reader_t*r, s32*val,int num)
 {
     u32 x;
-    readbits(&x, num);
+    reader_readbits(r, &x, num);
     if((x>>(num-1))&1)
     {
 	x|=(0xffffffff<<num);
@@ -92,42 +84,42 @@ void readsbits(s32*val,int num)
     *(s32*)val=x;
 }
 
-u32 getbits(int num)
+u32 reader_getbits(struct reader_t*r, int num)
 {
     u32 x;
-    readbits(&x,num);
+    reader_readbits(r,&x,num);
     return x;
 }
 
-s32 getsbits(int num)
+s32 reader_getsbits(struct reader_t*r, int num)
 {
     s32 x;
-    readsbits(&x,num);
+    reader_readsbits(r, &x,num);
     return x;
 }
 
-u8 readu8()
+u8 reader_readu8(struct reader_t*r)
 {
     u8 a;
-    input1(&a);
+    reader_input1(r, &a);
     return a;
 }
 
-u16 readu16()
+u16 reader_readu16(struct reader_t*r)
 {
     u8 a,b;
-    input1(&a);
-    input1(&b);
+    reader_input1(r, &a);
+    reader_input1(r, &b);
     return ((u16)b)*256+a;
 }
 
-u32 readu32()
+u32 reader_readu32(struct reader_t*r)
 {
     u8 a,b,c,d;
-    input1(&a);
-    input1(&b);
-    input1(&c);
-    input1(&d);
+    reader_input1(r, &a);
+    reader_input1(r, &b);
+    reader_input1(r, &c);
+    reader_input1(r, &d);
     return (((((u32)d)*256+(u32)c)*256+(u32)b)*256+(u32)a);
 }
 
diff --git a/src/bitio.h b/src/bitio.h
index dbcd82a..ac5f7d4 100644
--- a/src/bitio.h
+++ b/src/bitio.h
@@ -12,25 +12,13 @@
 
 #include "types.h"
 
-void resetbits();
-void reader_init(uchar*newdata, int newlength);
-void skip(int length);
-void input1(void*target);
-void input2(void*target);
-void input4(void*target);
-
-uchar*getinputpos();
-int getinputlength();
-void setinputpos(uchar*pos);
-
-u32 readbit();
-void readbits(u32*val,int num);
-void readsbits(s32*val,int num);
-u32 getbits(int num);
-s32 getsbits(int num);
-u8 readu8();
-u16 readu16();
-u32 readu32();
+struct reader_t {
+    u8* data;
+    int datalength;
+    int datapos;
+    u8 bitpos,mybyte;
+    u8 bitmem;
+};
 
 struct writer_t {
     u8* data;
@@ -40,6 +28,24 @@ struct writer_t {
     u8 mybyte;
 };
 
+void reader_resetbits(struct reader_t*);
+void reader_init(struct reader_t*,uchar*newdata, int newlength);
+void reader_skip(struct reader_t*,int length);
+void reader_input1(struct reader_t*, void*target);
+void reader_input2(struct reader_t*, void*target);
+void reader_input4(struct reader_t*, void*target);
+uchar*reader_getinputpos(struct reader_t*);
+int reader_getinputlength(struct reader_t*);
+void reader_setinputpos(struct reader_t*,uchar*pos);
+u32 reader_readbit(struct reader_t*);
+void reader_readbits(struct reader_t*,u32*val,int num);
+void reader_readsbits(struct reader_t*,s32*val,int num);
+u32 reader_getbits(struct reader_t*,int num);
+s32 reader_getsbits(struct reader_t*,int num);
+u8 reader_readu8(struct reader_t*);
+u16 reader_readu16(struct reader_t*);
+u32 reader_readu32(struct reader_t*);
+
 void writer_init(struct writer_t*w, u8*data, int maxlength);
 void writer_write(struct writer_t*w, void*data, int length);
 void* writer_getpos(struct writer_t*w);
diff --git a/src/combine.c b/src/combine.c
index bcc511b..4908912 100644
--- a/src/combine.c
+++ b/src/combine.c
@@ -402,8 +402,9 @@ void writeheader(struct writer_t*w, u8*data, int length)
     if(config.hassizex || config.hassizey || config.framerate)
     {
 	struct flash_header head;
-	swf_init(data-3, length+3);
-	head = swf_read_header();
+	struct reader_t reader;
+	swf_init(&reader, data-3, length+3);
+	head = swf_read_header(&reader);
 	if(config.hassizex)
 	{
 	    head.boundingBox.x2 = head.boundingBox.x1 + config.sizex;
@@ -474,21 +475,27 @@ uchar * catcombine(uchar*masterdata, int masterlength, char*_slavename, uchar*sl
 	    switch(master.tags[pos].id) {
 		case TAGID_PLACEOBJECT2:
 		    num++;
-		case TAGID_PLACEOBJECT:
-		   reader_init (master.tags[pos].data, master.tags[pos].length);
+		case TAGID_PLACEOBJECT: {
+		   struct reader_t r;
+		   reader_init (&r, master.tags[pos].data, master.tags[pos].length);
 		   if(num>=2)
-			readu8();
-		   depth = readu16();
+			reader_readu8(&r);
+		   depth = reader_readu16(&r);
 		   depths[depth] = 1;
+		}
 	        break;
-		case TAGID_REMOVEOBJECT:
-		   reader_init (master.tags[pos].data, master.tags[pos].length);
-		   readu16();
-		   depths[readu16()] = 0;
+		case TAGID_REMOVEOBJECT: {
+		   struct reader_t r;
+		   reader_init (&r, master.tags[pos].data, master.tags[pos].length);
+		   reader_readu16(&r);
+		   depths[reader_readu16(&r)] = 0;
+		}
 		break;
-		case TAGID_REMOVEOBJECT2:
-		   reader_init (master.tags[pos].data, master.tags[pos].length);
-		   depths[readu16()] = 0;
+		case TAGID_REMOVEOBJECT2: {
+		   struct reader_t r;
+		   reader_init (&r, master.tags[pos].data, master.tags[pos].length);
+		   depths[reader_readu16(&r)] = 0;
+		}
 		break;
 	    }
 	    if(master.tags[pos].id != 0)
diff --git a/src/flash.c b/src/flash.c
index 289dcbb..2607f21 100644
--- a/src/flash.c
+++ b/src/flash.c
@@ -10,33 +10,33 @@
 #include "flash.h"
 #include "bitio.h"
 
-void swf_init(uchar*newdata, int newlength)
+void swf_init(struct reader_t*r, uchar*newdata, int newlength)
 {
-    reader_init (&newdata[3], newlength - 3);
+    reader_init (r, &newdata[3], newlength - 3);
 }
 
-struct flash_header swf_read_header()
+struct flash_header swf_read_header(struct reader_t*r)
 {
     struct flash_header head;
     u16 rate;
     u16 count;
     char version;
     int length;
-    u8* oldpos = getinputpos();
+    u8* oldpos = reader_getinputpos(r);
 
-    input1(&version);
+    reader_input1(r,&version);
     head.version = version;
-    input4(&length);
+    reader_input4(r,&length);
     head.length = length;
     
-    resetbits();
-    head.boundingBox = readRECT();
-    input2(&rate);
+    reader_resetbits(r);
+    head.boundingBox = readRECT(r);
+    reader_input2(r,&rate);
     head.rate = rate;
-    input2(&count);
+    reader_input2(r,&count);
     head.count = count;
 
-    head.headerlength = getinputpos() - oldpos;
+    head.headerlength = reader_getinputpos(r) - oldpos;
     head.headerdata = oldpos;
 
     return head;
@@ -57,53 +57,53 @@ void swf_write_header(struct writer_t*w, struct flash_header*head)
     writer_writeu16(w, head->count);
 }
 
-struct RGB readRGB()
+struct RGB readRGB(struct reader_t*r)
 {
     struct RGB rgb;
-    input1(&rgb.r);
-    input1(&rgb.g);
-    input1(&rgb.b);
+    reader_input1(r,&rgb.r);
+    reader_input1(r,&rgb.g);
+    reader_input1(r,&rgb.b);
     return rgb;
 }
 
-struct RGBA readRGBA()
+struct RGBA readRGBA(struct reader_t*r)
 {
     struct RGBA rgba;
-    input1(&rgba.r);
-    input1(&rgba.g);
-    input1(&rgba.b);
-    input1(&rgba.a);
+    reader_input1(r,&rgba.r);
+    reader_input1(r,&rgba.g);
+    reader_input1(r,&rgba.b);
+    reader_input1(r,&rgba.a);
     return rgba;
 }
 
-struct GRADIENT readGRADIENT(int shape)
+struct GRADIENT readGRADIENT(struct reader_t*r, int shape)
 {
     struct GRADIENT gradient;
     int t;
-    gradient.num = readu8();
+    gradient.num = reader_readu8(r);
     for(t=0;t<gradient.num;t++)
     {
-	gradient.ratios[t] = readu8();
+	gradient.ratios[t] = reader_readu8(r);
 	if(shape<3)
-	    gradient.rgb[t] = readRGB();
+	    gradient.rgb[t] = readRGB(r);
 	else
-	    gradient.rgba[t] = readRGBA();
+	    gradient.rgba[t] = readRGBA(r);
     }
 }
 
-struct RECT readRECT()
+struct RECT readRECT(struct reader_t*reader)
 {
     u32 a;
     struct RECT r;
     s32 b;
-    readbits(&a,5);
-    readsbits(&b,a);
+    reader_readbits(reader,&a,5);
+    reader_readsbits(reader,&b,a);
     r.x1=b;
-    readsbits(&b,a);
+    reader_readsbits(reader,&b,a);
     r.x2=b;
-    readsbits(&b,a);
+    reader_readsbits(reader,&b,a);
     r.y1=b;
-    readsbits(&b,a);
+    reader_readsbits(reader,&b,a);
     r.y2=b;
     return r;
 }
@@ -123,30 +123,30 @@ void writeRECT(u8**pos, struct RECT*r)
     *pos = writer_getpos(&w);
 }
 
-struct CXFORM readCXFORM(char alpha)
+struct CXFORM readCXFORM(struct reader_t*r, char alpha)
 {
     struct CXFORM c;
     int bits;
-    c.hasadd=readbit();
-    c.hasmult=readbit();
-    bits=getbits(4);
+    c.hasadd=reader_readbit(r);
+    c.hasmult=reader_readbit(r);
+    bits=reader_getbits(r,4);
     c.alpha = alpha;
 
     if (c.hasmult)
     {
-	c.rmult=getsbits(bits)/65536.0;
-	c.gmult=getsbits(bits)/65536.0;
-	c.bmult=getsbits(bits)/65536.0;
+	c.rmult=reader_getsbits(r,bits)/65536.0;
+	c.gmult=reader_getsbits(r,bits)/65536.0;
+	c.bmult=reader_getsbits(r,bits)/65536.0;
 	if(c.alpha)
-	    c.amult=getsbits(bits)/65536.0;
+	    c.amult=reader_getsbits(r,bits)/65536.0;
     }
     if (c.hasadd)
     {
-	c.radd=getsbits(bits)/65536.0;
-	c.gadd=getsbits(bits)/65536.0;
-	c.badd=getsbits(bits)/65536.0;
+	c.radd=reader_getsbits(r,bits)/65536.0;
+	c.gadd=reader_getsbits(r,bits)/65536.0;
+	c.badd=reader_getsbits(r,bits)/65536.0;
 	if(c.alpha)
-	    c.aadd=getsbits(bits)/65536.0;
+	    c.aadd=reader_getsbits(r,bits)/65536.0;
     }
     return c;
 }
@@ -175,13 +175,13 @@ void CXFORM_write(struct CXFORM *obj, struct writer_t*w)
     }
 }
 
-unsigned char* readSTRING()
+unsigned char* readSTRING(struct reader_t*r)
 {
-    unsigned char*now = getinputpos();
+    unsigned char*now = reader_getinputpos(r);
     char a;
     do
     {
-	input1(&a);
+	reader_input1(r,&a);
     }
     while(a);
     return now;
@@ -197,7 +197,7 @@ void MATRIX_init(struct MATRIX*m)
     m->a[1][0] = 0;
     m->a[0][1] = 0;
 }
-struct MATRIX readMATRIX()
+struct MATRIX readMATRIX(struct reader_t*r)
 {
     struct MATRIX m;
     u8 hasrotate;
@@ -207,28 +207,28 @@ struct MATRIX readMATRIX()
 
     m.a[0][0] = m.a[1][1] = 1;
     m.a[0][1] = m.a[1][0] = 0;
-    m.hasscale=readbit();
+    m.hasscale=reader_readbit(r);
     if(m.hasscale)
     {
-	u8 scalebits=getbits(5);
-	s32 scalex=getsbits(scalebits);
-	s32 scaley=getsbits(scalebits);
+	u8 scalebits=reader_getbits(r,5);
+	s32 scalex=reader_getsbits(r,scalebits);
+	s32 scaley=reader_getsbits(r,scalebits);
 	m.a[0][0]=scalex/65536.0;
 	m.a[1][1]=scaley/65536.0;
     }
-    m.hasrotate=readbit();
+    m.hasrotate=reader_readbit(r);
     if(m.hasrotate)
     {
-	u8 rotbits=getbits(5);
-	s32 rotateskew0=getsbits(rotbits);
-	s32 rotateskew1=getsbits(rotbits);
+	u8 rotbits=reader_getbits(r,5);
+	s32 rotateskew0=reader_getsbits(r,rotbits);
+	s32 rotateskew1=reader_getsbits(r,rotbits);
 	m.a[0][1]=rotateskew0/65536.0;
 	m.a[1][0]=rotateskew1/65536.0;
     }
 
-    translatebits=getbits(5);
-    translatex=getsbits(translatebits);
-    translatey=getsbits(translatebits);
+    translatebits=reader_getbits(r,5);
+    translatex=reader_getsbits(r,translatebits);
+    translatey=reader_getsbits(r,translatebits);
     m.b[0]=translatex;
     m.b[1]=translatey;
 
@@ -264,59 +264,60 @@ void MATRIX_write(struct MATRIX * m , struct writer_t*w)
 }
 
 
-int swf_read_tag(struct swf_tag* swftag)
+int swf_read_tag(struct reader_t*r, struct swf_tag* swftag)
 {
-    u8*pos2,*pos = getinputpos();
+    u8*pos2,*pos = reader_getinputpos(r);
     u16 tag;
     u32 taglength;
     u32 tagid;
     int t;
 
-    input2(&tag);
+    reader_input2(r, &tag);
 
     taglength = tag & 0x3f;
     if (taglength == 0x3f)
     {
-	input4(&taglength);
+	reader_input4(r, &taglength);
     }
 
     swftag->id=tag>>6;
     swftag->length = taglength;
-    swftag->data = getinputpos();
-    skip(taglength);
-    pos2 = getinputpos();
+    swftag->data = reader_getinputpos(r);
+    reader_skip(r,taglength);
+    pos2 = reader_getinputpos(r);
     swftag->fulllength = pos2 - pos;
     swftag->fulldata = pos;
     return 1;
 }
 
-int swf_count_tags()
+int swf_count_tags(struct reader_t*r)
 {
-    u8*pos = getinputpos();
+    u8*pos = reader_getinputpos(r);
     int t=0;
     struct swf_tag tag;
 
     while(1)
     {
-	swf_read_tag(&tag);
+	swf_read_tag(r,&tag);
 	t++;
 	if (tag.id == 0)
 	    break;
     }
     
-    setinputpos(pos);
+    reader_setinputpos(r,pos);
     return t;
 }
 
 void placeobject_init (struct PlaceObject*obj, struct swf_tag*tag)
 {
-    reader_init (tag->data, tag->length);
-    obj -> id = readu16();
-    obj -> depth = readu16();
-    obj -> matrix = readMATRIX();
-    obj -> hascxform = (getinputpos() < &tag->data[tag->length]);
+    struct reader_t r;
+    reader_init (&r, tag->data, tag->length);
+    obj -> id = reader_readu16(&r);
+    obj -> depth = reader_readu16(&r);
+    obj -> matrix = readMATRIX(&r);
+    obj -> hascxform = (reader_getinputpos(&r) < &tag->data[tag->length]);
     if(obj -> hascxform)
-	obj -> cxform = readCXFORM(0);
+	obj -> cxform = readCXFORM(&r, 0);
 }
 
 void placeobject_write (struct PlaceObject*obj, struct writer_t*w)
@@ -348,9 +349,10 @@ void placeobject_write (struct PlaceObject*obj, struct writer_t*w)
 
 void placeobject2_init (struct PlaceObject2*obj,struct swf_tag*tag)
 {    
+    struct reader_t r;
     u8 b;
-    reader_init (tag->data, tag->length);
-    b=readu8();
+    reader_init (&r, tag->data, tag->length);
+    b=reader_readu8(&r);
     obj->reserved=         (b>>7)&1;
     obj->hasclipactions=   (b>>6)&1;
     obj->hasname=          (b>>5)&1;
@@ -360,26 +362,26 @@ void placeobject2_init (struct PlaceObject2*obj,struct swf_tag*tag)
     obj->hascharacter=     (b>>1)&1;
     obj->hasmove=          (b>>0)&1;
 
-    obj->depth = readu16();
+    obj->depth = reader_readu16(&r);
     obj->id = -1;
     if(obj->hascharacter) {
-	obj->id = readu16();
+	obj->id = reader_readu16(&r);
     }
     if(obj->hasmatrix) { 
-	obj->matrix = readMATRIX();
+	obj->matrix = readMATRIX(&r);
     } 
     if(obj->hascolortransform) {
-	obj->cxform = readCXFORM(0);
+	obj->cxform = readCXFORM(&r,0);
     }
     if(obj->hasratio) {
-	obj->ratio=readu16();
+	obj->ratio=reader_readu16(&r);
     }
     obj->name = 0;
     if(obj->hasname) {
-	obj->name=readSTRING();
+	obj->name=readSTRING(&r);
     }
     if(obj->hasclipactions) {
-	obj->clipactions=readu16();
+	obj->clipactions=reader_readu16(&r);
     }
 }
 
@@ -422,8 +424,9 @@ void read_swf(struct swffile*swf, uchar*data, int length)
     int pos;
     struct flash_header head;
     int tagnum;
-    swf_init(data, length);
-    head = swf_read_header(data);
+    struct reader_t r;
+    swf_init(&r, data, length);
+    head = swf_read_header(&r);
     logf("<debug> [HEADER] the version is %d", head.version);
     logf("<debug> [HEADER] the length is %d", head.length);
     logf("<debug> [HEADER] the boundingBox is %d:%d:%d:%d", 
@@ -432,7 +435,7 @@ void read_swf(struct swffile*swf, uchar*data, int length)
     logf("<debug> [HEADER] the rate (frames/second) is %d", head.rate);
     logf("<debug> [HEADER] the count (frame number) is %d", head.count);
 
-    tagnum = swf_count_tags();
+    tagnum = swf_count_tags(&r);
     swf->tags = (struct swf_tag*)malloc(sizeof(struct swf_tag)*tagnum);
     
     logf("<debug> [HEADER] the file consists of %d tags", tagnum);
@@ -441,7 +444,7 @@ void read_swf(struct swffile*swf, uchar*data, int length)
     while(1)
     {
 	struct swf_tag tag;
-	swf_read_tag(&tag);
+	swf_read_tag(&r, &tag);
 	logf("<debug> read tag %02x (%d bytes)", tag.id, tag.length);
 	swf->tags[pos] = tag;
 	pos++;
@@ -498,15 +501,17 @@ int getidfromtag(struct swf_tag* tag)
     switch(tag->id) {
 	case TAGID_PLACEOBJECT2:
 	    num++;
-	case TAGID_PLACEOBJECT:
-	   reader_init (tag->data, tag->length);
+	case TAGID_PLACEOBJECT: {
+	   struct reader_t r;
+	   reader_init (&r, tag->data, tag->length);
 	   if(num>=2) {
-		char b = readu8();
+		char b = reader_readu8(&r);
 		if(!(b&2))
 		    return -1;
 	   }
-	   readu16();
-	   return readu16();
+	   reader_readu16(&r);
+	   return reader_readu16(&r);
+	}
 	break;
 	case TAGID_REMOVEOBJECT:
 	   return *(u16*)tag->data;
diff --git a/src/flash.h b/src/flash.h
index f93d78b..1a185c5 100644
--- a/src/flash.h
+++ b/src/flash.h
@@ -119,7 +119,7 @@ struct CLIPACTIONS readCLIPACTIONS();
 
 void writeRECT(u8**pos, struct RECT*r);
 
-void swf_init(uchar*newdata, int newlength);
+void swf_init(struct reader_t*,uchar*newdata, int newlength);
 struct flash_header
 {
     int version;
@@ -139,16 +139,16 @@ struct swffile
     struct swf_tag* tags;
 };
 
-struct flash_header swf_read_header();
-struct RGB readRGB();
-struct RGBA readRGBA();
-struct GRADIENT readGRADIENT(int shape);
-struct RECT readRECT();
-struct CXFORM readCXFORM(char alpha);
-struct MATRIX readMATRIX();
-unsigned char* readSTRING();
-int swf_read_tag(struct swf_tag* swftag);
-int swf_count_tags();
+struct flash_header swf_read_header(struct reader_t*);
+struct RGB readRGB(struct reader_t*);
+struct RGBA readRGBA(struct reader_t*);
+struct GRADIENT readGRADIENT(struct reader_t*,int shape);
+struct RECT readRECT(struct reader_t*);
+struct CXFORM readCXFORM(struct reader_t*,char alpha);
+struct MATRIX readMATRIX(struct reader_t*);
+unsigned char* readSTRING(struct reader_t*);
+int swf_read_tag(struct reader_t*,struct swf_tag* swftag);
+int swf_count_tags(struct reader_t*);
 
 
 struct PlaceObject
diff --git a/src/reloc.c b/src/reloc.c
index 4b951e6..6217d34 100644
--- a/src/reloc.c
+++ b/src/reloc.c
@@ -26,69 +26,69 @@ void maponeid(void*idpos)
 }
 
 
-void mapstyles(int num, void(*callback)(void*))
+void mapstyles(struct reader_t*reader, int num, void(*callback)(void*))
 {
     u16 count;
     int t;
-    resetbits();
-    count = readu8();
+    reader_resetbits(reader);
+    count = reader_readu8(reader);
     if(count == 0xff && num>1) // defineshape2,3 only
-	count = readu16();
+	count = reader_readu16(reader);
 
 //	    printf("%d fillstyles\n", count);
     for(t=0;t<count;t++)
     {
 	int type;
 	u8*pos;
-	pos=getinputpos();
+	pos=reader_getinputpos(reader);
 //		printf("%02x %02x %02x %02x %02x %02x %02x %02x\n", 
 //			pos[0],pos[1],pos[2],pos[3],pos[4],pos[5],pos[6],pos[7]);
-	resetbits();
-	type = readu8(); //type
+	reader_resetbits(reader);
+	type = reader_readu8(reader); //type
 //		printf("fillstyle %d is type 0x%02x\n", t, type);
 	if(type == 0) {
 //	    printf("solid fill\n");
 	    if(num == 3)
-		readRGBA();
+		readRGBA(reader);
 	    else 
-		readRGB();
+		readRGB(reader);
 	}
 	else if(type == 0x10 || type == 0x12)
 	{
 //	    printf("gradient fill\n");
-	    resetbits();
-	    readMATRIX();
-	    resetbits();
-	    readGRADIENT(num);
+	    reader_resetbits(reader);
+	    readMATRIX(reader);
+	    reader_resetbits(reader);
+	    readGRADIENT(reader, num);
 	}
 	else if(type == 0x40 || type == 0x41)
 	{
-	    resetbits();
+	    reader_resetbits(reader);
 	    // we made it.
 //	    printf("bitmap fill:%04x\n", *(u16*)getinputpos());
-	    if(*(u16*)getinputpos() != 65535)
-		(callback)(getinputpos());
+	    if(*(u16*)reader_getinputpos(reader) != 65535)
+		(callback)(reader_getinputpos(reader));
 
-	    readu16();
-	    resetbits();
-	    readMATRIX();
+	    reader_readu16(reader);
+	    reader_resetbits(reader);
+	    readMATRIX(reader);
 	}
 	else {
 	    logf("<error> Unknown fillstyle:0x%02x\n",type);
 	}
     }
-    resetbits();
-    count = readu8(); // line style array
+    reader_resetbits(reader);
+    count = reader_readu8(reader); // line style array
 //	    printf("%d linestyles\n", count);
     if(count == 0xff)
-	count = readu16();
+	count = reader_readu16(reader);
     for(t=0;t<count;t++) 
     {
-	readu16();
+	reader_readu16(reader);
 	if(num == 3)
-	    readRGBA();
+	    readRGBA(reader);
 	else
-	    readRGB();
+	    readRGB(reader);
     }
 }
 
@@ -99,35 +99,37 @@ void map_ids_mem(u8*mem, int length, void(*callback)(void*))
     int num=1;
     struct swf_tag newtag_instance;
     struct swf_tag*newtag = &newtag_instance;
-    reader_init (mem, length);
-    swf_read_tag(newtag);
+    struct reader_t reader;
+    reader_init (&reader, mem, length);
+    swf_read_tag(&reader, newtag);
 
     switch(newtag->id)
     {
 	case TAGID_DEFINEBUTTONCXFORM: {
 	    int t;
+	    struct reader_t reader;
 	    callback(&newtag->data[0]); //button id
-	    reader_init (newtag->data, newtag->length);
+	    reader_init (&reader, newtag->data, newtag->length);
 	    for(t=0;t<4;t++) {
 		int flags;
 		callback(&newtag->data[0]);
-		readu16(); //sound id
-		flags = readu8();
+		reader_readu16(&reader); //sound id
+		flags = reader_readu8(&reader);
 		if(flags&1)
-		    readu32(); // in point
+		    reader_readu32(&reader); // in point
 		if(flags&2)
-		    readu32(); // out points
+		    reader_readu32(&reader); // out points
 		if(flags&4)
-		    readu16(); // loop count
+		    reader_readu16(&reader); // loop count
 		if(flags&8)
 		{
-		    int npoints = readu8();
+		    int npoints = reader_readu8(&reader);
 		    int s;
 		    for(s=0;s<npoints;s++)
 		    {
-			readu32();
-			readu16();
-			readu16();
+			reader_readu32(&reader);
+			reader_readu16(&reader);
+			reader_readu16(&reader);
 		    }
 		}
 	    }
@@ -158,12 +160,13 @@ void map_ids_mem(u8*mem, int length, void(*callback)(void*))
 		u8*fmem = mem;
 		int flen = len;
 		struct swf_tag sprtag;
+		struct reader_t reader;
 
-		reader_init (mem, len);
-		swf_read_tag (&sprtag);
+		reader_init (&reader, mem, len);
+		swf_read_tag (&reader, &sprtag);
 
-		mem = getinputpos();
-		len = getinputlength();
+		mem = reader_getinputpos(&reader);
+		len = reader_getinputlength(&reader);
 
 		if(sprtag.id == TAGID_END)
 		    break;
@@ -175,43 +178,46 @@ void map_ids_mem(u8*mem, int length, void(*callback)(void*))
 	case TAGID_DEFINEBUTTON2: // has some font ids in the button records
 	    num++; 
 	//fallthrough
-	case TAGID_DEFINEBUTTON:
-	    reader_init (newtag->data, newtag->length);
-	    readu16(); //button id
+	case TAGID_DEFINEBUTTON: {
+	    struct reader_t reader;
+	    reader_init (&reader, newtag->data, newtag->length);
+	    reader_readu16(&reader); //button id
 	    if(num>1)
 	    { 
 		int offset;
-		readu8(); //flag
-		offset = readu16(); //offset
+		reader_readu8(&reader); //flag
+		offset = reader_readu16(&reader); //offset
 	    }
 	    while(1)
 	    {
 		u16 charid;
-		if(!readu8()) //flags
+		if(!reader_readu8(&reader)) //flags
 		    break; 
-		charid = *(u16*)getinputpos();
-		callback(getinputpos());
-		readu16(); //char
-		readu16(); //layer
-		resetbits();
-		readMATRIX();
+		charid = *(u16*)reader_getinputpos(&reader);
+		callback(reader_getinputpos(&reader));
+		reader_readu16(&reader); //char
+		reader_readu16(&reader); //layer
+		reader_resetbits(&reader);
+		readMATRIX(&reader);
 		if(num>1) {
-		  resetbits();
-		  readCXFORM(1);
+		  reader_resetbits(&reader);
+		  readCXFORM(&reader, 1);
 		}
 	    }
 	    // ...
+	}
 	break;
 	case TAGID_DEFINEEDITTEXT:  {
 	    u8 flags1,flags2;
-	    reader_init (newtag->data, newtag->length);
-	    readu16(); //id
-	    readRECT(); //bounding box
-	    resetbits();
-	    flags1 = readu8();
-	    flags2 = readu8();
+	    struct reader_t reader;
+	    reader_init (&reader, newtag->data, newtag->length);
+	    reader_readu16(&reader); //id
+	    readRECT(&reader); //bounding box
+	    reader_resetbits(&reader);
+	    flags1 = reader_readu8(&reader);
+	    flags2 = reader_readu8(&reader);
 	    if(flags1 & 128)
-		callback(getinputpos());
+		callback(reader_getinputpos(&reader));
 	}
 	break;
 	case TAGID_DEFINETEXT2:
@@ -219,48 +225,49 @@ void map_ids_mem(u8*mem, int length, void(*callback)(void*))
 	case TAGID_DEFINETEXT: { 
 	    int glyphbits, advancebits;
 	    int id;
-	    reader_init (newtag->data, newtag->length);
-	    id = readu16(); //id
-	    readRECT(); //bounding box
-	    resetbits();
-	    readMATRIX(); //matrix
-	    resetbits();
-	    glyphbits = readu8(); //glyphbits
-	    advancebits = readu8(); //advancebits
+	    struct reader_t reader;
+	    reader_init (&reader, newtag->data, newtag->length);
+	    id = reader_readu16(&reader); //id
+	    readRECT(&reader); //bounding box
+	    reader_resetbits(&reader);
+	    readMATRIX(&reader); //matrix
+	    reader_resetbits(&reader);
+	    glyphbits = reader_readu8(&reader); //glyphbits
+	    advancebits = reader_readu8(&reader); //advancebits
 	    while(1) {
 		u16 flags;
-		resetbits();
-		flags = getbits(8);
+		reader_resetbits(&reader);
+		flags = reader_getbits(&reader, 8);
 		if(!flags) break;
 		if(flags & 128) // text style record
 		{
-		    resetbits();
+		    reader_resetbits(&reader);
 		    if(flags & 8) { // hasfont
-			callback(getinputpos());
-			id = readu16();
+			callback(reader_getinputpos(&reader));
+			id = reader_readu16(&reader);
 		    }
 		    if(flags & 4) { // hascolor
-			if(num==1) readRGB();
-			else       readRGBA();
+			if(num==1) readRGB(&reader);
+			else       readRGBA(&reader);
 		    }
 		    if(flags & 2) { //has x offset
-			resetbits();
-			readu16();
+			reader_resetbits(&reader);
+			reader_readu16(&reader);
 		    }
 		    if(flags & 1) { //has y offset
-			resetbits();
-			readu16();
+			reader_resetbits(&reader);
+			reader_readu16(&reader);
 		    }
 		    if(flags & 8) { //has height
-			resetbits();
-			readu16();
+			reader_resetbits(&reader);
+			reader_readu16(&reader);
 		    }
 		} else { // glyph record
 		    int t;
-		    resetbits();
+		    reader_resetbits(&reader);
 		    for(t=0;t<flags;t++) {
-			getbits(glyphbits);
-			getbits(advancebits);
+			reader_getbits(&reader, glyphbits);
+			reader_getbits(&reader, advancebits);
 		    }
 		}
 	    }
@@ -278,16 +285,17 @@ void map_ids_mem(u8*mem, int length, void(*callback)(void*))
 	    int fillbits;
 	    int linebits;
 	    struct RECT r;
+	    struct reader_t reader;
 	    //printf("defineshape%d\n", num);
-	    reader_init (newtag->data, newtag->length);
-	    readu16(); // id;
-	    r = readRECT(); // bounds
+	    reader_init (&reader, newtag->data, newtag->length);
+	    reader_readu16(&reader); // id;
+	    r = readRECT(&reader); // bounds
 //	    printf("%d shape bounds: %d %d %d %d\n",newtag->id,r.x1,r.y1,r.x2,r.y2);
 
-	    mapstyles(num, callback);
-	    fillbits = getbits(4);
-	    linebits = getbits(4);
-	    resetbits();
+	    mapstyles(&reader, num, callback);
+	    fillbits = reader_getbits(&reader, 4);
+	    linebits = reader_getbits(&reader, 4);
+	    reader_resetbits(&reader);
 	    //printf("%d %d\n", fillbits, linebits);
 	    while(1) {
 		int flags;
@@ -297,50 +305,50 @@ void map_ids_mem(u8*mem, int length, void(*callback)(void*))
 		    ((u8*)getinputpos())[0],
 		    ((u8*)getinputpos())[1],
 		    ((u8*)getinputpos())[2]);*/
-		flags = getbits(1);
+		flags = reader_getbits(&reader, 1);
 		if(!flags) { //style change
-		    flags = getbits(5);
+		    flags = reader_getbits(&reader, 5);
 		    //printf("style flags:%02x\n",flags);
 		    if(!flags)
 			break;
 		    if(flags&1) { //move
-			int n = getbits(5); 
+			int n = reader_getbits(&reader, 5); 
 			//printf("n:%d\n",n);
-			getbits(n); //x
-			getbits(n); //y
+			reader_getbits(&reader, n); //x
+			reader_getbits(&reader, n); //y
 		    }
 		    if(flags&2) { //fill0
-			getbits(fillbits); 
+			reader_getbits(&reader, fillbits); 
 		    }
 		    if(flags&4) { //fill1
-			getbits(fillbits); 
+			reader_getbits(&reader, fillbits); 
 		    }
 		    if(flags&8) { //linestyle
-			getbits(linebits); 
+			reader_getbits(&reader, linebits); 
 		    }
 		    if(flags&16) {
-			mapstyles(num, callback);
-			fillbits = getbits(4);
-			linebits = getbits(4);
+			mapstyles(&reader, num, callback);
+			fillbits = reader_getbits(&reader, 4);
+			linebits = reader_getbits(&reader, 4);
 		    }
 		} else {
-		    flags = getbits(1);
+		    flags = reader_getbits(&reader, 1);
 		    //printf("edge:%d\n", flags);
 		    if(flags) { //straight edge
-			int n = getbits(4) + 2;
-			if(getbits(1)) { //line flag
-			    getbits(n); //delta x
-			    getbits(n); //delta y
+			int n = reader_getbits(&reader, 4) + 2;
+			if(reader_getbits(&reader, 1)) { //line flag
+			    reader_getbits(&reader, n); //delta x
+			    reader_getbits(&reader, n); //delta y
 			} else {
-			    int v=getbits(1);
-			    getbits(n); //vert/horz
+			    int v=reader_getbits(&reader, 1);
+			    reader_getbits(&reader, n); //vert/horz
 			}
 		    } else { //curved edge
-			int n = getbits(4) + 2;
-			getbits(n);
-			getbits(n);
-			getbits(n);
-			getbits(n);
+			int n = reader_getbits(&reader, 4) + 2;
+			reader_getbits(&reader, n);
+			reader_getbits(&reader, n);
+			reader_getbits(&reader, n);
+			reader_getbits(&reader, n);
 		    }
 		}
 	    }
diff --git a/src/swfcombine.c b/src/swfcombine.c
index f190e9a..2b189b9 100644
--- a/src/swfcombine.c
+++ b/src/swfcombine.c
@@ -1,5 +1,5 @@
 /* swfcombine.c
-   main routine for swfcombine(1), which is a tool for merging .swf-files.
+   main routine for swfcombine(1), a tool for merging .swf-files.
 
    Part of the swftools package.
    
@@ -10,6 +10,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include "../lib/rfxswf.h"
 #include "../lib/args.h"
 #include "combine.h"
 #include "settings.h"
@@ -257,6 +258,7 @@ void fi_dump(FILE*fi, void*_mem, int length)
     }
 }
 
+/* todo: use rfxswf */
 void makestackmaster(u8**masterdata, int*masterlength)
 {
     u8 head[] = {'F','W','S'};
@@ -274,6 +276,7 @@ void makestackmaster(u8**masterdata, int*masterlength)
 	u8 data[256];
 	int ret;
 	struct flash_header head;
+	struct reader_t r;
 	strlength += strlen(slave_name[t]) + 9;
 	if(!fi) {
 	    logf("<fatal> Couldn't open %s.", slave_filename[t]);
@@ -284,8 +287,8 @@ void makestackmaster(u8**masterdata, int*masterlength)
 	    logf("<fatal> File %s is to small (%d bytes)", slave_filename[t], ret);
 	    exit(1);
 	}
-	swf_init(data,256);
-	head = swf_read_header();
+	swf_init(&r, data,256);
+	head = swf_read_header(&r);
 	logf("<verbose> File %s has bounding box %d:%d:%d:%d\n",
 		slave_filename[t], 
 		head.boundingBox.x1, head.boundingBox.y1,
@@ -311,7 +314,6 @@ void makestackmaster(u8**masterdata, int*masterlength)
     }
 
     /* we don't have a master, so we create one ourselves. */
-    /* (please notice the philosophical content) */
     *masterlength = (numslaves + 1) * 32 + strlength;
     *masterdata = (u8*)malloc(*masterlength);
     pos = *masterdata;
@@ -319,12 +321,12 @@ void makestackmaster(u8**masterdata, int*masterlength)
     pos += sizeof(head);
     *pos++ = fileversion;
     fixpos = (u32*)pos;
-    *(u32*)pos = 0x12345678; // to be overwritten
+    *(u32*)pos = SWAP32(0x12345678); // to be overwritten
     pos += 4;
     writeRECT(&pos, &box);
-    *(u16*)pos = 0x2000; // framerate
+    *(u16*)pos = SWAP16(0x2000); // framerate
     pos += 2;
-    *(u16*)pos = numslaves;
+    *(u16*)pos = SWAP16(numslaves);
     pos += 2;
     for(t=0;t<numslaves;t++)
     {
@@ -337,31 +339,31 @@ void makestackmaster(u8**masterdata, int*masterlength)
 	} 
 	namelen = strlen(slave_name[t]);
 
-	*(u16*)&pos[0] = (u16)(TAGID_DEFINESPRITE<<6) + 6;
-	*(u16*)&pos[2] = t+1; //ID
+	*(u16*)&pos[0] = SWAP16((u16)(TAGID_DEFINESPRITE<<6) + 6);
+	*(u16*)&pos[2] = SWAP16(t+1); //ID
 	*(u16*)&pos[4] = 0; // Frames
 	*(u16*)&pos[6] = 0; // TAG1
-	*(u16*)&pos[8] = (u16)(TAGID_PLACEOBJECT2<<6) + 6 + namelen;
-	*(u16*)&pos[10]= 34; //flags: id+name
-	*(u16*)&pos[11]= 1+t; // depth
-	*(u16*)&pos[13]= t+1; // id
+	*(u16*)&pos[8] = SWAP16((u16)(TAGID_PLACEOBJECT2<<6) + 6 + namelen);
+	*(u16*)&pos[10]= SWAP16(34); //flags: id+name
+	*(u16*)&pos[11]= SWAP16(1+t); // depth
+	*(u16*)&pos[13]= SWAP16(t+1); // id
 	sprintf(&pos[15],slave_name[t]);
 	pos += 15 + namelen + 1;
 	if(!config.stack1 || t == numslaves-1) {
-	    *(u16*)&pos[0]= (u16)(TAGID_SHOWFRAME<<6) + 0;
+	    *(u16*)&pos[0]= SWAP16((u16)(TAGID_SHOWFRAME<<6) + 0);
 	    pos += 2;
 	}
 	if(!config.stack)
 	if(t!=numslaves-1)
 	{
-	    *(u16*)&pos[0]= (u16)(TAGID_REMOVEOBJECT2<<6) + 2;
-	    *(u16*)&pos[2]= 1+t; // depth;
+	    *(u16*)&pos[0]= SWAP16((u16)(TAGID_REMOVEOBJECT2<<6) + 2);
+	    *(u16*)&pos[2]= SWAP16(1+t); // depth;
 	    pos += 4;
 	}
     }
-    *(u16*)pos = TAGID_END<<6 + 0;
+    *(u16*)pos = SWAP16(TAGID_END<<6 + 0);
     *masterlength = pos - *masterdata;
-    *fixpos = *masterlength;
+    *fixpos = SWAP32(*masterlength);
 }
 
 struct config_t config;
@@ -503,11 +505,11 @@ int main(int argn, char *argv[])
 		slavedata[1] = 'W';
 		slavedata[2] = 'S';
 		slavedata[3] = 4; //version
-		*(u32*)&slavedata[4] = 14; // length
+		*(u32*)&slavedata[4] = SWAP32(14); // length
 		slavedata[8] = 0; // boundingbox
-		*(u16*)&slavedata[9] = 0; // rate
-		*(u16*)&slavedata[11] = 0; // count
-		*(u16*)&slavedata[13] = 0; // end tag
+		*(u16*)&slavedata[9] = SWAP16(0); // rate
+		*(u16*)&slavedata[11] = SWAP16(0); // count
+		*(u16*)&slavedata[13] = SWAP16(0); // end tag
 		slavelength = 17;
 	    }
 
-- 
1.7.10.4