Copyright (c) 2000, 2001 Rainer Böhme <rfxswf@reflex-studio.de>
- This file is distributed under the GPL, see file COPYING for details
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-*/
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Matrix & Math tools for SWF files
#define S64 long long
SFIXED RFXSWF_SP(SFIXED a1,SFIXED a2,SFIXED b1,SFIXED b2)
-{ S64 a;
- a = (S64)a1*(S64)b1+(S64)a2*(S64)b2;
- return (SFIXED)(a>>16);
+{ S64 a = ((S64)a1*(S64)b1+(S64)a2*(S64)b2)>>16;
+ SFIXED result = (SFIXED)(a);
+ if(a!=result)
+ fprintf(stderr, "Warning: overflow in matrix multiplication");
+ return result;
}
SFIXED RFXSWF_QFIX(int zaehler,int nenner) // bildet Quotient von zwei INTs in SFIXED
{ S64 z = zaehler<<16;
if (!s1) return (s2)?(MATRIX *)memcpy(d,s2,sizeof(MATRIX)):NULL;
if (!s2) return (MATRIX *)memcpy(d,s1,sizeof(MATRIX));
- d->tx = s1->tx + s2->tx;
- d->ty = s1->ty + s2->ty;
+ d->tx = s1->tx + RFXSWF_SP(s1->sx,s1->r1,s2->tx,s2->ty);
+ d->ty = s1->ty + RFXSWF_SP(s1->r0,s1->sy,s2->tx,s2->ty);
d->sx = RFXSWF_SP(s1->sx,s1->r1,s2->sx,s2->r0);
- d->sy = RFXSWF_SP(s1->r0,s1->sy,s2->r1,s2->sy);
d->r0 = RFXSWF_SP(s1->r0,s1->sy,s2->sx,s2->r0);
+
d->r1 = RFXSWF_SP(s1->sx,s1->r1,s2->r1,s2->sy);
+ d->sy = RFXSWF_SP(s1->r0,s1->sy,s2->r1,s2->sy);
//DumpMatrix(NULL,d);
case ST_DEFINETEXT2:
case ST_DEFINESOUND:
case ST_DEFINESPRITE:
+ case ST_DEFINEMOVIE:
case ST_DEFINEVIDEOSTREAM:
+ case ST_GLYPHNAMES: //pseudodefine
case ST_VIDEOFRAME: //pseudodefine
case ST_NAMECHARACTER: //pseudodefine
+ case ST_DOINITACTION: //pseudodefine
id = swf_GetU16(t);
break;
+ default:
+ fprintf(stderr, "rfxswf: Error: tag %d (%s) has no id\n", t->id, swf_TagGetName(t));
}
swf_SetTagPos(t,oldTagPos);
U32 oldTagPos;
U16 id = 0;
SRECT b1,b2;
+ memset(&b1, 0, sizeof(b1));
oldTagPos = swf_GetTagPos(t);
swf_SetTagPos(t,0);
case ST_DEFINESHAPE2:
case ST_DEFINESHAPE3:
case ST_DEFINEEDITTEXT:
- case ST_DEFINEBUTTON:
- case ST_DEFINEBUTTON2:
case ST_DEFINETEXT:
case ST_DEFINETEXT2:
case ST_DEFINEVIDEOSTREAM:
ST_NAMECHARACTER,
ST_DOINITACTION,
ST_VIDEOFRAME,
+ ST_GLYPHNAMES,
-1
};
return 0;
}
-U16 swf_GetDepth(TAG * t)
-// up to SWF 4.0
+int swf_GetDepth(TAG * t)
{
- U16 depth = 0;
+ int depth = -1;
U32 oldTagPos;
oldTagPos = swf_GetTagPos(t);
swf_SetTagPos(t,0);
{ U8 flags = swf_GetU8(t);
depth = swf_GetU16(t);
} break;
+ case ST_SETTABINDEX:
+ {
+ depth = swf_GetU16(t);
+ }
}
swf_SetTagPos(t,oldTagPos);
return depth;
}
+void swf_SetDepth(TAG * t, U16 depth)
+{
+ switch (swf_GetTagID(t))
+ { case ST_PLACEOBJECT:
+ case ST_REMOVEOBJECT:
+ PUT16(t->data, depth);
+ break;
+ case ST_REMOVEOBJECT2:
+ PUT16(t->data, depth);
+ break;
+ case ST_PLACEOBJECT2:
+ PUT16(&t->data[1], depth);
+ break;
+ case ST_SETTABINDEX:
+ PUT16(t->data, depth);
+ break;
+ default:
+ fprintf(stderr, "rfxswf: Error: tag %d has no depth\n", t->id);
+ }
+}
+
char* swf_GetName(TAG * t)
{
char* name = 0;
#define DEBUG_ENUMERATE if(0)
-static void enumerateUsedIDs_styles(TAG * tag, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
+void enumerateUsedIDs_styles(TAG * tag, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
{
U16 count;
int t;
tag->pos = 0;
switch(tag->id)
{
- case ST_DEFINEBUTTONCXFORM: {
+ case ST_DEFINEBUTTONSOUND: {
int t;
callback(tag, tag->pos + base, callback_data);
for(t=0;t<4;t++) {
}
}
} break;
- case ST_DEFINEBUTTONSOUND:
+ case ST_DEFINEBUTTONCXFORM:
callback(tag, tag->pos + base, callback_data); //button id
break;
if(id == ST_END)
break;
tag2->len = tag2->memsize = len;
- tag2->data = malloc(len);
+ tag2->data = rfx_alloc(len);
memcpy(tag2->data, &tag->data[tag->pos], len);
/* I never saw recursive sprites, but they are (theoretically)
possible, so better add base here again */
advancebits = swf_GetU8(tag); //advancebits
while(1) {
U16 flags;
+ int t;
swf_ResetReadBits(tag);
flags = swf_GetBits(tag, 8);
if(!flags) break;
- if(flags & 128) // text style record
- {
+
+ swf_ResetReadBits(tag);
+ if(flags & 8) { // hasfont
+ callback(tag, tag->pos + base, callback_data);
+ id = swf_GetU16(tag);
+ }
+ if(flags & 4) { // hascolor
+ if(num==1) swf_GetRGB(tag, NULL);
+ else swf_GetRGBA(tag, NULL);
+ }
+ if(flags & 2) { //has x offset
swf_ResetReadBits(tag);
- if(flags & 8) { // hasfont
- callback(tag, tag->pos + base, callback_data);
- id = swf_GetU16(tag);
- }
- if(flags & 4) { // hascolor
- if(num==1) swf_GetRGB(tag, NULL);
- else swf_GetRGBA(tag, NULL);
- }
- if(flags & 2) { //has x offset
- swf_ResetReadBits(tag);
- swf_GetU16(tag);
- }
- if(flags & 1) { //has y offset
- swf_ResetReadBits(tag);
- swf_GetU16(tag);
- }
- if(flags & 8) { //has height
- swf_ResetReadBits(tag);
- swf_GetU16(tag);
- }
- } else { // glyph record
- int t;
+ swf_GetU16(tag);
+ }
+ if(flags & 1) { //has y offset
swf_ResetReadBits(tag);
- for(t=0;t<flags;t++) {
- swf_GetBits(tag, glyphbits);
- swf_GetBits(tag, advancebits);
- }
+ swf_GetU16(tag);
+ }
+ if(flags & 8) { //has height
+ swf_ResetReadBits(tag);
+ swf_GetU16(tag);
+ }
+
+ flags = swf_GetBits(tag, 8);
+ if(!flags) break;
+ swf_ResetReadBits(tag);
+ for(t=0;t<flags;t++) {
+ swf_GetBits(tag, glyphbits);
+ swf_GetBits(tag, advancebits);
}
}
break;
}
+ case ST_GLYPHNAMES:
case ST_DEFINEFONTINFO:
case ST_DEFINEFONTINFO2:
case ST_VIDEOFRAME:
}
num = swf_GetNumUsedIDs(tag);
- ptr = malloc(sizeof(int)*num);
- swf_GetUsedIDs(tag, ptr);
-
- for(t=0;t<num;t++) {
- int id = GET16(&tag->data[ptr[t]]);
- if(slaveids[id]<0) {
- fprintf(stderr, "swf_Relocate: Mapping id never encountered before: %d\n", id);
- return ;
+ if(num) {
+ ptr = rfx_alloc(sizeof(int)*num);
+ swf_GetUsedIDs(tag, ptr);
+
+ for(t=0;t<num;t++) {
+ int id = GET16(&tag->data[ptr[t]]);
+ if(slaveids[id]<0) {
+ fprintf(stderr, "swf_Relocate: Mapping id (%d) never encountered before in %s\n", id,
+ swf_TagGetName(tag));
+ return ;
+ }
+ id = slaveids[id];
+ PUT16(&tag->data[ptr[t]], id);
}
- id = slaveids[id];
- PUT16(&tag->data[ptr[t]], id);
}
tag=tag->next;
}
}
-
+
+void swf_RelocateDepth(SWF*swf, char*bitmap)
+{
+ TAG*tag;
+ int nr;
+ tag = swf->firstTag;
+ for(nr=65535;nr>=0;nr--) {
+ if(bitmap[nr] != 0)
+ break;
+ }
+ // now nr is the highest used depth. So we start
+ // assigning depths at nr+1
+ nr++;
+
+ while(tag)
+ {
+ int depth;
+ /* TODO * clip depths
+ * sprites
+ */
+ if(tag->id == ST_PLACEOBJECT2) {
+ SWFPLACEOBJECT obj;
+ swf_GetPlaceObject(tag, &obj);
+ if(obj.clipdepth) {
+ int newdepth = obj.clipdepth+nr;
+ if(newdepth>65535) {
+ fprintf(stderr, "Couldn't relocate depths: too large values\n");
+ newdepth = 65535;
+ }
+ obj.clipdepth = newdepth;
+ swf_ResetTag(tag, ST_PLACEOBJECT2);
+ swf_SetPlaceObject(tag, &obj);
+ }
+ swf_PlaceObjectFree(&obj);
+ }
+
+ depth = swf_GetDepth(tag);
+ if(depth>=0) {
+ int newdepth = depth+nr;
+ if(newdepth>65535) {
+ fprintf(stderr, "Couldn't relocate depths: too large values\n");
+ newdepth = 65535;
+ }
+ swf_SetDepth(tag, newdepth);
+ }
+ tag=tag->next;
+ }
+}
+
+U8 swf_isShapeTag(TAG*tag)
+{
+ if(tag->id == ST_DEFINESHAPE ||
+ tag->id == ST_DEFINESHAPE2 ||
+ tag->id == ST_DEFINESHAPE3)
+ return 1;
+ return 0;
+}
+
+U8 swf_isPlaceTag(TAG*tag)
+{
+ if(tag->id == ST_PLACEOBJECT ||
+ tag->id == ST_PLACEOBJECT2)
+ return 1;
+ return 0;
+}
+U8 swf_isTextTag(TAG*tag)
+{
+ if(tag->id == ST_DEFINETEXT ||
+ tag->id == ST_DEFINETEXT2)
+ return 1;
+ return 0;
+}
+
+U8 swf_isFontTag(TAG*tag)
+{
+ if(tag->id == ST_DEFINEFONT ||
+ tag->id == ST_DEFINEFONT2 ||
+ tag->id == ST_DEFINEFONTINFO)
+ return 1;
+ return 0;
+}
+
+U8 swf_isImageTag(TAG*tag)
+{
+ if(tag->id == ST_DEFINEBITSJPEG ||
+ tag->id == ST_DEFINEBITSJPEG2 ||
+ tag->id == ST_DEFINEBITSJPEG3 ||
+ tag->id == ST_DEFINEBITSLOSSLESS ||
+ tag->id == ST_DEFINEBITSLOSSLESS2)
+ return 1;
+ return 0;
+}
+
+TAG* swf_Concatenate (TAG*list1,TAG*list2)
+{
+ TAG*tag=0,*lasttag=0;
+ char bitmap[65536];
+ char depthmap[65536];
+ SWF swf1,swf2;
+ memset(bitmap, 0, sizeof(bitmap));
+ memset(depthmap, 0, sizeof(depthmap));
+ memset(&swf1, 0, sizeof(swf1));
+ memset(&swf2, 0, sizeof(swf2));
+
+ swf1.firstTag = list1;
+ swf_FoldAll(&swf1);
+ swf2.firstTag = list2;
+ swf_FoldAll(&swf2);
+
+ tag = list1;
+ while(tag) {
+ if(!swf_isDefiningTag(tag)) {
+ int id = swf_GetDefineID(tag);
+ bitmap[id] = 1;
+ }
+ if(tag->id == ST_PLACEOBJECT ||
+ tag->id == ST_PLACEOBJECT2) {
+ int depth = swf_GetDepth(tag);
+ depthmap[depth] = 1;
+ }
+ if(tag->id == ST_REMOVEOBJECT ||
+ tag->id == ST_REMOVEOBJECT2) {
+ int depth = swf_GetDepth(tag);
+ depthmap[depth] = 0;
+ }
+ tag = tag->next;
+ lasttag = tag;
+ }
+ swf_Relocate(&swf2, bitmap);
+ swf_RelocateDepth(&swf2, depthmap);
+ lasttag->next = swf2.firstTag;
+ swf2.firstTag->prev = lasttag;
+
+ return swf1.firstTag;
+}
+
+static int tagHash(TAG*tag)
+{
+ int t, h=0;
+ unsigned int a = 0x6b973e5a;
+ /* start at pos 2, as 0 and 1 are the id */
+ for(t=2;t<tag->len;t++) {
+ unsigned int b = a;
+ a >>= 8;
+ a += tag->data[t]*0xefbc35a5*b*(t+1);
+ }
+ return a&0x7fffffff; //always return positive number
+}
+
+void swf_Optimize(SWF*swf)
+{
+ const int hash_size = 131072;
+ char* dontremap = rfx_calloc(sizeof(char)*65536);
+ U16* remap = rfx_alloc(sizeof(U16)*65536);
+ TAG* id2tag = rfx_calloc(sizeof(TAG*)*65536);
+ TAG** hashmap = rfx_calloc(sizeof(TAG*)*hash_size);
+ TAG* tag;
+ int t;
+ for(t=0;t<65536;t++) {
+ remap[t] = t;
+ }
+
+ swf_FoldAll(swf);
+
+ tag = swf->firstTag;
+ while(tag) {
+ /* make sure we don't remap to this tag,
+ as it might have different "helper tags"
+ FIXME: a better way would be to compare
+ the helper tags, too.
+ */
+ if(swf_isPseudoDefiningTag(tag) &&
+ tag->id != ST_NAMECHARACTER) {
+ dontremap[swf_GetDefineID(tag)] = 1;
+ }
+ tag=tag->next;
+ }
+ tag = swf->firstTag;
+ while(tag) {
+ int doremap=1;
+
+ TAG*next = tag->next;
+
+ /* remap the tag */
+ int num = swf_GetNumUsedIDs(tag);
+ int*positions = rfx_alloc(sizeof(int)*num);
+ int t;
+ swf_GetUsedIDs(tag, positions);
+ for(t=0;t<num;t++) {
+ int id = GET16(&tag->data[positions[t]]);
+ id = remap[id];
+ PUT16(&tag->data[positions[t]], id);
+ }
+ rfx_free(positions);
+ tag = tag->next;
+
+ /* now look for previous tags with the same
+ content */
+ if(swf_isDefiningTag(tag)) {
+ TAG*tag2;
+ int id = swf_GetDefineID(tag);
+ int hash = tagHash(tag);
+ int match=0;
+ if(!dontremap[id])
+ while((tag2 = hashmap[hash%hash_size])) {
+ if(tag2 != (TAG*)(-1) && tag->len == tag2->len) {
+ int t;
+ /* start at pos 2, as 0 and 1 are the id */
+ for(t=2;t<tag->len;t++) {
+ if(tag->data[t] != tag2->data[t])
+ break;
+ }
+ if(t == tag->len) {
+ match=1;
+ }
+ }
+ if(match) {
+ /* we found two identical tags- remap one
+ of them */
+ remap[id] = swf_GetDefineID(tag2);
+ break;
+ }
+ hash++;
+ }
+ if(!match) {
+ while(hashmap[hash%hash_size]) hash++;
+ hashmap[hash%hash_size] = tag;
+ } else {
+ swf_DeleteTag(tag);
+ if(tag == swf->firstTag)
+ swf->firstTag = next;
+ doremap = 0;
+ }
+ } else if(swf_isPseudoDefiningTag(tag)) {
+ int id = swf_GetDefineID(tag);
+ if(remap[id]!=id) {
+ /* if this tag was remapped, we don't
+ need the helper tag anymore. Discard
+ it. */
+ swf_DeleteTag(tag);
+ if(tag == swf->firstTag)
+ swf->firstTag = next;
+ doremap = 0;
+ }
+ }
+
+ tag = next;
+ }
+ rfx_free(dontremap);
+ rfx_free(remap);
+ rfx_free(id2tag);
+ rfx_free(hashmap);
+}
+
+void swf_SetDefineBBox(TAG * tag, SRECT newbbox)
+{
+ U16 id = 0;
+ SRECT b1;
+ swf_SetTagPos(tag,0);
+
+ switch (swf_GetTagID(tag))
+ {
+ case ST_DEFINESHAPE:
+ case ST_DEFINESHAPE2:
+ case ST_DEFINESHAPE3:
+ case ST_DEFINEEDITTEXT:
+ case ST_DEFINETEXT:
+ case ST_DEFINETEXT2:
+ case ST_DEFINEVIDEOSTREAM: {
+ U32 after_bbox_offset = 0, len;
+ U8*data;
+ id = swf_GetU16(tag);
+ swf_GetRect(tag, &b1);
+ swf_ResetReadBits(tag);
+ after_bbox_offset = tag->pos;
+ len = tag->len - after_bbox_offset;
+ data = malloc(len);
+ memcpy(data, &tag->data[after_bbox_offset], len);
+ tag->writeBit = 0;
+ tag->len = 2;
+ swf_SetRect(tag, &newbbox);
+ swf_SetBlock(tag, data, len);
+ free(data);
+ tag->pos = tag->readBit = 0;
+
+ } break;
+ default:
+ fprintf(stderr, "rfxswf: Tag %d (%s) has no bbox\n", tag->id, swf_TagGetName(tag));
+ }
+}
+
+RGBA swf_GetSWFBackgroundColor(SWF*swf)
+{
+ TAG*t=swf->firstTag;
+ RGBA color;
+ color.r = color.b = color.g = 0;
+ color.a = 255;
+ while(t) {
+ if(t->id == ST_SETBACKGROUNDCOLOR) {
+ swf_SetTagPos(t, 0);
+ color.r = swf_GetU8(t);
+ color.g = swf_GetU8(t);
+ color.b = swf_GetU8(t);
+ break;
+ }
+ t=t->next;
+ }
+ return color;
+}
+