-/* rfxswf.c
+/* vi: set sts=2 sw=2 :*/
+
+/* rfxswf.c
Library for creating and reading SWF files or parts of it.
There's a module directory which provides some extended functionality.
#include "rfxswf.h"
-#ifdef HAVE_LIBJPEG
-#ifdef HAVE_JPEGLIB_H
+#ifdef HAVE_JPEGLIB
#define HAVE_BOOLEAN
#include <jpeglib.h>
-#define _JPEGLIB_INCLUDED_
-#endif // HAVE_JPEGLIB_H
-#endif // HAVE_LIBJPEG
+#endif // HAVE_JPEGLIB
-#ifdef HAVE_LIBZ
-#ifdef HAVE_ZLIB_H
+#ifdef HAVE_ZLIB
#include <zlib.h>
-#define _ZLIB_INCLUDED_
-#endif // HAVE_ZLIB_H
-#endif // HAVE_LIBZ
-
-// Win32 support may be broken since it was only tested in an older version for Watcom C
-#ifdef __NT__
-# include <io.h>
-# include <malloc.h>
-# include <string.h>
-# ifdef DEBUG_RFXSWF
-# include <stdio.h>
-# endif
-#else
-#endif
+#endif // HAVE_ZLIB
+
+#define LAME
+#include "lame/lame.h"
+
+#include "./bitio.h"
// internal constants
#define MEMSIZE(l) (((l/MALLOC_SIZE)+1)*MALLOC_SIZE)
+
// inline wrapper functions
TAG * swf_NextTag(TAG * t) { return t->next; }
#endif
}
+char* swf_GetString(TAG*t)
+{
+ char* str = ((char*)(&(t)->data[(t)->pos]));
+ while(swf_GetU8(t));
+ return str;
+}
+
U8 swf_GetU8(TAG * t)
{ swf_ResetReadBits(t);
#ifdef DEBUG_RFXSWF
if (!newdata)
{
#ifdef DEBUG_RFXSWF
- fprintf(stderr,"Fatal Error: malloc()/realloc() failed.\n");
+ fprintf(stderr,"Fatal Error: malloc()/realloc() failed (1). (%d bytes)\n", newmem);
+ *(int*)0=0;
#endif
return 0;
}
return (S32)res;
}
+U32 reader_GetBits(struct reader_t*reader, int nbits)
+{ return reader_readbits(reader, nbits);
+}
+S32 reader_GetSBits(struct reader_t*reader, int nbits)
+{ U32 res = reader_readbits(reader, nbits);
+ if (res&(1<<(nbits-1))) res|=(0xffffffff<<nbits);
+ return (S32)res;
+}
+
int swf_SetBits(TAG * t,U32 v,int nbits)
{ U32 bm = 1<<(nbits-1);
} else swf_SetBlock(t,NULL,3);
return 0;
}
+void swf_GetRGB(TAG * t, RGBA * col)
+{
+ RGBA dummy;
+ if(!col);
+ col = &dummy;
+ col->r = swf_GetU8(t);
+ col->g = swf_GetU8(t);
+ col->b = swf_GetU8(t);
+ col->a = 255;
+}
int swf_SetRGBA(TAG * t,RGBA * col)
{ if (!t) return -1;
} else swf_SetBlock(t,NULL,4);
return 0;
}
+void swf_GetRGBA(TAG * t, RGBA * col)
+{
+ RGBA dummy;
+ if(!col);
+ col = &dummy;
+ col->r = swf_GetU8(t);
+ col->g = swf_GetU8(t);
+ col->b = swf_GetU8(t);
+ col->a = swf_GetU8(t);
+}
+
+void swf_GetGradient(TAG * tag, GRADIENT * gradient, char alpha)
+{
+ GRADIENT dummy;
+ int t;
+ if(!gradient)
+ gradient = &dummy;
+ gradient->num = swf_GetU8(tag);
+ for(t=0;t<gradient->num;t++)
+ {
+ int s=t;
+ if(s>=8) //FIXME
+ s=7;
+ gradient->ratios[t] = swf_GetU8(tag);
+ if(!alpha)
+ swf_GetRGB(tag, &gradient->rgba[t]);
+ else
+ swf_GetRGBA(tag, &gradient->rgba[t]);
+ }
+}
int swf_CountBits(U32 v,int nbits)
{ int n = 33;
int swf_GetRect(TAG * t,SRECT * r)
{ int nbits;
SRECT dummy;
+ if(!t) {r->xmin=r->xmax=r->ymin=r->ymax=0;return 0;}
if (!r) r = &dummy;
nbits = (int) swf_GetBits(t,5);
r->xmin = swf_GetSBits(t,nbits);
return 0;
}
+int reader_GetRect(struct reader_t*reader,SRECT * r)
+{ int nbits;
+ SRECT dummy;
+ if (!r) r = &dummy;
+ nbits = (int) reader_GetBits(reader,5);
+ r->xmin = reader_GetSBits(reader,nbits);
+ r->xmax = reader_GetSBits(reader,nbits);
+ r->ymin = reader_GetSBits(reader,nbits);
+ r->ymax = reader_GetSBits(reader,nbits);
+ return 0;
+}
+
int swf_SetRect(TAG * t,SRECT * r)
{ int nbits;
nbits = swf_CountBits(r->xmax,nbits);
nbits = swf_CountBits(r->ymin,nbits);
nbits = swf_CountBits(r->ymax,nbits);
+ if(nbits>=32) {
+ fprintf(stderr, "rfxswf: Warning: num_bits overflow in swf_SetRect\n");
+ nbits=31;
+ }
swf_SetBits(t,nbits,5);
swf_SetBits(t,r->xmin,nbits);
return 0;
}
+void swf_ExpandRect(SRECT*src, SPOINT add)
+{
+ if(add.x < src->xmin)
+ src->xmin = add.x;
+ if(add.x > src->xmax)
+ src->xmax = add.x;
+ if(add.y < src->ymin)
+ src->ymin = add.y;
+ if(add.y > src->ymax)
+ src->ymax = add.y;
+}
+void swf_ExpandRect2(SRECT*src, SRECT*add)
+{
+ if((add->xmin | add->ymin | add->xmax | add->ymax)==0)
+ return;
+ if(add->xmin < src->xmin)
+ src->xmin = add->xmin;
+ if(add->ymin < src->ymin)
+ src->ymin = add->ymin;
+ if(add->xmax > src->xmax)
+ src->xmax = add->xmax;
+ if(add->ymax > src->ymax)
+ src->ymax = add->ymax;
+}
+SPOINT swf_TurnPoint(SPOINT p, MATRIX* m)
+{
+ SPOINT r;
+ r.x = (int)(m->sx*(1/65536.0)*p.x + m->r1*(1/65536.0)*p.y + 0.5) + m->tx;
+ r.y = (int)(m->r0*(1/65536.0)*p.x + m->sy*(1/65536.0)*p.y + 0.5) + m->ty;
+ return r;
+}
+SRECT swf_TurnRect(SRECT r, MATRIX* m)
+{
+ SRECT g;
+ SPOINT p1,p2,p3,p4,pp1,pp2,pp3,pp4;
+ p1.x = r.xmin;p1.y = r.ymin;
+ p2.x = r.xmax;p2.y = r.ymin;
+ p3.x = r.xmin;p3.y = r.ymax;
+ p4.x = r.xmax;p4.y = r.ymax;
+ pp1 = swf_TurnPoint(p1, m);
+ pp2 = swf_TurnPoint(p2, m);
+ pp3 = swf_TurnPoint(p3, m);
+ pp4 = swf_TurnPoint(p4, m);
+ g.xmin = g.xmax = pp1.x;
+ g.ymin = g.ymax = pp1.y;
+ swf_ExpandRect(&g, pp2);
+ swf_ExpandRect(&g, pp3);
+ swf_ExpandRect(&g, pp4);
+ return g;
+}
+
+
int swf_GetMatrix(TAG * t,MATRIX * m)
{ MATRIX dummy;
int nbits;
// Tag List Manipulating Functions
-int RFXSWF_UpdateFrame(TAG * t,S8 delta)
+int swf_UpdateFrame(TAG * t,S8 delta)
// returns number of frames
{ int res = -1;
while (t)
return res;
}
-#define swf_UpdateFrame(a,b) RFXSWF_UpdateFrame(a,b)
-
TAG * swf_InsertTag(TAG * after,U16 id) // updates frames, if nescessary
{ TAG * t;
return t;
}
+TAG * swf_InsertTagBefore(SWF* swf, TAG * before,U16 id) // updates frames, if nescessary
+{ TAG * t;
+
+ t = (TAG *)malloc(sizeof(TAG));
+ if (t)
+ { memset(t,0x00,sizeof(TAG));
+ t->id = id;
+
+ if (before)
+ { t->frame = before->frame;
+ t->next = before;
+ t->prev = before->prev;
+ before->prev = t;
+ if (t->prev) t->prev->next = t;
+
+ if (id==ST_SHOWFRAME) swf_UpdateFrame(t->next,+1);
+ }
+ }
+ if(swf && swf->firstTag == before) {
+ swf->firstTag = t;
+ }
+ return t;
+}
+
+void swf_ClearTag(TAG * t)
+{
+ if (t->data) free(t->data);
+ t->data = 0;
+ t->pos = 0;
+ t->len = 0;
+ t->readBit = 0;
+ t->writeBit = 0;
+ t->memsize = 0;
+}
+
+void swf_ResetTag(TAG*tag, U16 id)
+{
+ tag->len = tag->pos = tag->readBit = tag->writeBit = 0;
+ tag->id = id;
+}
+
int swf_DeleteTag(TAG * t)
{ if (!t) return -1;
return 0;
}
-TAG * RFXSWF_ReadTag(int handle,TAG * prev)
+TAG * swf_ReadTag(struct reader_t*reader, TAG * prev)
{ TAG * t;
U16 raw;
U32 len;
int id;
- if (read(handle,&raw,2)!=2) return NULL;
+ if (reader->read(reader, &raw, 2) !=2 ) return NULL;
+ raw = SWAP16(raw);
len = raw&0x3f;
id = raw>>6;
if (len==0x3f)
- { if (read(handle,&len,4)!=4) return NULL;
+ {
+ if (reader->read(reader, &len, 4) != 4) return NULL;
+ len = SWAP32(len);
}
if (id==ST_DEFINESPRITE) len = 2*sizeof(U16);
if (!t)
{
#ifdef DEBUG_RFXSWF
- fprintf(stderr,"Fatal Error: malloc()/realloc() failed.\n");
+ fprintf(stderr,"Fatal Error: malloc()/realloc() failed (2). (%d bytes)\n", sizeof(TAG));
#endif
return NULL;
}
if (!t->data)
{
#ifdef DEBUG_RFXSWF
- fprintf(stderr,"Fatal Error: malloc()/realloc() failed.\n");
+ fprintf(stderr,"Fatal Error: malloc()/realloc() failed (3). (%d bytes)\n", t->len);
#endif
return NULL;
}
t->memsize = t->len;
- if (read(handle,t->data,t->len)!=t->len) return NULL;
+ if (reader->read(reader, t->data, t->len) != t->len) return NULL;
}
if (prev)
return t;
}
-int RFXSWF_DefineSprite_GetRealSize(TAG * t);
+int swf_DefineSprite_GetRealSize(TAG * t);
-int RFXSWF_WriteTag(int handle,TAG * t)
+int swf_WriteTag2(struct writer_t*writer, TAG * t)
// returns tag length in bytes (incl. Header), -1 = Error
-// handle = -1 -> no output
+// writer = 0 -> no output
{ U16 raw[3];
U32 len;
int short_tag;
if (!t) return -1;
- len = (t->id==ST_DEFINESPRITE)?RFXSWF_DefineSprite_GetRealSize(t):t->len;
+ len = (t->id==ST_DEFINESPRITE)?swf_DefineSprite_GetRealSize(t):t->len;
short_tag = len<0x3f;
- if (handle>=0)
+ if (writer)
{ if (short_tag)
- { raw[0] = len|((t->id&0x3ff)<<6);
- if (write(handle,raw,2)!=2)
+ { raw[0] = SWAP16(len|((t->id&0x3ff)<<6));
+ if (writer->write(writer,raw,2)!=2)
{
#ifdef DEBUG_RFXSWF
fprintf(stderr,"WriteTag() failed: Short Header.\n");
}
}
else
- { raw[0] = (t->id<<6)|0x3f;
- raw[1] = (U16)(len&0xffff);
- raw[2] = (U16)(len>>16);
- if (write(handle,raw,6)!=6)
+ {
+ raw[0] = SWAP16((t->id<<6)|0x3f);
+ if (writer->write(writer,raw,2)!=2)
+ {
+#ifdef DEBUG_RFXSWF
+ fprintf(stderr,"WriteTag() failed: Long Header (1).\n");
+#endif
+ return -1;
+ }
+
+ len = SWAP32(len);
+ if (writer->write(writer,&len,4)!=4)
{
#ifdef DEBUG_RFXSWF
- fprintf(stderr,"WriteTag() failed: Long Header.\n");
+ fprintf(stderr,"WriteTag() failed: Long Header (2).\n");
#endif
return -1;
}
}
if (t->data)
- { if (write(handle,t->data,t->len)!=t->len)
+ { if (writer->write(writer,t->data,t->len)!=t->len)
{
#ifdef DEBUG_RFXSWF
fprintf(stderr,"WriteTag() failed: Data.\n");
return t->len+(short_tag?2:6);
}
-int RFXSWF_DefineSprite_GetRealSize(TAG * t)
+int swf_WriteTag(int handle, TAG * t)
+{
+ struct writer_t writer;
+ if(handle<0)
+ return swf_WriteTag2(0, t);
+ writer_init_filewriter(&writer, handle);
+ return swf_WriteTag2(&writer, t);
+}
+
+int swf_DefineSprite_GetRealSize(TAG * t)
// Sprite Handling: Helper function to pack DefineSprite-Tag
{ U32 len = t->len;
+ if(len>4) { // folded sprite
+ return t->len;
+ }
do
{ t = swf_NextTag(t);
- if (t->id!=ST_DEFINESPRITE) len += RFXSWF_WriteTag(-1,t);
+ if (t && t->id!=ST_DEFINESPRITE) len += swf_WriteTag(-1, t);
else t = NULL;
} while (t&&(t->id!=ST_END));
return len;
}
-#define swf_ReadTag(a,b) RFXSWF_ReadTag(a,b)
-#define swf_WriteTag(a,b) RFXSWF_WriteTag(a,b)
+void swf_UnFoldSprite(TAG * t)
+{
+ U16 id,tmp;
+ U32 len;
+ TAG*next = t;
+ U16 spriteid,spriteframes;
+ int level;
+ if(t->id!=ST_DEFINESPRITE)
+ return;
+ if(t->len<=4) // not folded
+ return;
+
+ swf_SetTagPos(t,0);
+
+ spriteid = swf_GetU16(t); //id
+ spriteframes = swf_GetU16(t); //frames
+
+ level = 1;
+
+ while(1)
+ {
+ TAG*it = 0;
+ tmp = swf_GetU16(t);
+ len = tmp&0x3f;
+ id = tmp>>6;
+ if(id == ST_END)
+ level--;
+ if(id == ST_DEFINESPRITE && len<=4)
+ level++;
+
+ if (len==0x3f)
+ len = swf_GetU32(t);
+ it = swf_InsertTag(next, id);
+ next = it;
+ it->len = len;
+ it->id = id;
+ if (it->len)
+ { it->data = (U8*)malloc(it->len);
+ it->memsize = it->len;
+ swf_GetBlock(t, it->data, it->len);
+ }
+
+ if(!level)
+ break;
+ }
+
+ free(t->data); t->data = 0;
+ t->memsize = t->len = t->pos = 0;
+
+ swf_SetU16(t, spriteid);
+ swf_SetU16(t, spriteframes);
+}
+
+void swf_FoldSprite(TAG * t)
+{
+ TAG*sprtag=t,*tmp;
+ U16 id,frames,tmpid;
+ int level;
+ if(t->id!=ST_DEFINESPRITE)
+ return;
+ if(!t->len) {
+ fprintf(stderr, "Error: Sprite has no ID!");
+ return;
+ }
+ if(t->len>4) {
+ /* sprite is already folded */
+ return;
+ }
+
+ t->pos = 0;
+ id = swf_GetU16(t);
+ free(t->data);
+ t->len = t->pos = t->memsize = 0;
+ t->data = 0;
+
+ frames = 0;
+
+ t = swf_NextTag(sprtag);
+ level = 1;
+
+ do
+ {
+ if(t->id==ST_SHOWFRAME) frames++;
+ if(t->id == ST_DEFINESPRITE && t->len<=4)
+ level++;
+ if(t->id == ST_END)
+ level--;
+ t = swf_NextTag(t);
+ } while(t && level);
+ if(level)
+ fprintf(stderr, "rfxswf error: sprite doesn't end(1)\n");
+
+ swf_SetU16(sprtag, id);
+ swf_SetU16(sprtag, frames);
+
+ t = swf_NextTag(sprtag);
+ level = 1;
+
+ do
+ {
+ if(t->len<0x3f) {
+ swf_SetU16(sprtag,t->len|(t->id<<6));
+ } else {
+ swf_SetU16(sprtag,0x3f|(t->id<<6));
+ swf_SetU32(sprtag,t->len);
+ }
+ if(t->len)
+ swf_SetBlock(sprtag,t->data, t->len);
+ tmp = t;
+ if(t->id == ST_DEFINESPRITE && t->len<=4)
+ level++;
+ if(t->id == ST_END)
+ level--;
+ t = swf_NextTag(t);
+ swf_DeleteTag(tmp);
+ }
+ while (t && level);
+ if(level)
+ fprintf(stderr, "rfxswf error: sprite doesn't end(2)\n");
+
+// sprtag->next = t;
+// t->prev = sprtag;
+}
+
+int swf_IsFolded(TAG * t)
+{
+ return (t->id == ST_DEFINESPRITE && t->len>4);
+}
+
+void swf_FoldAll(SWF*swf)
+{
+ TAG*tag = swf->firstTag;
+ while(tag) {
+ if(tag->id == ST_DEFINESPRITE)
+ swf_FoldSprite(tag);
+ tag = swf_NextTag(tag);
+ }
+}
+
+void swf_UnFoldAll(SWF*swf)
+{
+ TAG*tag = swf->firstTag;
+ while(tag) {
+ if(tag->id == ST_DEFINESPRITE)
+ swf_UnFoldSprite(tag);
+ tag = tag->next;
+ }
+}
+
+void swf_OptimizeTagOrder(SWF*swf)
+{
+ TAG*tag,*next;
+ TAG*level0;
+ int level;
+ int changes;
+ swf_UnFoldAll(swf);
+ /* at the moment, we don't actually do optimizing,
+ only fixing of non-spec-conformant things like
+ sprite tags */
+
+ do {
+ changes = 0;
+ level = 0;
+ level0 = 0;
+ tag = swf->firstTag;
+ while(tag) {
+ next = tag->next;
+ if(tag->id == ST_DEFINESPRITE) {
+ if(tag->len>4) {
+ /* ??? all sprites are supposed to be unfolded */
+ fprintf(stderr, "librfxswf error - internal error in OptimizeTagOrder/UnfoldAll\n");
+ }
+ level++;
+ if(level==1) {
+ level0 = tag;
+ tag = next;
+ continue;
+ }
+ }
+ if(level>=1) {
+ /* move non-sprite tags out of sprite */
+ if(!swf_isAllowedSpriteTag(tag) || level>=2) {
+ /* remove tag from current position */
+ tag->prev->next = tag->next;
+ if(tag->next)
+ tag->next->prev = tag->prev;
+
+ /* insert before tag level0 */
+ tag->next = level0;
+ tag->prev = level0->prev;
+ level0->prev = tag;
+ tag->prev->next = tag;
+ changes = 1;
+ }
+ }
+ if(tag->id == ST_END) {
+ level--;
+ }
+
+ tag = next;
+ }
+ } while(changes);
+}
// Movie Functions
-int swf_ReadSWF(int handle,SWF * swf) // Reads SWF to memory (malloc'ed), returns length or <0 if fails
+int swf_ReadSWF2(struct reader_t*reader, SWF * swf) // Reads SWF to memory (malloc'ed), returns length or <0 if fails
{
if (!swf) return -1;
memset(swf,0x00,sizeof(SWF));
{ char b[32]; // read Header
- TAG t1;
+ int len;
TAG * t;
+ TAG t1;
+ struct reader_t zreader;
- memset(&t1,0x00,sizeof(TAG));
+ if ((len = reader->read(reader ,b,8))<8) return -1;
+
+ if (b[0]!='F' && b[0]!='C') return -1;
+ if (b[1]!='W') return -1;
+ if (b[2]!='S') return -1;
+ swf->fileVersion = b[3];
+ swf->compressed = (b[0]=='C')?1:0;
+ swf->fileSize = GET32(&b[4]);
- if ((t1.len=read(handle,b,32))<21) return -1;
- t1.data = (U8*)b;
-
- if (swf_GetU8(&t1)!=(U8)'F') return -1;
- if (swf_GetU8(&t1)!=(U8)'W') return -1;
- if (swf_GetU8(&t1)!=(U8)'S') return -1;
+ if(swf->compressed) {
+ reader_init_zlibinflate(&zreader, reader);
+ reader = &zreader;
+ }
- swf->fileVersion = swf_GetU8(&t1);
- swf->fileSize = swf_GetU32(&t1);
- swf_GetRect(&t1,&swf->movieSize);
- swf->frameRate = swf_GetU16(&t1);
- swf->frameCount = swf_GetU16(&t1);
+ reader_GetRect(reader, &swf->movieSize);
+ reader->read(reader, &swf->frameRate, 2);
+ swf->frameRate = SWAP16(swf->frameRate);
+ reader->read(reader, &swf->frameCount, 2);
+ swf->frameCount = SWAP16(swf->frameCount);
- swf_GetU8(&t1);
- lseek(handle,swf_GetTagPos(&t1)-1,SEEK_SET);
-
- // reda tags and connect to list
+ /* read tags and connect to list */
t = &t1;
- while (t) t = swf_ReadTag(handle,t);
+ while (t) t = swf_ReadTag(reader,t);
swf->firstTag = t1.next;
t1.next->prev = NULL;
}
- return 0;
+ return reader->pos;
+}
+
+int swf_ReadSWF(int handle, SWF * swf)
+{
+ struct reader_t reader;
+ reader_init_filereader(&reader, handle);
+ return swf_ReadSWF2(&reader, swf);
}
-int swf_WriteSWF(int handle,SWF * swf) // Writes SWF to file, returns length or <0 if fails
+
+int swf_WriteSWF2(struct writer_t*writer, SWF * swf) // Writes SWF to file, returns length or <0 if fails
{ U32 len;
TAG * t;
+ int frameCount=0;
+ struct writer_t zwriter;
+ int fileSize = 0;
if (!swf) return -1;
#ifdef INSERT_RFX_TAG
- if (swf_NextTag(swf->firstTag))
+ if (swf->firstTag && swf_NextTag(swf->firstTag))
if (swf_GetTagID(swf_NextTag(swf->firstTag))!=ST_REFLEX)
swf_SetBlock(swf_InsertTag(swf->firstTag,ST_REFLEX),"rfx",3);
len = 0;
t = swf->firstTag;
- swf->frameCount = 0;
+ frameCount = 0;
while(t)
- { len += swf_WriteTag(-1,t);
- if (t->id==ST_SHOWFRAME) swf->frameCount++;
+ { len += swf_WriteTag(-1, t);
+ if (t->id==ST_SHOWFRAME) frameCount++;
t = swf_NextTag(t);
}
{ TAG t1;
- char b[64];
+ char b[64],b4[4];
U32 l;
memset(&t1,0x00,sizeof(TAG));
t1.data = (U8*)b;
t1.memsize = 64;
- swf_SetU8(&t1,'F');
- swf_SetU8(&t1,'W');
- swf_SetU8(&t1,'S');
- swf_SetU8(&t1,swf->fileVersion);
-
- swf_SetU32(&t1,0); // Keep space for filesize
+ { // measure header file size
+ TAG t2;
+ char b2[64];
+ memset(&t2,0x00,sizeof(TAG));
+ t2.data = (U8*)b2;
+ t2.memsize = 64;
+ swf_SetRect(&t2, &swf->movieSize);
+ swf_SetU16(&t2, swf->frameRate);
+ swf_SetU16(&t2, swf->frameCount);
+ l = swf_GetTagLen(&t2)+8;
+ }
+ if(swf->compressed == 8) {
+ l -= 8;
+ }
+
+ fileSize = l+len;
+ if(len) {// don't touch headers without tags
+ swf->fileSize = fileSize;
+ swf->frameCount = frameCount;
+ }
+
+ if(swf->compressed != 8) {
+ /* compressed flag set to 8 means "skip first 8
+ header bytes". This is necessary if the caller wants to
+ create compressed SWFs himself */
+ if(swf->compressed) {
+ char*id = "CWS";
+ writer->write(writer, id, 3);
+ }
+ else {
+ char*id = "FWS";
+ writer->write(writer, id, 3);
+ }
+
+ writer->write(writer, &swf->fileVersion, 1);
+ PUT32(b4, swf->fileSize);
+ writer->write(writer, b4, 4);
+
+ if(swf->compressed) {
+ writer_init_zlibdeflate(&zwriter, writer);
+ writer = &zwriter;
+ }
+ }
+
swf_SetRect(&t1,&swf->movieSize);
swf_SetU16(&t1,swf->frameRate);
swf_SetU16(&t1,swf->frameCount);
- l = swf_GetTagLen(&t1);
- swf->fileSize = l+len;
- t1.len = 4; // bad & ugly trick !
- swf_SetU32(&t1,swf->fileSize);
-
- if (handle>=0)
+ if (writer)
{
- int ret = write(handle,b,l);
- if (ret!=l)
+ int ret = writer->write(writer,b,swf_GetTagLen(&t1));
+ if (ret!=swf_GetTagLen(&t1))
{
#ifdef DEBUG_RFXSWF
- printf("ret:%d (fd:%d)\n",ret, handle);
+ fprintf(stderr, "ret:%d\n",ret);
perror("write:");
fprintf(stderr,"WriteSWF() failed: Header.\n");
#endif
t = swf->firstTag;
while (t)
- { if (swf_WriteTag(handle,t)<0) return -1;
+ { if (swf_WriteTag2(writer, t)<0) return -1;
t = swf_NextTag(t);
}
+ if(swf->compressed != 8)
+ writer->finish(writer); // flush zlib buffers - only if _we_ initialized that writer.
}
}
- return (int)swf->fileSize;
+ return (int)fileSize;
+}
+
+int swf_WriteSWF(int handle, SWF * swf) // Writes SWF to file, returns length or <0 if fails
+{
+ struct writer_t writer;
+ swf->compressed = 0;
+ if(handle<0)
+ return swf_WriteSWF2(&writer, swf);
+ writer_init_filewriter(&writer, handle);
+ return swf_WriteSWF2(&writer, swf);
+}
+
+int swf_WriteSWC(int handle, SWF * swf) // Writes SWF to file, returns length or <0 if fails
+{
+ struct writer_t writer;
+ swf->compressed = 1;
+ if(handle<0)
+ return swf_WriteSWF2(&writer, swf);
+ writer_init_filewriter(&writer, handle);
+ return swf_WriteSWF2(&writer, swf);
+}
+
+int swf_WriteHeader2(struct writer_t*writer,SWF * swf)
+{
+ SWF myswf;
+ memcpy(&myswf,swf,sizeof(SWF));
+ myswf.firstTag = 0;
+ return swf_WriteSWF2(writer, &myswf);
+}
+
+int swf_WriteHeader(int handle,SWF * swf)
+{
+ SWF myswf;
+ memcpy(&myswf,swf,sizeof(SWF));
+ myswf.firstTag = 0;
+ return swf_WriteSWF(handle, &myswf);
}
int swf_WriteCGI(SWF * swf)
// include advanced functions
-#ifdef __NT__
-
-#include "modules\swfdump.c"
-#include "modules\swfshape.c"
-#include "modules\swftext.c"
-#include "modules\swfobject.c"
-#include "modules\swfbutton.c"
-#include "modules\swftools.c"
-#include "modules\swfcgi.c"
-#include "modules\swfbits.c"
-#include "modules\swfaction.c"
-
-#else
-
#include "modules/swfdump.c"
#include "modules/swfshape.c"
#include "modules/swftext.c"
#include "modules/swfcgi.c"
#include "modules/swfbits.c"
#include "modules/swfaction.c"
-
-#endif
-
-
+#include "modules/swfsound.c"
git.asbjorn.biz / swftools.git / blobdiff