slight output changes.
[swftools.git] / lib / python / SWF.c
1 /* SWF.c
2
3    Python wrapper for librfxswf- module core.
4
5    Part of the swftools package.
6
7    Copyright (c) 2003 Matthias Kramm <kramm@quiss.org>
8  
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
22
23 #include <Python.h>
24 #undef HAVE_STAT
25 #include "../rfxswf.h"
26 #include "../log.h"
27 #include "./pyutils.h"
28 #include "./tags.h"
29 #include "./taglist.h"
30
31 /*
32 TODO:
33     1) taglist is rfxswflib's linked list. It should maybe implemented as Python
34        list, which would, however, mean that we would have to convert the list
35        back and forth for the following functions:
36         load, save, writeCGI, unfoldAll, foldAll, optimizeOrder
37     2) taglist should have an ID handler. Every time a tag is inserted, it's ID
38        is stored in a lookup list.
39     3) 
40 */
41
42 //-------------------------- Types -------------------------------------------
43
44 staticforward PyTypeObject SWFClass;
45
46 /* Tags, Objects */
47
48 typedef struct {
49     PyObject_HEAD
50     SWF swf; //swf.firstTag ist not used
51     PyObject*taglist;
52     char*filename;
53 } SWFObject;
54
55
56 //----------------------------------------------------------------------------
57 static PyObject* f_create(PyObject* self, PyObject* args, PyObject* kwargs)
58 {
59     static char *kwlist[] = {"version", "fps", "bbox", "name", NULL};
60     SWFObject* swf;
61     int version = 6;
62     double framerate = 25;
63     PyObject * obbox = 0;
64     SRECT bbox = {0,0,0,0};
65     char* filename = 0;
66     
67     swf = PyObject_New(SWFObject, &SWFClass);
68     mylog("+%08x(%d) create\n", (int)swf, swf->ob_refcnt);
69
70     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|idOs", 
71                 kwlist, &version, &framerate, 
72                 &obbox, filename))
73         return NULL;
74
75     if (!PyArg_Parse(obbox, "(iiii)", &bbox.xmin, &bbox.ymin, &bbox.xmax, &bbox.ymax))
76         return NULL;
77
78     memset(&swf->swf, 0, sizeof(SWF));
79     if(filename)
80         swf->filename = strdup(filename);
81     else
82         swf->filename = 0;
83
84     swf->swf.fileVersion = version;
85     swf->swf.frameRate = (int)(framerate*0x100);
86     swf->swf.movieSize = bbox;
87     swf->taglist = taglist_new();
88
89     if(swf->swf.fileVersion>=6)
90         swf->swf.compressed = 1;
91
92     mylog(" %08x(%d) create: done\n", (int)swf, swf->ob_refcnt);
93     return (PyObject*)swf;
94 }
95 //----------------------------------------------------------------------------
96 static PyObject* f_load(PyObject* self, PyObject* args)
97 {
98     char* filename;
99     SWFObject* swf;
100     int fi;
101
102     if (!PyArg_ParseTuple(args,"s:load", &filename)) 
103         return NULL;
104
105     swf = PyObject_New(SWFObject, &SWFClass);
106     mylog("+%08x(%d) f_load\n", (int)swf, swf->ob_refcnt);
107
108     memset(&swf->swf, 0, sizeof(SWF));
109
110     if(!filename) {
111         PyErr_SetString(PyExc_Exception, setError("Couldn't open file %s", filename));
112         return 0;
113     }
114     swf->filename = strdup(filename);
115     fi = open(filename,O_RDONLY|O_BINARY);
116     if (fi<0) { 
117         PyErr_SetString(PyExc_Exception, setError("Couldn't open file %s", filename));
118         return 0;
119     }
120     if(swf_ReadSWF(fi,&swf->swf)<0) { 
121         close(fi);
122         PyErr_SetString(PyExc_Exception, setError("%s is not a valid SWF file or contains errors",filename));
123         return 0;
124     }
125     close(fi);
126     swf_FoldAll(&swf->swf);
127
128     swf->taglist = taglist_new2(swf->swf.firstTag);
129     if(swf->taglist == NULL) {
130         return NULL;
131     }
132     
133     swf_FreeTags(&swf->swf);
134     swf->swf.firstTag = 0;
135     
136     return (PyObject*)swf;
137 }
138 //----------------------------------------------------------------------------
139 static PyObject * swf_save(PyObject* self, PyObject* args, PyObject* kwargs)
140 {
141     static char *kwlist[] = {"name", "compress", NULL};
142     SWFObject*swfo;
143     SWF*swf;
144     int fi;
145     char*filename = 0;
146     int compress = 0;
147     
148     if(!self)
149         return NULL;
150
151     swfo = (SWFObject*)self;
152     swf = &swfo->swf;
153     
154     filename = swfo->filename;
155
156     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|si", kwlist, &filename, &compress))
157         return NULL;
158     
159     mylog(" %08x(%d) f_save filename=%s compress=%d\n", (int)self, self->ob_refcnt, filename, compress);
160
161     // keyword arg compress (=1) forces compression
162     if(compress)
163         swf->compressed = 1;
164     
165     swf->firstTag = taglist_getTAGs(swfo->taglist);
166     if(!swf->firstTag)
167         return NULL;
168
169     // fix the file, in case it is empty or not terminated properly
170     {
171         TAG*tag = swf->firstTag;
172         if(!tag)
173             tag = swf->firstTag = swf_InsertTag(0,ST_END);
174         while(tag && tag->next) {
175             tag = tag->next;
176         }
177         if(tag->id != ST_END) {
178             tag = swf_InsertTag(tag,ST_END);
179         }
180     }
181
182     fi = open(filename, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644);
183     if(fi<0) {
184         PyErr_SetString(PyExc_Exception, setError("couldn't create output file %s", filename));
185         return 0;
186     }
187     if(swf->compressed) {
188             if(swf_WriteSWC(fi, swf)<0) {
189                 close(fi);
190                 PyErr_SetString(PyExc_Exception, setError("WriteSWC() failed."));
191                 return 0;
192             }
193     } else {
194             if(swf_WriteSWF(fi, swf)<0) {
195                 close(fi);
196                 PyErr_SetString(PyExc_Exception, setError("WriteSWC() failed."));
197                 return 0;
198             }
199     }
200     close(fi);
201
202     swf_FreeTags(swf);
203     /*{ TAG * t = swf->firstTag;
204       while (t)
205       { 
206         mylog("tag: %08x\n",t);
207         mylog("  id: %d (%s)\n", t->id, swf_TagGetName(t));
208         mylog("  data: %08x (%d bytes)\n", t->data, t->len);
209         mylog("  next: %08x\n", t->next);
210         TAG * tnew = t->next;
211         mylog("->free data\n");
212         if (t->data) free(t->data);
213         mylog("->free tag\n");
214         free(t);
215         t = tnew;
216       }
217     }*/
218     swf->firstTag = 0;
219     
220     return PY_NONE;
221 }
222 //----------------------------------------------------------------------------
223 static PyObject * swf_writeCGI(PyObject* self, PyObject* args)
224 {
225     SWFObject*swf = (SWFObject*)self;
226     if(!self || !PyArg_ParseTuple(args,"")) 
227         return NULL;
228     swf->swf.firstTag = taglist_getTAGs(swf->taglist);
229     if(!swf->swf.firstTag)
230         return NULL;
231     swf_WriteCGI(&swf->swf);
232     swf_FreeTags(&swf->swf);
233     swf->swf.firstTag = 0;
234     return PY_NONE;
235 }
236 //----------------------------------------------------------------------------
237
238 //TODO: void swf_Relocate(SWF*swf, char*bitmap); // bitmap is 65536 bytes, bitmap[a]==0 means id a is free
239
240 static PyMethodDef swf_functions[] =
241 {{"save", (PyCFunction)swf_save, METH_KEYWORDS, "Save SWF to disk"},
242  {"writeCGI", (PyCFunction)swf_writeCGI, METH_VARARGS, "print SWF as CGI to stdout"},
243  {NULL, NULL, 0, NULL}
244 };
245  
246 //----------------------------------------------------------------------------
247 static void swf_dealloc(PyObject* self)
248 {
249     mylog("-%08x(%d) swf_dealloc\n", (int)self, self->ob_refcnt);
250     SWFObject*swfo;
251     SWF*swf;
252     swfo = (SWFObject*)self;
253     swf = &swfo->swf;
254     if(swfo->filename) {
255         free(swfo->filename);
256         swfo->filename = 0;
257     }
258     Py_DECREF(swfo->taglist);
259     swfo->taglist = 0;
260     PyObject_Del(self);
261 }
262 //----------------------------------------------------------------------------
263 static int swf_print(PyObject * self, FILE *fi, int flags) //flags&Py_PRINT_RAW
264 {
265     mylog(" %08x(%d) print \n", (int)self, self->ob_refcnt);
266     SWFObject*swf = (SWFObject*)self;
267     swf_DumpHeader(fi, &swf->swf);
268     //void swf_DumpSWF(FILE * f,SWF*swf);
269     return 0;
270 }
271 //----------------------------------------------------------------------------
272 static PyObject* swf_getattr(PyObject * self, char* a)
273 {
274     SWFObject*swf = (SWFObject*)self;
275     PyObject* ret;
276
277     if(!strcmp(a, "fps")) {
278         double fps = swf->swf.frameRate/256.0;
279         mylog(" %08x(%d) swf_getattr %s = %f\n", (int)self, self->ob_refcnt, a, fps);
280         return Py_BuildValue("d", fps);
281     } else if(!strcmp(a, "version")) {
282         int version = swf->swf.fileVersion;;
283         mylog(" %08x(%d) swf_getattr %s = %d\n", (int)self, self->ob_refcnt, a, version);
284         return Py_BuildValue("i", version);
285     } else if(!strcmp(a, "name")) {
286         char*filename = swf->filename;
287         mylog(" %08x(%d) swf_getattr %s = %s\n", (int)self, self->ob_refcnt, a, filename);
288         return Py_BuildValue("s", filename);
289     } else if(!strcmp(a, "bbox")) {
290         int xmin,ymin,xmax,ymax;
291         xmin = swf->swf.movieSize.xmin;
292         ymin = swf->swf.movieSize.ymin;
293         xmax = swf->swf.movieSize.xmax;
294         ymax = swf->swf.movieSize.ymax;
295         mylog(" %08x(%d) swf_getattr %s = (%d,%d,%d,%d)\n", (int)self, self->ob_refcnt, a, xmin,ymin,xmax,ymax);
296         return Py_BuildValue("(iiii)", xmin, ymin, xmax, ymax); 
297     } else if(!strcmp(a, "tags")) {
298         PyObject*ret =  (PyObject*)(swf->taglist);
299         Py_INCREF(ret);
300         mylog(" %08x(%d) swf_getattr %s = %08x(%d)\n", (int)self, self->ob_refcnt, a, ret, ret->ob_refcnt);
301         return ret;
302     }
303
304     ret = Py_FindMethod(swf_functions, self, a);
305     mylog(" %08x(%d) swf_getattr %s: %08x\n", (int)self, self->ob_refcnt, a, ret);
306     return ret;
307 }
308 //----------------------------------------------------------------------------
309 static int swf_setattr(PyObject * self, char* a, PyObject * o)
310 {
311     SWFObject*swf = (SWFObject*)self;
312     if(!strcmp(a, "fps")) {
313         double fps;
314         if (!PyArg_Parse(o, "d", &fps)) 
315             goto err;
316         swf->swf.frameRate = (int)(fps*0x100);
317         mylog(" %08x(%d) swf_setattr %s = %f\n", (int)self, self->ob_refcnt, a, fps);
318         return 0;
319     } else if(!strcmp(a, "version")) {
320         int version;
321         if (!PyArg_Parse(o, "i", &version)) 
322             goto err;
323         swf->swf.fileVersion = version;
324         mylog(" %08x(%d) swf_setattr %s = %d\n", (int)self, self->ob_refcnt, a, version);
325         return 0;
326     } else if(!strcmp(a, "name")) {
327         char*filename;
328         if (!PyArg_Parse(o, "s", &filename)) 
329             goto err;
330         if(swf->filename) {
331             free(swf->filename);swf->filename=0;
332         }
333         swf->filename = strdup(filename);
334         mylog(" %08x(%d) swf_setattr %s = %s\n", (int)self, self->ob_refcnt, a, filename);
335         return 0;
336     } else if(!strcmp(a, "bbox")) {
337         int xmin=0,ymin=0,xmax=0,ymax=0;
338         if (!PyArg_Parse(o, "(iiii)", &xmin, &ymin, &xmax, &ymax)) 
339             goto err;
340
341         swf->swf.movieSize.xmin = xmin;
342         swf->swf.movieSize.ymin = ymin;
343         swf->swf.movieSize.xmax = xmax;
344         swf->swf.movieSize.ymax = ymax;
345         mylog(" %08x(%d) swf_setattr %s = (%d,%d,%d,%d)\n", (int)self, self->ob_refcnt, a, xmin,ymin,xmax,ymax);
346         return 0;
347     } else if(!strcmp(a, "tags")) {
348         PyObject* taglist;
349         taglist = o;
350         PY_ASSERT_TYPE(taglist,&TagListClass);
351         Py_DECREF(swf->taglist);
352         swf->taglist = taglist;
353         Py_INCREF(swf->taglist);
354         mylog(" %08x(%d) swf_setattr %s = %08x\n", (int)self, self->ob_refcnt, a, swf->taglist);
355         return 0;
356     }
357 err:
358     mylog(" %08x(%d) swf_setattr %s = ? (%08x)\n", (int)self, self->ob_refcnt, a, o);
359     return 1;
360 }
361
362 //----------------------------------------------------------------------------
363 static PyTypeObject SWFClass = 
364 {
365     PyObject_HEAD_INIT(NULL)
366     0,
367     tp_name: "SWF",
368     tp_basicsize: sizeof(SWFObject),
369     tp_itemsize: 0,
370     tp_dealloc: swf_dealloc,
371     tp_print: swf_print,
372     tp_getattr: swf_getattr,
373     tp_setattr: swf_setattr,
374 };
375 //----------------------------------------------------------------------------
376
377 static PyMethodDef SWFMethods[] = 
378 {
379     /* SWF creation*/
380     {"load", f_load, METH_VARARGS, "Load a SWF from disc."},
381     {"create", (PyCFunction)f_create, METH_KEYWORDS, "Create a new SWF from scratch."},
382     {0,0,0,0}
383     // save is a member function
384 };
385 PyMethodDef* swf_getMethods()
386 {
387     SWFClass.ob_type = &PyType_Type;
388     return SWFMethods;
389 }
390
391 // =============================================================================
392
393 #include "primitives.h"
394 #include "action.h"
395 #include "tag.h"
396 #include "taglist.h"
397
398 static PyObject* module_verbose(PyObject* self, PyObject* args, PyObject* kwargs)
399 {
400     int _verbose = 0;
401     static char *kwlist[] = {"verbosity", NULL};
402     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, &verbose))
403         return NULL;
404     setVerbosity(_verbose);
405
406     return Py_BuildValue("s", 0);
407 }
408
409 static PyMethodDef LoggingMethods[] = 
410 {
411     /* Module functions */
412     {"verbose", (PyCFunction)module_verbose, METH_KEYWORDS, "Set the module verbosity"},
413     {0,0,0,0}
414 };
415
416 void initSWF(void)
417 {
418     PyObject*module;
419     PyMethodDef* primitive_methods = primitive_getMethods();
420     PyMethodDef* tag_methods = tags_getMethods();
421     PyMethodDef* action_methods = action_getMethods();
422     PyMethodDef* swf_methods = swf_getMethods();
423
424     PyMethodDef* all_methods = 0;
425     all_methods = addMethods(all_methods, primitive_methods);
426     all_methods = addMethods(all_methods, tag_methods);
427     all_methods = addMethods(all_methods, action_methods);
428     all_methods = addMethods(all_methods, swf_methods);
429
430     all_methods = addMethods(all_methods, LoggingMethods);
431
432     module = Py_InitModule("SWF", all_methods);
433
434     /* Python doesn't copy the PyMethodDef struct, so we need
435        to keep it around */
436     // free(all_methods) 
437 }
438