X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fmodules%2Fswfrender.c;h=1cdc4987d4e4f7ae12355578166d6697e0d17ee5;hb=603099a6f5603b7576f89acba66c8d59542a032c;hp=e5775bc93caf53edff6a5242c943ad48ee4edca8;hpb=efd888e3f4bf32721fd7815e6795fd4d0912afc8;p=swftools.git

diff --git a/lib/modules/swfrender.c b/lib/modules/swfrender.c
index e5775bc..1cdc498 100644
--- a/lib/modules/swfrender.c
+++ b/lib/modules/swfrender.c
@@ -31,16 +31,21 @@ typedef struct _dummyshape
     struct _dummyshape*next;
 } dummyshape_t;
 
+/* one bit flag: */
+#define clip_type 0
+#define fill_type 1
+
 typedef struct _renderpoint
 {
-    enum {clip_type, fill_type} type;
-    float fx; //for sorting
-    int x;
+    char type;
+    float x;
     U32 depth;
-    U32 clipdepth;
+
     SHAPELINE*shapeline;
-   
+    
+    U32 clipdepth;
     dummyshape_t*s;
+    
 } renderpoint_t;
 
 /* 
@@ -93,13 +98,107 @@ typedef struct _renderbuf_internal
 
 #define DEBUG 0
 
+static void renderpoint_write(TAG*tag, renderpoint_t*p)
+{
+    if(tag->len == 0) {
+	swf_SetU32(tag, 1);
+    } else {
+	int num = GET32(tag->data);
+	PUT32(tag->data, num+1);
+    }
+
+    swf_SetBits(tag, p->type, 1);
+    swf_SetBits(tag, *(U32*)&p->x, 32);
+    if(p->depth & 0xffff) {
+	swf_SetBits(tag, 1, 1);
+	swf_SetBits(tag, p->depth, 32);
+    } else {
+	swf_SetBits(tag, 0, 1);
+	swf_SetBits(tag, p->depth >> 16, 16);
+    }
+    if(p->shapeline) {
+	swf_SetBits(tag, 1, 1);
+	swf_SetBits(tag, *(U32*)&p->shapeline, 32);
+    } else {
+	swf_SetBits(tag, 0, 1);
+    }
+
+    if(p->type == clip_type) {
+	//printf("type=%d x=%f, depth=%08x, shapeline=%08x, clipdepth=%08x\n", p->type, p->x, p->depth, p->shapeline, p->clipdepth);
+	assert((p->clipdepth & 0xffff) == 0xffff);
+	swf_SetBits(tag, p->clipdepth >> 16, 16);
+	/* don't set s */
+    } else {
+	//printf("type=%d x=%f, depth=%08x, shapeline=%08x, s=%08x\n", p->type, p->x, p->depth, p->shapeline, p->s);
+	swf_SetBits(tag, *(U32*)&p->s, 32);
+	/* don't set clipdepth */
+    }
+}
+static renderpoint_t renderpoint_read(TAG*tag, int num)
+{
+    renderpoint_t p;
+    U8 flag = 0;
+    U32 dummy = 0;
+
+    p.type = swf_GetBits(tag, 1);
+    
+    dummy = swf_GetBits(tag, 32);p.x = *(float*)&dummy;
+    flag = swf_GetBits(tag, 1);
+    if(flag) {
+	p.depth = swf_GetBits(tag, 32);
+    } else {
+	p.depth = swf_GetBits(tag, 16) << 16;
+    }
+    flag = swf_GetBits(tag, 1);
+    if(flag) {
+	dummy = swf_GetBits(tag, 32);p.shapeline = *(SHAPELINE**)&dummy;
+    } else {
+	p.shapeline = 0;
+    }
+
+    if(p.type == clip_type) {
+	p.clipdepth = swf_GetBits(tag, 16) << 16 | 0xffff;
+	p.s = 0;
+    } else {
+	dummy = swf_GetBits(tag, 32);p.s = *(dummyshape_t**)&dummy;
+	p.clipdepth = 0;
+    }
+
+    return p;
+}
+
+static int renderpoint_num(TAG*tag)
+{
+    if(tag->len == 0)
+	return 0;
+    return GET32(tag->data);
+}
+
+static renderpoint_t* renderpoint_readall(TAG*tag)
+{
+    int num;
+    int t;
+    renderpoint_t*p;
+    swf_SetTagPos(tag, 0);
+    if(tag->len == 0)
+	num = 0;
+    else
+	num = swf_GetU32(tag);
+    p = (renderpoint_t*)rfx_alloc(num*sizeof(renderpoint_t));
+    for(t=0;t<num;t++)
+	p[t] = renderpoint_read(tag,t);
+    return p;
+}
+
 static inline void add_pixel(RENDERBUF*dest, float x, int y, renderpoint_t*p)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
     if(x >= i->width2 || y >= i->height2 || y<0) return;
-    p->x = (int)x;
-    p->fx = x;
-    swf_SetBlock(i->lines[y].points, (U8*)p, sizeof(renderpoint_t));
+    p->x = x;
+    if(y<10)
+	renderpoint_write(i->lines[y].points, p);
+    else
+	renderpoint_write(i->lines[y].points, p);
 }
 
 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
@@ -265,8 +364,8 @@ static int compare_renderpoints(const void * _a, const void * _b)
 {
     renderpoint_t*a = (renderpoint_t*)_a;
     renderpoint_t*b = (renderpoint_t*)_b;
-    if(a->fx < b->fx) return -1;
-    if(a->fx > b->fx) return 1;
+    if(a->x < b->x) return -1;
+    if(a->x > b->x) return 1;
     return 0;
 }
 
@@ -311,7 +410,8 @@ void swf_Render_AddImage(RENDERBUF*buf, U16 id, RGBA*img, int width, int height)
     bm->id = id;
     bm->width = width;
     bm->height = height;
-    bm->data = img;
+    bm->data = rfx_alloc(width*height*4);
+    memcpy(bm->data, img, width*height*4);
 
     bm->next = i->bitmaps;
     i->bitmaps = bm;
@@ -353,7 +453,7 @@ void swf_Render_Delete(RENDERBUF*dest)
     /* delete bitmaps */
     while(b) {
         bitmap_t*next = b->next;
-        //free(b->data);b->data=0;
+        free(b->data);b->data=0;
         rfx_free(b);
         b = next;
     }
@@ -394,31 +494,34 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
     
-    SHAPELINE*line = shape->lines;
+    SHAPELINE*line;
     int x=0,y=0;
     MATRIX mat = *m;
     SHAPE2* lshape = 0;
 
+    SHAPE2* s2 = swf_Shape2Clone(shape);
+    /* add this shape to the global shape list, for deallocing */
+    dummyshape_t*fshape = rfx_calloc(sizeof(dummyshape_t));
+    fshape->shape = s2;
+    swf_Render_AddShape(dest, fshape);
+
+    line = s2->lines;
+
     renderpoint_t p, lp;
     memset(&p, 0, sizeof(renderpoint_t));
     memset(&lp, 0, sizeof(renderpoint_t));
     
     p.type = _clipdepth?clip_type:fill_type;
     p.depth = _depth << 16;
-    p.clipdepth = _clipdepth << 16;
+    p.clipdepth = _clipdepth? _clipdepth << 16 | 0xffff : 0;
 
     mat.tx -= dest->posx*20;
     mat.ty -= dest->posy*20;
+        
 
     if(shape->numfillstyles) {
-        dummyshape_t*fshape = rfx_calloc(sizeof(dummyshape_t));
         int t;
-        SHAPE2* s2 = swf_Shape2Clone(shape);
-       
-        fshape->shape = s2;
-
         p.s = fshape;
-
         /* multiply fillstyles matrices with placement matrix-
            important for texture and gradient fill */
         for(t=0;t<s2->numfillstyles;t++) {
@@ -433,8 +536,6 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
             s2->fillstyles[t].m = nm;
         }
 
-        /* add this shape to the global shape list, for deallocing */
-        swf_Render_AddShape(dest, fshape);
     }
 
     if(shape->numlinestyles) {
@@ -453,7 +554,7 @@ void swf_RenderShape(RENDERBUF*dest, SHAPE2*shape, MATRIX*m, CXFORM*c, U16 _dept
     }
 
     if(p.clipdepth) {
-        /* reverse shape */
+        /* invert shape */
         p.shapeline = 0;
         add_line(dest, -20, 0, -20, i->height2*20, &p);
     }
@@ -621,22 +722,41 @@ static void fill_bitmap(RGBA*line, int y, int x1, int x2, MATRIX*m, bitmap_t*b,
     } while(++x<x2);
 }
 
-static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*state)
+static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*clipstate, state_t*fillstate)
 {
     renderbuf_internal*i = (renderbuf_internal*)dest->internal;
     U32 clipdepth;
 
-    layer_t*l = state->layers;
+    layer_t*lc = clipstate->layers;
+    layer_t*lf = fillstate->layers;
+    layer_t*l = 0;
 
     if(x1>=x2) //zero width? nothing to do.
         return;
-
+    
     clipdepth = 0;
-    while(l) {
-        if(l->p->depth < clipdepth) {
+    while(lf) {
+	if(lc && (!lf || lc->p->depth < lf->p->depth)) {
+	    l = lc;
+	    lc = lc->next;
+	} else if(lf && (!lc || lf->p->depth < lc->p->depth)) {
+	    l = lf;
+	    lf = lf->next;
+	} else if(lf && lc && lf->p->depth == lc->p->depth) {
+	    /* A clipshape and a fillshape at the same depth. Yuck.
+	       Bug in the SWF file */
+	    fprintf(stderr, "Error: Multiple use of depth %d in SWF\n", lf->p->depth);
+	    l = lc;
+	    lc = lc->next;
+	} else {
+	    fprintf(stderr, "Internal error: %08x %08x\n", lc, lf);
+	    if(lc) fprintf(stderr, "                lc->depth = %08x\n", lc->p->depth);
+	    if(lf) fprintf(stderr, "                lf->depth = %08x\n", lf->p->depth);
+	}
+
+        if(l->p->depth <= clipdepth) {
             if(DEBUG&2) printf("(clipped)");
-            l = l->next;
-            continue;
+	    continue;
         }
         if(l->fillid < 0 /*clip*/) {
             if(DEBUG&2) printf("(add clip %d)", l->clipdepth);
@@ -682,7 +802,6 @@ static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*state
                 }
             }
         }
-        l = l->next;
     }
 }
 
@@ -817,16 +936,17 @@ RGBA* swf_Render(RENDERBUF*dest)
     for(y=0;y<i->height2;y++) {
         TAG*tag = i->lines[y].points;
         int n;
-        int size = sizeof(renderpoint_t);
-        int num = tag->len / size;
+        int num = renderpoint_num(tag);
+	renderpoint_t*points = renderpoint_readall(tag);
         RGBA*line = line1;
-	state_t state;
-        memset(&state, 0, sizeof(state_t));
+	state_t clipstate;
+	state_t fillstate;
+        memset(&clipstate, 0, sizeof(state_t));
+        memset(&fillstate, 0, sizeof(state_t));
 
         if((y&1) && i->antialize)
             line = line2;
 
-
 	if(!i->background) {
 	    memset(line, 0, sizeof(RGBA)*i->width2);
 	} else {
@@ -838,10 +958,10 @@ RGBA* swf_Render(RENDERBUF*dest)
 	    }
 	}
         memory += tag->memsize;
-        qsort(tag->data, num, size, compare_renderpoints);
+        qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
         for(n=0;n<num;n++) {
-            renderpoint_t*p = (renderpoint_t*)&tag->data[size*n];
-            renderpoint_t*next= n<num-1?(renderpoint_t*)&tag->data[size*(n+1)]:0;
+            renderpoint_t*p = &points[n];
+            renderpoint_t*next= n<num-1?&points[n+1]:0;
             int startx = p->x;
             int endx = next?next->x:i->width2;
             if(endx > i->width2)
@@ -849,13 +969,17 @@ RGBA* swf_Render(RENDERBUF*dest)
             if(startx < 0)
                 startx = 0;
 
-            change_state(y, &state, p);
+	    if(p->type == clip_type)
+		change_state(y, &clipstate, p);
+	    else
+		change_state(y, &fillstate, p);
 
-            fill(dest, line, y, startx, endx, &state);
+            fill(dest, line, y, startx, endx, &clipstate, &fillstate);
             if(endx == i->width2)
                 break;
         }
-        free_layers(&state);
+        free_layers(&clipstate);
+        free_layers(&fillstate);
         if(DEBUG&2) printf("\n");
 
         if(!i->antialize) {
@@ -876,9 +1000,12 @@ RGBA* swf_Render(RENDERBUF*dest)
                 }
             }
         }
+	free(points);
     }
     free(line1);
     free(line2);
+
+#define MEMORY
     
     if(DEBUG) printf("\nMemory used: %d\n", memory);
 #ifdef STATISTICS
@@ -889,3 +1016,109 @@ RGBA* swf_Render(RENDERBUF*dest)
 
     return img;
 }
+
+typedef struct
+{
+    TAG*tag;
+    SRECT*bbox;
+    enum {none_type, shape_type, image_type, text_type, font_type} type;
+    union {
+        SHAPE2*shape;
+        SWFFONT*font;
+    };
+} character_t;
+
+void swf_RenderSWF(RENDERBUF*buf, SWF*swf)
+{
+    TAG*tag;
+    int t;
+
+    character_t* idtable = rfx_calloc(sizeof(character_t)*65536);            // id to character mapping
+    SWFPLACEOBJECT** depthtable = rfx_calloc(sizeof(SWFPLACEOBJECT*)*65536); // depth to placeobject mapping
+
+    /* set background color */
+    RGBA color = swf_GetSWFBackgroundColor(swf);
+    swf_Render_SetBackgroundColor(buf, color);
+
+    /* parse definitions */
+    tag = swf->firstTag;
+    while(tag) {
+        if(swf_isDefiningTag(tag)) {
+            int id = swf_GetDefineID(tag);
+            idtable[id].tag = tag;
+            idtable[id].bbox = rfx_alloc(sizeof(SRECT));
+            *idtable[id].bbox = swf_GetDefineBBox(tag);
+
+            if(swf_isShapeTag(tag)) {
+                SHAPE2* shape = rfx_calloc(sizeof(SHAPE2));
+                swf_ParseDefineShape(tag, shape);
+                idtable[id].type = shape_type;
+                idtable[id].shape = shape;
+            } else if(swf_isImageTag(tag)) {
+		int width,height;
+                RGBA*data = swf_ExtractImage(tag, &width, &height);
+                idtable[id].type = image_type;
+                swf_Render_AddImage(buf, id, data, width, height);
+		free(data);
+            } else if(tag->id == ST_DEFINEFONT ||
+                      tag->id == ST_DEFINEFONT2) {
+                //swf_FontExtract(swf,id,&idtable[id].font);
+                idtable[id].font = 0;
+            } else if(tag->id == ST_DEFINEFONTINFO ||
+                      tag->id == ST_DEFINEFONTINFO2) {
+                idtable[id].type = font_type;
+            } else if(tag->id == ST_DEFINETEXT ||
+                      tag->id == ST_DEFINETEXT2) {
+                idtable[id].type = text_type;
+            }
+        } else if(tag->id == ST_PLACEOBJECT || 
+                  tag->id == ST_PLACEOBJECT2) {
+            SWFPLACEOBJECT* p = rfx_calloc(sizeof(SWFPLACEOBJECT));
+            swf_GetPlaceObject(tag, p);
+            /* TODO: add move and deletion */
+            depthtable[p->depth] = p;
+        }
+        tag = tag->next;
+    }
+      
+    for(t=65535;t>=0;t--) if(depthtable[t]) {
+        SWFPLACEOBJECT*p = depthtable[t];
+        int id = p->id;
+            
+        if(!idtable[id].tag) { 
+            fprintf(stderr, "rfxswf: Id %d is unknown\n", id);
+            continue;
+        }
+
+        if(idtable[id].type == shape_type) {
+            SRECT sbbox = swf_TurnRect(*idtable[id].bbox, &p->matrix);
+            swf_RenderShape(buf, idtable[id].shape, &p->matrix, &p->cxform, p->depth, p->clipdepth);
+        } else if(idtable[id].type == text_type) {
+	    /* TODO */
+        } else {
+            fprintf(stderr, "Unknown/Unsupported Object Type for id %d: %s\n", id, swf_TagGetName(idtable[id].tag));
+        }
+    }
+
+    /* free id and depth tables again */
+    for(t=0;t<65536;t++) {
+        if(idtable[t].bbox) {
+            free(idtable[t].bbox);
+            idtable[t].bbox=0;
+        }
+        if(idtable[t].type == shape_type) {
+            SHAPE2* shape = idtable[t].shape;
+            if(shape) {
+                swf_Shape2Free(shape); // FIXME
+                free(idtable[t].shape);idtable[t].shape = 0;
+            }
+        }
+        if(depthtable[t]) {
+            swf_PlaceObjectFree(depthtable[t]);
+            free(depthtable[t]);depthtable[t] = 0;
+        }
+    }
+    free(idtable);
+    free(depthtable);
+}
+