X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fpython%2Ftags.c;h=ca49a25d837dce9ac1c5a6dfe0760044dc221754;hp=f1b69a9e15720d94551165a73f2477f5b4d8186b;hb=6f78b0ef3998e959ce09c5ef11d46149756b682b;hpb=140703ead0d966025a0bad957356e3ad4908b0c8

diff --git a/lib/python/tags.c b/lib/python/tags.c
index f1b69a9..ca49a25 100644
--- a/lib/python/tags.c
+++ b/lib/python/tags.c
@@ -5,6 +5,7 @@
 #include "tag.h"
 #include "tags.h"
 #include "image.h"
+#include "../png.h"
 
 //----------------------------------------------------------------------------
 
@@ -48,7 +49,7 @@ static PyObject* f_DefineFont(PyObject* self, PyObject* args, PyObject* kwargs)
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwlist, &filename))
 	return NULL;
 
-    font = swf_LoadFont(filename);
+    font = swf_LoadFont(filename, 0);
     if(!font) {
 	PyErr_SetString(PyExc_Exception, setError("Could not load %s", filename));
 	return NULL;
@@ -83,6 +84,7 @@ static tag_internals_t font_tag =
 typedef struct _placeobject_internal
 {
     SWFPLACEOBJECT* po;
+    PyObject*character;
 } placeobject_internal_t;
 staticforward tag_internals_t placeobject_tag;
 
@@ -96,10 +98,25 @@ static void po_dealloc(tag_internals_t*self)
 }
 static int po_parse(tag_internals_t*self)
 {
-    placeobject_internal_t*pi = (placeobject_internal_t*)self->data;
-    /* TODO */
-    PyErr_SetString(PyExc_Exception, setError("Font parsing not implemented yet"));
-    return 0;
+    placeobject_internal_t*i = (placeobject_internal_t*)self->data;
+    if(i->po)
+	return 1;
+    if(!self->tag)
+	return 0;
+    SWFPLACEOBJECT* swfpo = malloc(sizeof(SWFPLACEOBJECT));
+    swf_GetPlaceObject(self->tag, swfpo);
+    i->po = swfpo;
+    swf_DeleteTag(0, self->tag);self->tag = 0;
+	
+    if(i->po->id) {
+	i->character = tagmap_id2obj(self->tagmap, i->po->id);
+	if(i->character) {
+	    Py_INCREF(i->character);
+	} else {
+	    //PyErr_Clear(); //?
+	}
+    }
+    return 1;
 }
 static int po_fillTAG(tag_internals_t*self)
 {
@@ -108,6 +125,33 @@ static int po_fillTAG(tag_internals_t*self)
     swf_SetPlaceObject(self->tag, pi->po);
     return 1;
 }
+static PyObject* po_getattr(tag_internals_t*self,char*a)
+{
+    placeobject_internal_t*i = (placeobject_internal_t*)self->data;
+    if(!po_parse(self))
+	return PY_ERROR("Couldn't parse placeobject");
+    if(!strcmp(a, "character")) {
+	if(!i->character)
+	    return PY_NONE;
+	Py_INCREF(i->character); //TODO: ??
+	return i->character;
+    } else if(!strcmp(a, "matrix")) {
+	return f_Matrix2(&i->po->matrix);
+    } else if(!strcmp(a, "cxform")) {
+	/* TODO */
+	return 0;
+    }
+    return 0;
+}
+static int po_setattr(tag_internals_t*self,char*a, PyObject*obj)
+{
+    placeobject_internal_t*si = (placeobject_internal_t*)self->data;
+    if(!strcmp(a, "cxform")) {
+	/* TODO */
+	return 0;
+    }
+    return -1;
+}
 static PyObject* po_create(PyObject* self, PyObject* args, PyObject* kwargs,char move)
 {
     static char *kwlist[] = {"character", "depth", "matrix", "colortransform", "ratio", "name", "clipdepth", "action", NULL};
@@ -177,8 +221,8 @@ static tag_internals_t placeobject_tag =
     parse: po_parse,
     fillTAG: po_fillTAG,
     dealloc: po_dealloc,
-    getattr: 0, 
-    setattr: 0,
+    getattr: po_getattr, 
+    setattr: po_setattr,
     tagfunctions: 0,
     datasize: sizeof(placeobject_internal_t),
 };
@@ -376,7 +420,7 @@ static int sprite_setattr(tag_internals_t*self,char*a, PyObject*obj)
 {
     sprite_internal_t*si = (sprite_internal_t*)self->data;
     if(self->tag) {
-	swf_DeleteTag(self->tag);
+	swf_DeleteTag(0, self->tag);
 	self->tag = 0;
     }
     if(!strcmp(a, "tags")) {
@@ -516,6 +560,22 @@ static void image_dealloc(tag_internals_t*self)
 	free(pi->rgba);pi->rgba = 0;
     }
 }
+static int image_parse(tag_internals_t*self)
+{
+    image_internal_t*i= (image_internal_t*)self->data;
+    if(i->rgba)
+	return 1;
+    if(!self->tag)
+	return 0;
+   
+    i->rgba = swf_ExtractImage(self->tag, &i->width, &i->height);
+    i->bpp = 32;
+    i->isindexed = 0;
+    i->islossless = 1;
+
+    swf_DeleteTag(0, self->tag);self->tag = 0;
+    return 1;
+}
 static int imagetag_getWidth(PyObject* self)
 {
     tag_internals_t*itag = tag_getinternals(self);
@@ -530,7 +590,7 @@ static int imagetag_getHeight(PyObject* self)
 }
 static PyObject* f_DefineImage(PyObject* self, PyObject* args, PyObject* kwargs)
 {
-    static char *kwlist[] = {"image"};
+    static char *kwlist[] = {"image", NULL};
     PyObject*image = 0;
     PyObject*tag = tag_new(&image_tag);
 
@@ -553,14 +613,48 @@ static PyObject* f_DefineImage(PyObject* self, PyObject* args, PyObject* kwargs)
 
     return (PyObject*)tag;
 }
+static PyObject* image_getattr(tag_internals_t*self,char*a)
+{
+    image_internal_t*i = (image_internal_t*)self->data;
+    if(!strcmp(a, "image")) {
+	if(!i->rgba) {
+	    image_parse(self);
+	}
+	PyObject* image = rgba_to_image(i->rgba, i->width, i->height);
+	return image;
+    }
+    return 0;
+}
+
+static PyObject* image_save(PyObject*self, PyObject*args)
+{
+    tag_internals_t*itag = tag_getinternals(self);
+    if(!image_parse(itag))
+	return PY_ERROR("Couldn't parse image");
+    image_internal_t*fi = (image_internal_t*)itag->data;
+   
+    char*filename = 0;
+    if(!PyArg_ParseTuple(args, "s", &filename))
+	return NULL;
+
+    png_write(filename, (unsigned char*)fi->rgba ,fi->width, fi->height);
+    
+    return PY_NONE;
+}
+
+static PyMethodDef image_methods[] = 
+{{"save", image_save, METH_VARARGS, "saves an image as PNG"},
+ {NULL, NULL, 0, NULL}
+};
+
 static tag_internals_t image_tag =
 {
-    parse: 0,
+    parse: image_parse,
     fillTAG: image_fillTAG,
     dealloc: image_dealloc,
-    getattr: 0, 
+    getattr: image_getattr, 
     setattr: 0,
-    tagfunctions: 0,
+    tagfunctions: image_methods,
     datasize: sizeof(image_internal_t),
 };
 //----------------------------------------------------------------------------
@@ -568,7 +662,7 @@ staticforward tag_internals_t shape_tag;
 
 typedef struct _shape_internal
 {
-    SHAPE2*shape;
+    SHAPE2*shape2;
 } shape_internal_t;
 staticforward tag_internals_t shape_tag;
 
@@ -577,31 +671,42 @@ static int shape_fillTAG(tag_internals_t*self)
     shape_internal_t*ti = (shape_internal_t*)self->data;
     self->tag= swf_InsertTag(0, ST_DEFINESHAPE3);
     swf_SetU16(self->tag, /*ID*/0);
-    swf_SetShape2(self->tag, ti->shape);
+    swf_SetShape2(self->tag, ti->shape2);
+    return 1;
+}
+static int shape_parse(tag_internals_t*self)
+{
+    shape_internal_t*i= (shape_internal_t*)self->data;
+    if(i->shape2)
+	return 1;
+    if(!self->tag)
+	return 0;
+    SHAPE2* shape2 = malloc(sizeof(SHAPE2));
+    swf_ParseDefineShape(self->tag, shape2);
+    i->shape2 = shape2;
+    swf_DeleteTag(0, self->tag);self->tag = 0;
     return 1;
 }
 static void shape_dealloc(tag_internals_t*self)
 {
     shape_internal_t*pi = (shape_internal_t*)self->data;
-    if(pi->shape) {
-	swf_Shape2Free(pi->shape);
-	pi->shape = 0;
+    if(pi->shape2) {
+	swf_Shape2Free(pi->shape2);
+	pi->shape2 = 0;
     }
 }
 static PyObject* f_DefineImageShape(PyObject* self, PyObject* args, PyObject* kwargs)
 {
-    static char *kwlist[] = {"image"};
-    PyObject*shape = 0;
-    PyObject*tag = tag_new(&shape_tag);
+    static char *kwlist[] = {"image", NULL};
     PyObject*image = 0;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist, &TagClass, &image))
 	return NULL;
     
-    tag = tag_new(&shape_tag);
+    PyObject*tag = tag_new(&shape_tag);
     tag_internals_t* itag = tag_getinternals(tag);
     shape_internal_t*ti = (shape_internal_t*)itag->data;
-    ti->shape = 0; /*HACK*/
+    ti->shape2 = 0; /*HACK*/
 
     int width = imagetag_getWidth(image);
     int height = imagetag_getHeight(image);
@@ -611,14 +716,179 @@ static PyObject* f_DefineImageShape(PyObject* self, PyObject* args, PyObject* kw
     swf_ShapeSetBitmapRect(itag->tag, id, width, height);
     return (PyObject*)tag;
 }
+
+/* TODO: move to lib/ */
+SHAPE2*swf_StringToShape2(char*s,FILLSTYLE*f, LINESTYLE*l)
+{
+    drawer_t draw;
+    swf_Shape11DrawerInit(&draw, 0);
+    draw_string(&draw, s);
+    draw.finish(&draw);
+    SHAPE*s1 =  swf_ShapeDrawerToShape(&draw);
+    SRECT r = swf_ShapeDrawerGetBBox(&draw);
+    RGBA col;col.r=col.g=col.b=128;col.a=255;
+    if(l) 
+	swf_ShapeAddLineStyle(s1, 1, &col);
+    if(f)
+	swf_ShapeAddSolidFillStyle(s1, &col);
+    draw.dealloc(&draw);
+    SHAPE2*shape2 = swf_ShapeToShape2(s1);
+    swf_ShapeFree(s1);
+    shape2->bbox = malloc(sizeof(SRECT));
+    *(shape2->bbox) = r;
+    if(f && shape2->numfillstyles)
+	shape2->fillstyles[0] = *f;
+    if(l && shape2->numlinestyles)
+	shape2->linestyles[0] = *l;
+    return shape2;
+}
+
+static PyObject* f_DefineShape(PyObject* self, PyObject* args, PyObject* kwargs)
+{
+    static char *kwlist[] = {"s", "fill", "line", NULL};
+    char*s = 0;
+    PyObject*fillstyle=0,*linestyle=0;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OO", kwlist, &s,&fillstyle,&linestyle))
+	return NULL;
+
+    PyObject*tag = tag_new(&shape_tag);
+    tag_internals_t* itag = tag_getinternals(tag);
+    shape_internal_t*ti = (shape_internal_t*)itag->data;
+    
+    FILLSTYLE _f,*f=0;
+    LINESTYLE _l,*l=0;
+
+    if(fillstyle) {
+	f = &_f;
+	if(PY_CHECK_TYPE(fillstyle, &ColorClass)) {
+	    f->type = /*FILL_SOLID*/ 0;
+	    f->color = color_getRGBA(fillstyle);
+	} else {
+	    return PY_ERROR("Invalid Fillstyle");
+	}
+    }
+
+    if(linestyle) {
+	l = &_l;
+	if(PyTuple_Check(linestyle) && PyTuple_GET_SIZE(linestyle)==2) {
+	    float f = 0.0;
+	    PyObject*color = 0;
+	    if(!PyArg_ParseTuple(linestyle, "fO!", &f, &ColorClass, &color))
+		return 0;
+
+	    l->width = (int)(f*20);
+	    l->color = color_getRGBA(color);
+	} else {
+	    return PY_ERROR("Invalid Linestyle");
+	}
+    }
+    ti->shape2 = swf_StringToShape2(s,f,l);
+
+    itag->tag = 0;
+    
+    return (PyObject*)tag;
+}
+static PyObject* shape_getfillstyles(PyObject*self, PyObject*args)
+{
+    tag_internals_t*itag = tag_getinternals(self);
+    if(!shape_parse(itag))
+	return PY_ERROR("Couldn't parse shape");
+    shape_internal_t*fi = (shape_internal_t*)itag->data;
+    int num = fi->shape2->numfillstyles;
+    return Py_BuildValue("i", num);
+}
+static PyObject* shape_getlinestyles(PyObject*self, PyObject*args)
+{
+    tag_internals_t*itag = tag_getinternals(self);
+    if(!shape_parse(itag))
+	return PY_ERROR("Couldn't parse shape");
+    shape_internal_t*fi = (shape_internal_t*)itag->data;
+    int num = fi->shape2->numlinestyles;
+    return Py_BuildValue("i", num);
+}
+static PyObject* shape_getfillstyle(PyObject*self, PyObject*args)
+{
+    tag_internals_t*itag = tag_getinternals(self);
+    if(!shape_parse(itag))
+	return PY_ERROR("Couldn't parse shape");
+    shape_internal_t*fi = (shape_internal_t*)itag->data;
+    int nr = 0;
+    if(!PyArg_ParseTuple(args, "i", &nr))
+	return NULL;
+    
+    int num = fi->shape2->numfillstyles;
+    if(nr < 0 || nr >=num)
+	return PY_ERROR("fillstyle index out of range");
+    return f_FillStyle2(fi->shape2->fillstyles[nr]);
+}
+static PyObject* shape_getlinestyle(PyObject*self, PyObject*args)
+{
+    tag_internals_t*itag = tag_getinternals(self);
+    if(!shape_parse(itag))
+	return PY_ERROR("Couldn't parse shape");
+    shape_internal_t*fi = (shape_internal_t*)itag->data;
+    int nr = 0;
+    if(!PyArg_ParseTuple(args, "i", &nr))
+	return NULL;
+    
+    int num = fi->shape2->numfillstyles;
+    if(nr < 0 || nr >=num)
+	return PY_ERROR("fillstyle index out of range");
+    return f_LineStyle3(fi->shape2->linestyles[nr]);
+}
+static PyObject* shape_setfillstyle(PyObject*self, PyObject*args)
+{
+    tag_internals_t*itag = tag_getinternals(self);
+    if(!shape_parse(itag))
+	return PY_ERROR("Couldn't parse shape");
+    shape_internal_t*fi = (shape_internal_t*)itag->data;
+    int nr = 0;
+    PyObject*fs = 0;
+    if(!PyArg_ParseTuple(args, "iO!", &nr, &FillStyleClass, &fs))
+	return NULL;
+    
+    int num = fi->shape2->numfillstyles;
+    if(nr < 0 || nr >=num)
+	return PY_ERROR("fillstyle index out of range");
+    fi->shape2->fillstyles[nr] = fillstyle_getFillStyle(fs);
+    return PY_NONE;
+}
+static PyObject* shape_setlinestyle(PyObject*self, PyObject*args)
+{
+    tag_internals_t*itag = tag_getinternals(self);
+    if(!shape_parse(itag))
+	return PY_ERROR("Couldn't parse shape");
+    shape_internal_t*fi = (shape_internal_t*)itag->data;
+    int nr = 0;
+    PyObject*ls = 0;
+    if(!PyArg_ParseTuple(args, "iO!", &nr, &LineStyleClass, &ls))
+	return NULL;
+    
+    int num = fi->shape2->numlinestyles;
+    if(nr < 0 || nr >=num)
+	return PY_ERROR("linestyle index out of range");
+    fi->shape2->linestyles[nr] = linestyle_getLineStyle(ls);
+    return PY_NONE;
+}
+static PyMethodDef shape_methods[] = 
+{{"numfillstyles", shape_getfillstyles, METH_VARARGS, "get's the number of fillstyles"},
+ {"numlinestyles", shape_getlinestyles, METH_VARARGS, "get's the number of linestyles"},
+ {"getfillstyle", shape_getfillstyle, METH_VARARGS, "get's one fillstyle"},
+ {"getlinestyle", shape_getlinestyle, METH_VARARGS, "get's one linestyle"},
+ {"setfillstyle", shape_setfillstyle, METH_VARARGS, "set's one fillstyle"},
+ {"setlinestyle", shape_setlinestyle, METH_VARARGS, "set's one linestyle"},
+ {NULL, NULL, 0, NULL}
+};
+
 static tag_internals_t shape_tag =
 {
-    parse: 0,
+    parse: shape_parse,
     fillTAG: shape_fillTAG,
     dealloc: shape_dealloc,
     getattr: 0, 
     setattr: 0,
-    tagfunctions: 0,
+    tagfunctions: shape_methods,
     datasize: sizeof(shape_internal_t),
 };
 //----------------------------------------------------------------------------
@@ -726,10 +996,10 @@ static PyObject* videostream_addFrame(PyObject*self, PyObject*args, PyObject*kwa
     static char *kwlist[] = {"image", "quant", "type", NULL};
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|is", kwlist, &image, &quant, &type))
 	return NULL;
-    if(fi->stream->width != image_getWidth(image)) {
+    if(fi->stream->owidth != image_getWidth(image)) {
 	PyErr_SetString(PyExc_Exception, setError("bad image width %d!=%d", image_getWidth(image), fi->stream->width));return 0;
     }
-    if(fi->stream->height != image_getHeight(image)) {
+    if(fi->stream->oheight != image_getHeight(image)) {
 	PyErr_SetString(PyExc_Exception, setError("bad image width %d!=%d", image_getHeight(image), fi->stream->height));return 0;
     }
     PyObject*tag = tag_new(&videoframe_tag);
@@ -910,7 +1180,6 @@ static tag_internals_t videoframe_tag =
 };
 
 //============================================================================
-
 static PyMethodDef TagMethods[] = 
 {
     /* TAGS */
@@ -924,8 +1193,10 @@ static PyMethodDef TagMethods[] =
     {"VideoStream", (PyCFunction)f_DefineVideoStream, METH_KEYWORDS, "Create a Videostream."},
     {"Image", (PyCFunction)f_DefineImage, METH_KEYWORDS, "Create an SWF Image Tag."},
     {"ImageShape", (PyCFunction)f_DefineImageShape, METH_KEYWORDS, "Create an SWF Image Shape Tag."},
+    {"Shape", (PyCFunction)f_DefineShape, METH_KEYWORDS, "Create an SWF Shape Tag."},
     {"ShowFrame", (PyCFunction)f_ShowFrame, METH_KEYWORDS, "Create an SWF Show Frame Tag."},
     {"Sprite", (PyCFunction)f_Sprite, METH_KEYWORDS, "Create an SWF Sprite Tag."},
+    
     {NULL, NULL, 0, NULL}
 };
 PyMethodDef* tags_getMethods()
@@ -945,6 +1216,9 @@ PyMethodDef* tags_getMethods()
     register_tag(ST_DEFINEBITSJPEG3,&image_tag);
     register_tag(ST_DEFINEBITSLOSSLESS,&image_tag);
     register_tag(ST_DEFINEBITSLOSSLESS2,&image_tag);
+    register_tag(ST_DEFINESHAPE,&shape_tag);
+    register_tag(ST_DEFINESHAPE2,&shape_tag);
+    register_tag(ST_DEFINESHAPE3,&shape_tag);
     register_tag(ST_SHOWFRAME,&showframe_tag);
     register_tag(ST_DEFINEVIDEOSTREAM,&videostream_tag);
     register_tag(ST_VIDEOFRAME,&videoframe_tag);