X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fmodules%2Fswftools.c;h=c4f6e0581f2ad64991223d7b5e59bdda62336a33;hb=4acb3c6593a57f4feb0e8b496025ef8497f8e9a2;hp=0b2a740b0bec212ca85a1f745993cd1f2e52af93;hpb=63238b27c482e8b760d2e6db5568b31a4b2cdb5f;p=swftools.git

diff --git a/lib/modules/swftools.c b/lib/modules/swftools.c
index 0b2a740..c4f6e05 100644
--- a/lib/modules/swftools.c
+++ b/lib/modules/swftools.c
@@ -7,9 +7,19 @@
 
    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
 
@@ -99,13 +109,21 @@ U16 swf_GetDefineID(TAG * t)
     case ST_DEFINEFONT:
     case ST_DEFINEFONT2:
     case ST_DEFINEFONTINFO: //pseudodefine
+    case ST_DEFINEFONTINFO2: //pseudodefine
     case ST_DEFINETEXT:
     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);
@@ -113,6 +131,49 @@ U16 swf_GetDefineID(TAG * t)
   return id;
 }
 
+SRECT swf_GetDefineBBox(TAG * t)
+{
+  U32 oldTagPos;
+  U16 id = 0;
+  SRECT b1,b2;
+  memset(&b1, 0, sizeof(b1));
+
+  oldTagPos = swf_GetTagPos(t);
+  swf_SetTagPos(t,0);
+
+  swf_GetRect(0, &b1);
+
+  switch (swf_GetTagID(t))
+  { case ST_DEFINESHAPE:
+    case ST_DEFINESHAPE2:
+    case ST_DEFINESHAPE3:
+    case ST_DEFINEEDITTEXT:
+    case ST_DEFINETEXT:
+    case ST_DEFINETEXT2:
+    case ST_DEFINEVIDEOSTREAM:
+      id = swf_GetU16(t);
+      swf_GetRect(t, &b1);
+      break;
+    case ST_DEFINEMORPHSHAPE:
+      id = swf_GetU16(t);
+      swf_GetRect(t, &b1);
+      swf_GetRect(t, &b2);
+      swf_ExpandRect2(&b1, &b2);
+      break;
+    case ST_DEFINEBITSLOSSLESS:
+    case ST_DEFINEBITSLOSSLESS2:
+    case ST_DEFINEBITS:
+    case ST_DEFINEBITSJPEG2:
+    case ST_DEFINEBITSJPEG3:
+      // FIXME
+      break;
+  }
+
+  swf_SetTagPos(t,oldTagPos);
+
+  return b1;
+}
+
 U16 swf_GetPlaceID(TAG * t)
 // up to SWF 4.0
 { U32 oldTagPos;
@@ -162,6 +223,7 @@ static int swf_definingtagids[] =
  ST_DEFINEBUTTON,
  ST_DEFINEBUTTON2,
  ST_DEFINESOUND,
+ ST_DEFINEVIDEOSTREAM,
  -1
 };
 
@@ -185,9 +247,13 @@ static int swf_spritetagids[] =
 static int swf_pseudodefiningtagids[] = 
 {
  ST_DEFINEFONTINFO,
+ ST_DEFINEFONTINFO2,
  ST_DEFINEBUTTONCXFORM,
  ST_DEFINEBUTTONSOUND,
  ST_NAMECHARACTER,
+ ST_DOINITACTION,
+ ST_VIDEOFRAME,
+ ST_GLYPHNAMES,
  -1
 };
 
@@ -230,10 +296,9 @@ U8 swf_isPseudoDefiningTag(TAG * tag)
     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);
@@ -251,11 +316,36 @@ U16 swf_GetDepth(TAG * t)
     { 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;
@@ -280,6 +370,8 @@ char* swf_GetName(TAG * t)
               swf_GetCXForm(t, &c, 1);
             if(flags&PF_RATIO)
               swf_GetU16(t);
+            if(flags&PF_CLIPACTION)
+              swf_GetU16(t);
             if(flags&PF_NAME) {
               swf_ResetReadBits(t);
               name = &t->data[swf_GetTagPos(t)];
@@ -291,6 +383,30 @@ char* swf_GetName(TAG * t)
     return name;
 }
 
+/* used in enumerateUsedIDs */
+void swf_GetMorphGradient(TAG * tag, GRADIENT * gradient1, GRADIENT * gradient2)
+{
+    GRADIENT dummy1;
+    GRADIENT dummy2;
+    int t;
+    if(!gradient1)
+	gradient1 = &dummy1;
+    if(!gradient2)
+	gradient2 = &dummy2;
+    gradient1->num = 
+    gradient2->num = swf_GetU8(tag);
+    for(t=0;t<gradient1->num;t++)
+    {
+	int s=t;
+	if(s>=8) //FIXME
+	    s=7;
+	gradient1->ratios[t] = swf_GetU8(tag);
+	swf_GetRGBA(tag, &gradient1->rgba[t]);
+	gradient2->ratios[t] = swf_GetU8(tag);
+	swf_GetRGBA(tag, &gradient2->rgba[t]);
+    }
+}
+
 #define DEBUG_ENUMERATE if(0)
 
 static void enumerateUsedIDs_styles(TAG * tag, void (*callback)(TAG*, int, void*), void*callback_data, int num, int morph)
@@ -410,7 +526,6 @@ void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), v
 	case ST_FREECHARACTER: /* unusual tags, which all start with an ID */
 	case ST_NAMECHARACTER:
 	case ST_GENERATORTEXT:
-	case ST_MX3:
 	    callback(tag, tag->pos + base, callback_data);
         break;
 	case ST_PLACEOBJECT:
@@ -446,7 +561,7 @@ void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), v
 		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 */
@@ -547,13 +662,21 @@ void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), v
 	    }
 	    break;
 	}
+	case ST_GLYPHNAMES:
 	case ST_DEFINEFONTINFO:
+	case ST_DEFINEFONTINFO2:
+	case ST_VIDEOFRAME:
 	    callback(tag, tag->pos + base, callback_data);
 	break;
+	case ST_DEFINEVIDEOSTREAM:
+	break;
 
-	//case ST_DEFINEMORPHSHAPE: /* disabled for now (doesn't work) */
+	case ST_DOINITACTION:
+	    callback(tag, tag->pos + base, callback_data);
+	break;
 
-	case ST_DEFINESHAPE3: // these thingies might have bitmap ids in their fillstyles
+	case ST_DEFINEMORPHSHAPE:
+	case ST_DEFINESHAPE3:
 	num++; //fallthrough
 	case ST_DEFINESHAPE2:
 	num++; //fallthrough
@@ -561,23 +684,28 @@ void enumerateUsedIDs(TAG * tag, int base, void (*callback)(TAG*, int, void*), v
 	    int fillbits;
 	    int linebits;
 	    int id; 
+	    int numshapes = 1;
 	    int morph = 0;
-	    if(tag->id == ST_DEFINEMORPHSHAPE)
+	    if(tag->id == ST_DEFINEMORPHSHAPE) {
+		numshapes = 2;
 		morph = 1;
+	    }
 
 	    id = swf_GetU16(tag); // id;
 	    swf_GetRect(tag, NULL); // bounds
 	    if(morph) {
+		swf_ResetReadBits(tag);
 		swf_GetRect(tag, NULL); // bounds2
 		swf_GetU32(tag); //offset to endedges
 	    }
-    
+   
 	    DEBUG_ENUMERATE printf("Tag:%d Name:%s ID:%d\n", tag->id, swf_TagGetName(tag), id);
 
 	    enumerateUsedIDs_styles(tag, callback, callback_data, num, morph);
 	    DEBUG_ENUMERATE printf("-------\n");
-	    while(--morph>=0) /* morph shapes define two shapes */
+	    while(--numshapes>=0) /* morph shapes define two shapes */
 	    {
+		DEBUG_ENUMERATE printf("shape:%d\n", numshapes);
 		fillbits = swf_GetBits(tag, 4);
 		linebits = swf_GetBits(tag, 4);
 		DEBUG_ENUMERATE printf("%d %d\n", fillbits, linebits);
@@ -717,19 +845,270 @@ void swf_Relocate (SWF*swf, char*bitmap)
 	} 
 	
 	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 never encountered before: %d\n", id);
+		    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)
+    {
+	/* TODO * clip depths 
+	        * sprites
+	 */
+	int 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_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));
+    }
+}
+