#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);
*(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);
}
#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;
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);
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;
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)
#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;
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;
}
*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;
}
}
}
-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;
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;
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;
}
-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)
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;
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);
}
}
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",
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);
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++;
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;
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;
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
}
-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);
}
}
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);
}
}
}
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;
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:
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);
}
}
}
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;
((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);
}
}
}
/* 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.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
+#include "../lib/rfxswf.h"
#include "../lib/args.h"
#include "combine.h"
#include "settings.h"
}
}
+/* todo: use rfxswf */
void makestackmaster(u8**masterdata, int*masterlength)
{
u8 head[] = {'F','W','S'};
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]);
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,
}
/* 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;
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++)
{
}
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;
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;
}
git.asbjorn.biz / swftools.git / commitdiff