lib/python/tags.c

   1 #include "pyutils.h"
   2 #include "primitives.h"
   3 #include "action.h"
   4 #include "tag.h"
   5 #include "tags.h"
   6 #include "image.h"
   7
   8 //----------------------------------------------------------------------------
   9
  10 typedef struct _font_internal
  11 {
  12     SWFFONT* font;
  13 } font_internal_t;
  14 staticforward tag_internals_t font_tag;
  15
  16 static int font_parse(tag_internals_t*self)
  17 {
  18     font_internal_t*font = (font_internal_t*)self->data;
  19     /* TODO */
  20     PyErr_SetString(PyExc_Exception, setError("Font parsing not implemented yet"));
  21     return 0;
  22 }
  23 static void font_dealloc(tag_internals_t*self)
  24 {
  25     font_internal_t*font = (font_internal_t*)self->data;
  26     if(font->font) {
  27         swf_FontFree(font->font);
  28         font->font = 0;
  29     }
  30 }
  31 static int font_fillTAG(tag_internals_t*self)
  32 {
  33     font_internal_t*fi = (font_internal_t*)self->data;
  34     if(self->tag)
  35         return 1;
  36     self->tag = swf_InsertTag(0, ST_DEFINEFONT2);
  37     swf_FontSetDefine2(self->tag, fi->font);
  38     return 1;
  39 }
  40 static PyObject* f_DefineFont(PyObject* self, PyObject* args, PyObject* kwargs)
  41 {
  42     static char *kwlist[] = {"filename", NULL};
  43     char*filename = 0;
  44     PyObject*tag;
  45     SWFFONT* font;
  46
  47     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwlist, &filename))
  48         return NULL;
  49
  50     font = swf_LoadFont(filename);
  51     if(!font) {
  52         PyErr_SetString(PyExc_Exception, setError("Could not load %s", filename));
  53         return NULL;
  54     }
  55
  56     tag = tag_new(&font_tag);
  57     tag_internals_t*itag = tag_getinternals(tag);
  58     font_internal_t*fi = (font_internal_t*)itag->data;
  59     font->id = 0;
  60     fi->font = font;
  61     return (PyObject*)tag;
  62 }
  63 static SWFFONT* font_getSWFFONT(PyObject*self)
  64 {
  65     PY_ASSERT_TYPE(self, &TagClass);
  66     tag_internals_t*itag = tag_getinternals(self);
  67     font_internal_t*fi = (font_internal_t*)itag->data;
  68     return fi->font;
  69 }
  70 static tag_internals_t font_tag =
  71 {
  72     parse: font_parse,
  73     fillTAG: font_fillTAG,
  74     dealloc: font_dealloc,
  75     tagfunctions: 0,
  76     datasize: sizeof(font_internal_t),
  77 };
  78 //----------------------------------------------------------------------------
  79
  80 typedef struct _placeobject_internal
  81 {
  82     SWFPLACEOBJECT* po;
  83 } placeobject_internal_t;
  84 staticforward tag_internals_t placeobject_tag;
  85
  86 static void po_dealloc(tag_internals_t*self)
  87 {
  88     placeobject_internal_t*pi = (placeobject_internal_t*)self->data;
  89     if(pi->po) {
  90         swf_PlaceObjectFree(pi->po);
  91         pi->po = 0;
  92     }
  93 }
  94 static int po_parse(tag_internals_t*self)
  95 {
  96     placeobject_internal_t*pi = (placeobject_internal_t*)self->data;
  97     /* TODO */
  98     PyErr_SetString(PyExc_Exception, setError("Font parsing not implemented yet"));
  99     return 0;
 100 }
 101 static int po_fillTAG(tag_internals_t*self)
 102 {
 103     placeobject_internal_t*pi = (placeobject_internal_t*)self->data;
 104     self->tag = swf_InsertTag(0, ST_PLACEOBJECT2);
 105     swf_SetPlaceObject(self->tag, pi->po);
 106     return 1;
 107 }
 108 static PyObject* f_PlaceObject(PyObject* self, PyObject* args, PyObject* kwargs)
 109 {
 110     static char *kwlist[] = {"character", "depth", "matrix", "colortransform", "ratio", "name", "clipdepth", "action", NULL};
 111
 112     PyObject*character = 0;
 113     int depth;
 114     int clipdepth = 0;
 115     PyObject*matrix = 0;
 116     PyObject*cxform = 0;
 117     PyObject*action = 0;
 118     int ratio = 0;
 119     char* name = 0;
 120     SWFPLACEOBJECT* po;
 121     po = malloc(sizeof(SWFPLACEOBJECT));
 122     memset(po, 0, sizeof(SWFPLACEOBJECT));
 123
 124     swf_GetPlaceObject(0, po);
 125
 126     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi|O!O!isiO!", kwlist,
 127                 &character,
 128                 &depth,
 129                 &MatrixClass, &matrix,
 130                 &CXFormClass, &cxform,
 131                 &ratio,
 132                 &name,
 133                 &clipdepth,
 134                 &ActionClass, &action
 135                 ))
 136         return NULL;
 137     po->depth = depth;
 138     po->id = /*ID*/ 0;
 139     po->clipdepth = clipdepth;
 140     po->ratio = ratio;
 141     po->name = name;
 142     if(clipdepth) po->clipdepth = clipdepth;
 143     if(matrix) po->matrix = matrix_getMatrix(matrix);
 144     if(cxform) po->cxform = colortransform_getCXForm(cxform);
 145     if(action) po->actions = action_getAction(action);
 146
 147     PyObject*tag;
 148     tag = tag_new(&placeobject_tag);
 149     tag_internals_t*itag = tag_getinternals(tag);
 150     placeobject_internal_t*pi = (placeobject_internal_t*)itag->data;
 151     pi->po = po;
 152     pi->po->id = tagmap_add(itag->tagmap,(PyObject*)character);
 153
 154     mylog("+%08x(%d) PlaceObject %08x(%d)\n", (int)tag, tag->ob_refcnt, character, character->ob_refcnt);
 155
 156     return (PyObject*)tag;
 157 }
 158 static tag_internals_t placeobject_tag =
 159 {
 160     parse: po_parse,
 161     fillTAG: po_fillTAG,
 162     dealloc: po_dealloc,
 163     tagfunctions: 0,
 164     datasize: sizeof(placeobject_internal_t),
 165 };
 166 //----------------------------------------------------------------------------
 167 staticforward tag_internals_t bgcolor_tag;
 168 static PyObject* tag_setbackgroundcolor_getrgb(PyObject * self, PyObject*other)
 169 {
 170     tag_internals_t*itag = tag_getinternals(self);
 171     int r,g,b;
 172     r = itag->tag->data[0];
 173     g = itag->tag->data[1];
 174     b = itag->tag->data[2];
 175     return Py_BuildValue("(iii)", r,g,b);
 176 }
 177 static PyMethodDef setbgcolor_methods[] =
 178 {{"getRGB", tag_setbackgroundcolor_getrgb, METH_VARARGS, "get's the color set by this tag"},
 179  {NULL, NULL, 0, NULL}
 180 };
 181 static PyObject* f_SetBackgroundColor(PyObject* self, PyObject* args, PyObject* kwargs)
 182 {
 183     static char *kwlist[] = {"color", NULL};
 184     int r=0,g=0,b=0;
 185     PyObject*tag;
 186     PyObject*color;
 187
 188     tag = tag_new(&bgcolor_tag);
 189     tag_internals_t*itag = tag_getinternals(tag);
 190
 191     /* 1st try- copy constructor */
 192     if(!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist, &ColorClass, &color)) {
 193         PyErr_Clear();
 194         /* 2nd try- color's contructor */
 195         color = f_Color(NULL, args, kwargs);
 196     }
 197     if(!color)
 198         return NULL;
 199
 200     itag->tag = swf_InsertTag(0, ST_SETBACKGROUNDCOLOR);
 201     RGBA rgba = color_getRGBA(color);
 202     swf_SetU8(itag->tag, rgba.r);
 203     swf_SetU8(itag->tag, rgba.g);
 204     swf_SetU8(itag->tag, rgba.b);
 205     mylog(" %08x(%d) SetBackgroundColor(%02x,%02x,%02x) (colorobj=%08x(%d))\n", (int)tag, tag->ob_refcnt, rgba.r, rgba.g, rgba.b, color, color->ob_refcnt);
 206     Py_DECREF(color);
 207     return (PyObject*)tag;
 208 }
 209 static tag_internals_t bgcolor_tag =
 210 {
 211     parse: 0,
 212     fillTAG: 0,
 213     dealloc: 0,
 214     tagfunctions: setbgcolor_methods,
 215     datasize: 0,
 216 };
 217 //----------------------------------------------------------------------------
 218 staticforward tag_internals_t protect_tag;
 219 static PyObject* f_Protect(PyObject* self, PyObject* args, PyObject* kwargs)
 220 {
 221     static char *kwlist[] = {"password", NULL};
 222     char*password = 0;
 223
 224     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwlist, &password))
 225         return NULL;
 226
 227     PyObject*tag = tag_new(&protect_tag);
 228     tag_internals_t*itag = tag_getinternals(tag);
 229     itag->tag = swf_InsertTag(0, ST_PROTECT);
 230     if(password) {
 231         swf_SetPassword(itag->tag, password);
 232     }
 233     mylog("+%08x(%d) f_Protect", (int)tag, tag->ob_refcnt);
 234     return (PyObject*)tag;
 235 }
 236 static tag_internals_t protect_tag =
 237 {
 238     parse: 0,
 239     fillTAG: 0,
 240     dealloc: 0,
 241     tagfunctions: 0,
 242     datasize: 0,
 243 };
 244 //----------------------------------------------------------------------------
 245 staticforward tag_internals_t end_tag;
 246 static tag_internals_t end_tag =
 247 {
 248     parse: 0,
 249     fillTAG: 0,
 250     dealloc: 0,
 251     tagfunctions: 0,
 252     datasize: 0,
 253 };
 254 //----------------------------------------------------------------------------
 255 staticforward tag_internals_t text_tag;
 256
 257 typedef struct _text_internal
 258 {
 259     char*text;
 260     SWFFONT* swffont;
 261     RGBA rgba;
 262     int size;
 263 } text_internal_t;
 264 staticforward tag_internals_t placeobject_tag;
 265
 266 static int text_fillTAG(tag_internals_t*self)
 267 {
 268     text_internal_t*ti = (text_internal_t*)self->data;
 269     self->tag= swf_InsertTag(0, ST_DEFINETEXT2);
 270     swf_SetU16(self->tag, /*ID*/0);
 271     SRECT r = swf_SetDefineText(self->tag, ti->swffont, &ti->rgba, ti->text, ti->size);
 272     return 1;
 273 }
 274 static PyObject* f_DefineText(PyObject* self, PyObject* args, PyObject* kwargs)
 275 {
 276     static char *kwlist[] = {"font", "text", "size", "color", NULL};
 277     PyObject*tag = 0;
 278     char*text = 0;
 279     int textlen = 0;
 280     PyObject*unicode16;
 281     PyObject*unicode8;
 282     int size = 0;
 283     RGBA rgba = {255,0,0,0};
 284     PyObject*color = 0;
 285     PyObject*font = 0;
 286
 287     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!u#i|O!", kwlist, &TagClass, &font, &text, &textlen, &size, &ColorClass, &color))
 288         return NULL;
 289
 290     unicode16 = PyUnicode_DecodeUTF16(text, textlen*2, NULL, NULL);
 291     unicode8 = PyUnicode_AsUTF8String(unicode16);
 292     text = PyString_AS_STRING(unicode8);
 293
 294     if(color)
 295         rgba = color_getRGBA(color);
 296
 297     mylog("DefineText: text = %s", text);
 298
 299     tag = tag_new(&text_tag);
 300     tag_internals_t* itag = tag_getinternals(tag);
 301     text_internal_t*ti = (text_internal_t*)itag->data;
 302
 303     ti->swffont = font_getSWFFONT(font);
 304     int font_id = tagmap_add(itag->tagmap, font); // add dependency on font
 305     ti->swffont->id = font_id; // for swf_SetDefineTexts
 306     ti->text = strdup(text);
 307     ti->rgba = rgba;
 308     ti->size = size;
 309
 310     return (PyObject*)tag;
 311 }
 312 static tag_internals_t text_tag =
 313 {
 314     parse: 0,
 315     fillTAG: text_fillTAG,
 316     dealloc: 0,
 317     tagfunctions: 0,
 318     datasize: sizeof(text_internal_t),
 319 };
 320 //----------------------------------------------------------------------------
 321
 322 typedef struct _videostream_internal
 323 {
 324     VIDEOSTREAM* stream;
 325     int lastiframe;
 326 } videostream_internal_t;
 327 staticforward tag_internals_t videostream_tag;
 328 staticforward tag_internals_t videoframe_tag;
 329
 330 static int videostream_parse(tag_internals_t*self)
 331 {
 332     videostream_internal_t*videostream = (videostream_internal_t*)self->data;
 333     /* TODO */
 334     PyErr_SetString(PyExc_Exception, setError("videostream parsing not implemented yet"));
 335     return 0;
 336 }
 337 static void videostream_dealloc(tag_internals_t*self)
 338 {
 339     videostream_internal_t*videostream = (videostream_internal_t*)self->data;
 340     if(videostream->stream) {
 341         swf_VideoStreamClear(videostream->stream);
 342         free(videostream->stream);
 343         videostream->stream = 0;
 344     }
 345 }
 346 static int videostream_fillTAG(tag_internals_t*self)
 347 {
 348     videostream_internal_t*fi = (videostream_internal_t*)self->data;
 349     if(self->tag)
 350         return 1;
 351     /* TODO */
 352     PyErr_SetString(PyExc_Exception, setError("videostream filling not implemented yet"));return 0;
 353     return 1;
 354 }
 355 static PyObject* f_DefineVideoStream(PyObject* self, PyObject* args, PyObject* kwargs)
 356 {
 357     PyObject*tag = tag_new(&videostream_tag);
 358
 359     int width=0,height=0,frames=65535;
 360     static char *kwlist[] = {"width", "height", "frames", NULL};
 361     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|i", kwlist, &TagClass, &width, &height, &frames))
 362         return NULL;
 363
 364     tag_internals_t*itag = tag_getinternals(tag);
 365     videostream_internal_t*fi = (videostream_internal_t*)itag->data;
 366     fi->stream = malloc(sizeof(VIDEOSTREAM));
 367     memset(fi->stream, 0, sizeof(VIDEOSTREAM));
 368
 369     TAG*t = swf_InsertTag(0, ST_DEFINEVIDEOSTREAM);
 370     swf_SetVideoStreamDefine(t, fi->stream, frames, width, height);
 371     fi->lastiframe = -65536;
 372     return (PyObject*)tag;
 373 }
 374 static VIDEOSTREAM* videostream_getVIDEOSTREAM(PyObject*self)
 375 {
 376     PY_ASSERT_TYPE(self, &TagClass);
 377     tag_internals_t*itag = tag_getinternals(self);
 378     videostream_internal_t*fi = (videostream_internal_t*)itag->data;
 379     return fi->stream;
 380 }
 381 static PyObject* videostream_getbwidth(PyObject*self, PyObject*args)
 382 {
 383     tag_internals_t*itag = tag_getinternals(self);
 384     videostream_internal_t*fi = (videostream_internal_t*)itag->data;
 385     int width = fi->stream->bbx;
 386     return Py_BuildValue("i", width);
 387 }
 388 static PyObject* videostream_getbheight(PyObject*self, PyObject*args)
 389 {
 390     tag_internals_t*itag = tag_getinternals(self);
 391     videostream_internal_t*fi = (videostream_internal_t*)itag->data;
 392     int height = fi->stream->bby;
 393     return Py_BuildValue("i", height);
 394 }
 395 static PyObject* videostream_addFrame(PyObject*self, PyObject*args, PyObject*kwargs)
 396 {
 397     tag_internals_t*_itag = tag_getinternals(self);
 398     videostream_internal_t*fi = (videostream_internal_t*)_itag->data;
 399
 400     PyObject*image = 0;
 401     char*type=0; // none, "i", "p"
 402     int quant=7;
 403     static char *kwlist[] = {"image", "quant", "type", NULL};
 404     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|is", kwlist, &image, &quant, &type))
 405         return NULL;
 406     if(fi->stream->width != image_getWidth(image)) {
 407         PyErr_SetString(PyExc_Exception, setError("bad image width %d!=%d", image_getWidth(image), fi->stream->width));return 0;
 408     }
 409     if(fi->stream->height != image_getHeight(image)) {
 410         PyErr_SetString(PyExc_Exception, setError("bad image width %d!=%d", image_getHeight(image), fi->stream->height));return 0;
 411     }
 412     PyObject*tag = tag_new(&videoframe_tag);
 413     tag_internals_t*itag = tag_getinternals(tag);
 414
 415     RGBA*pic = image_toRGBA(image);
 416     TAG* t = swf_InsertTag(0, ST_VIDEOFRAME);
 417     if((type && (type[0]=='I' || type[0]=='i')) || (type==0 && fi->lastiframe+64 < fi->stream->frame)) {
 418         swf_SetU16(t,0);
 419         swf_SetVideoStreamIFrame(t, fi->stream, pic, quant);
 420         fi->lastiframe = fi->stream->frame;
 421     } else {
 422         swf_SetU16(t,0);
 423         swf_SetVideoStreamPFrame(t, fi->stream, pic, quant);
 424     }
 425     itag->tag = t;
 426     tagmap_addMapping(itag->tagmap, 0, self);
 427     free(pic);
 428     return Py_BuildValue("s", 0);
 429 }
 430 static PyObject* videostream_addDistortionFrame(PyObject*self, PyObject*args)
 431 {
 432     tag_internals_t*itag = tag_getinternals(self);
 433     videostream_internal_t*fi = (videostream_internal_t*)itag->data;
 434
 435     /* TODO */
 436     return Py_BuildValue("s", 0);
 437 }
 438 static PyMethodDef videostream_methods[] =
 439 {{"xblocks", videostream_getbwidth, METH_VARARGS, "get's the number of horizontal blocks"},
 440  {"yblocks", videostream_getbheight, METH_VARARGS, "get's the number of vertical blocks"},
 441  {"addFrame", (PyCFunction)videostream_addFrame, METH_KEYWORDS, "add a Video Frame"},
 442  {"addDistortionFrame", (PyCFunction)videostream_addDistortionFrame, METH_KEYWORDS, "add a MVD frame"},
 443  {NULL, NULL, 0, NULL}
 444 };
 445
 446 static tag_internals_t videostream_tag =
 447 {
 448     parse: videostream_parse,
 449     fillTAG: videostream_fillTAG,
 450     dealloc: videostream_dealloc,
 451     tagfunctions: videostream_methods,
 452     datasize: sizeof(videostream_internal_t),
 453 };
 454
 455 //============================================================================
 456
 457 static tag_internals_t videoframe_tag =
 458 {
 459     parse: 0,
 460     fillTAG: 0,
 461     dealloc: 0,
 462     tagfunctions: 0,
 463     datasize: 0
 464 };
 465
 466 //============================================================================
 467
 468 static PyMethodDef TagMethods[] =
 469 {
 470     /* TAGS */
 471     {"BackgroundColor", (PyCFunction)f_SetBackgroundColor, METH_KEYWORDS, "Create a SetBackGroundColor Tag."},
 472     {"Protect", (PyCFunction)f_Protect, METH_KEYWORDS, "Create a Protect Tag."},
 473     {"Font", (PyCFunction)f_DefineFont, METH_KEYWORDS, "Create a DefineFont Tag."},
 474     {"Text", (PyCFunction)f_DefineText, METH_KEYWORDS, "Create a DefineText Tag."},
 475     {"PlaceObject", (PyCFunction)f_PlaceObject, METH_KEYWORDS, "Create a PlaceObject Tag."},
 476     {"VideoStream", (PyCFunction)f_DefineVideoStream, METH_KEYWORDS, "Create a Videostream."},
 477     {NULL, NULL, 0, NULL}
 478 };
 479 PyMethodDef* tags_getMethods()
 480 {
 481     TagClass.ob_type = &PyType_Type;
 482
 483     register_tag(ST_PLACEOBJECT,&placeobject_tag);
 484     register_tag(ST_PLACEOBJECT2,&placeobject_tag);
 485     register_tag(ST_SETBACKGROUNDCOLOR,&bgcolor_tag);
 486     register_tag(ST_DEFINEFONT,&font_tag);
 487     register_tag(ST_PROTECT,&protect_tag);
 488     register_tag(ST_DEFINETEXT,&text_tag);
 489     register_tag(ST_END,&end_tag);
 490
 491     return TagMethods;
 492 }
 493