From 3f8f9d9ca3c5d1e1067e0de0fe06951989cd9a9c Mon Sep 17 00:00:00 2001 From: kramm Date: Fri, 4 May 2007 13:20:29 +0000 Subject: [PATCH] initial checkin --- lib/python/gfx.c | 462 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 462 insertions(+) create mode 100644 lib/python/gfx.c diff --git a/lib/python/gfx.c b/lib/python/gfx.c new file mode 100644 index 0000000..fa07f47 --- /dev/null +++ b/lib/python/gfx.c @@ -0,0 +1,462 @@ +/* gfx.c + + Python wrapper for gfx convert + + Part of the swftools package. + + Copyright (c) 2003 Matthias Kramm + + 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 */ + +#include +#undef HAVE_STAT +#include "../devices/swf.h" +#include "../devices/render.h" +#include "../devices/rescale.h" +#include "../pdf/pdf.h" +#include "../log.h" + +gfxsource_t*pdfdriver; + +staticforward PyTypeObject OutputClass; +staticforward PyTypeObject PageClass; +staticforward PyTypeObject DriverClass; + +typedef struct { + PyObject_HEAD + gfxdevice_t*output_device; +} OutputObject; + +typedef struct { + PyObject_HEAD + PyObject*parent; + gfxpage_t*page; + int nr; +} PageObject; + +typedef struct { + PyObject_HEAD + gfxdocument_t*doc; + char*filename; +} DocObject; + +static char* strf(char*format, ...) +{ + char buf[1024]; + int l; + va_list arglist; + va_start(arglist, format); + vsprintf(buf, format, arglist); + va_end(arglist); + return strdup(buf); +} +#define PY_ERROR(s,args...) (PyErr_SetString(PyExc_Exception, strf(s, ## args)),NULL) +#define PY_NONE Py_BuildValue("s", 0) + +//--------------------------------------------------------------------- +staticforward PyObject* output_save(PyObject* _self, PyObject* args, PyObject* kwargs); +staticforward PyObject* output_startframe(PyObject* _self, PyObject* args, PyObject* kwargs); +staticforward PyObject* output_endframe(PyObject* _self, PyObject* args, PyObject* kwargs); + +static PyMethodDef output_methods[] = +{ + /* Output functions */ + {"save", (PyCFunction)output_save, METH_KEYWORDS, ""}, + {"startframe", (PyCFunction)output_startframe, METH_KEYWORDS, ""}, + {"endframe", (PyCFunction)output_endframe, METH_KEYWORDS, ""}, + {0,0,0,0} +}; +static PyObject* output_save(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + OutputObject* self = (OutputObject*)_self; + char*filename = 0; + static char *kwlist[] = {"filename", NULL}; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &filename)) + return NULL; + + gfxresult_t*result = self->output_device->finish(self->output_device); + if(result->save(result, filename) < 0) { + return PY_ERROR("Couldn't write to %s", filename); + } + result->destroy(result); + return PY_NONE; +} +static PyObject* output_startframe(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + OutputObject* self = (OutputObject*)_self; + int width=0, height=0; + if (!PyArg_ParseTuple(args, "ii", &width, &height)) + return NULL; + self->output_device->startpage(self->output_device, width, height); + return PY_NONE; +} +static PyObject* output_endframe(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + OutputObject* self = (OutputObject*)_self; + if (!PyArg_ParseTuple(args, "")) + return NULL; + self->output_device->endpage(self->output_device); + return PY_NONE; +} +static PyObject* f_createSWF(PyObject* parent, PyObject* args, PyObject* kwargs) +{ + static char *kwlist[] = {NULL}; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "", kwlist)) + return NULL; + OutputObject*self = PyObject_New(OutputObject, &OutputClass); + + self->output_device = malloc(sizeof(gfxdevice_t)); + gfxdevice_swf_init(self->output_device); + return (PyObject*)self; +} +static void output_dealloc(PyObject* _self) { + OutputObject* self = (OutputObject*)_self; + + if(self->output_device) { + gfxresult_t*result = self->output_device->finish(self->output_device); + result->destroy(result);result=0; + self->output_device = 0; + } + + PyObject_Del(self); +} +static PyObject* output_getattr(PyObject * _self, char* a) +{ + OutputObject*self = (OutputObject*)_self; + +/* if(!strcmp(a, "x1")) { + return PyInt_FromLong(self->output_device->x1); + } else if(!strcmp(a, "y1")) { + return PyInt_FromLong(self->output_device->y1); + } else if(!strcmp(a, "x2")) { + return PyInt_FromLong(self->output_device->x2); + } else if(!strcmp(a, "y2")) { + return PyInt_FromLong(self->output_device->y2); + }*/ + + return Py_FindMethod(output_methods, _self, a); +} +static int output_setattr(PyObject * _self, char* a, PyObject * o) +{ + OutputObject*self = (OutputObject*)_self; + if(!PyString_Check(o)) + return -1; + char*value = PyString_AsString(o); + self->output_device->setparameter(self->output_device, a, value); + return -1; +} +static int output_print(PyObject * _self, FILE *fi, int flags) +{ + OutputObject*self = (OutputObject*)_self; + fprintf(fi, "%08x(%d)", (int)_self, _self?_self->ob_refcnt:0); + return 0; +} + +//--------------------------------------------------------------------- +staticforward PyObject* page_render(PyObject* _self, PyObject* args, PyObject* kwargs); +staticforward PyObject* page_asImage(PyObject* _self, PyObject* args, PyObject* kwargs); + +static PyMethodDef page_methods[] = +{ + /* Page functions */ + {"render", (PyCFunction)page_render, METH_KEYWORDS, ""}, + {"asImage", (PyCFunction)page_asImage, METH_KEYWORDS, ""}, + {0,0,0,0} +}; +static PyObject* page_render(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + PageObject* self = (PageObject*)_self; + + static char *kwlist[] = {"dev", "move", "clip", NULL}; + OutputObject*output = 0; + PyObject*move=0; + PyObject*clip=0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|OO", kwlist, &OutputClass, &output, + &move,&clip + )) + return NULL; + + int x=0,y=0; + int cx1=0,cy1=0,cx2=0,cy2=0; + + if(move) { + if (!PyArg_ParseTuple(move, "ii", &x,&y)) + return NULL; + } + if(clip) { + if (!PyArg_ParseTuple(clip, "iiii", &cx1,&cy1,&cx2,&cy2)) + return NULL; + } + + if(x|y|cx1|cx2|cy1|cy2) + self->page->rendersection(self->page, output->output_device,x,y,cx1,cy1,cx2,cy2); + else + self->page->render(self->page, output->output_device); + return PY_NONE; +} + +static PyObject* page_asImage(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + PageObject* self = (PageObject*)_self; + + static char *kwlist[] = {"width", "height", NULL}; + int width=0,height=0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii", kwlist, &width, &height)) + return NULL; + + if(!width || !height) { + return PY_ERROR("invalid dimensions: %dx%d", width,height); + } + + gfxdevice_t dev1,dev2; + gfxdevice_render_init(&dev1); + dev1.setparameter(&dev1, "antialise", "2"); + gfxdevice_rescale_init(&dev2, &dev1, width, height); + dev2.startpage(&dev2, self->page->width, self->page->height); + self->page->render(self->page, &dev2); + dev2.endpage(&dev2); + gfxresult_t*result = dev2.finish(&dev2); + gfximage_t*img = (gfximage_t*)result->get(result,"page0"); + int l = img->width*img->height; + unsigned char*data = malloc(img->width*img->height*3); + int s,t; + for(t=0,s=0;tdata[t].r; + data[s+1] = img->data[t].g; + data[s+2] = img->data[t].b; + } + result->destroy(result); + return PyString_FromStringAndSize((char*)data,img->width*img->height*3); +} + +static void page_dealloc(PyObject* _self) { + PageObject* self = (PageObject*)_self; + if(self->page) { + self->page->destroy(self->page); + self->page=0; + } + if(self->parent) { + Py_DECREF(self->parent); + self->parent=0; + } + + PyObject_Del(self); +} +static PyObject* page_getattr(PyObject * _self, char* a) +{ + PageObject*self = (PageObject*)_self; + + if(!strcmp(a, "size")) { + return Py_BuildValue("(ii)", self->page->width, self->page->height); + } if(!strcmp(a, "doc")) { + Py_INCREF(self->parent); + return self->parent; + } if(!strcmp(a, "nr")) { + return PyInt_FromLong(self->nr); + } else if(!strcmp(a, "width")) { + return PyInt_FromLong(self->page->width); + } else if(!strcmp(a, "height")) { + return PyInt_FromLong(self->page->height); + } + return Py_FindMethod(page_methods, _self, a); +} +static int page_setattr(PyObject * self, char* a, PyObject * o) { + return -1; +} +static int page_print(PyObject * _self, FILE *fi, int flags) +{ + PageObject*self = (PageObject*)_self; + fprintf(fi, "%08x(%d)", (int)_self, _self?_self->ob_refcnt:0); + return 0; +} + +//--------------------------------------------------------------------- + +staticforward PyObject* doc_getPage(PyObject* parent, PyObject* args, PyObject* kwargs); + +static PyMethodDef doc_methods[] = +{ + /* PDF functions */ + {"getPage", (PyCFunction)doc_getPage, METH_KEYWORDS, ""}, + {0,0,0,0} +}; + +static PyObject* doc_getPage(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + DocObject* self = (DocObject*)_self; + + static char *kwlist[] = {"nr", NULL}; + int pagenr = 0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, &pagenr)) + return NULL; + + PageObject*page = PyObject_New(PageObject, &PageClass); + page->page = self->doc->getpage(self->doc, pagenr); + page->nr = pagenr; + page->parent = _self; + Py_INCREF(page->parent); + if(!page->page) { + PyObject_Del(page); + return PY_ERROR("Couldn't extract page %d", pagenr); + } + return (PyObject*)page; +} + +static PyObject* f_open(PyObject* parent, PyObject* args, PyObject* kwargs) +{ + static char *kwlist[] = {"type", "filename", NULL}; + char*filename; + char*type; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ss", kwlist, &type, &filename)) + return NULL; + + DocObject*self = PyObject_New(DocObject, &DriverClass); + + if(!strcmp(type,"pdf")) + self->doc = pdfdriver->open(filename); + else + return PY_ERROR("Unknown type %s", type); + + if(!self->doc) { + PyObject_Del(self); + return PY_ERROR("Couldn't open %s", filename); + } + self->filename = strdup(filename); + return (PyObject*)self; +} +static void doc_dealloc(PyObject* _self) { + DocObject* self = (DocObject*)_self; + if(self->doc) { + self->doc->destroy(self->doc); + self->doc=0; + } + if(self->filename) { + free(self->filename);self->filename=0; + } + PyObject_Del(self); +} +static PyObject* doc_getattr(PyObject * _self, char* a) +{ + DocObject*self = (DocObject*)_self; + if(!strcmp(a, "pages")) { + return PyInt_FromLong(self->doc->num_pages); + } + if(!strcmp(a, "filename")) { + return PyString_FromString(self->filename); + } + return Py_FindMethod(doc_methods, _self, a); +} +static int doc_setattr(PyObject * self, char* a, PyObject * o) { + return -1; +} +static int doc_print(PyObject * _self, FILE *fi, int flags) +{ + DocObject*self = (DocObject*)_self; + fprintf(fi, "%08x(%d)", (int)_self, _self?_self->ob_refcnt:0); + return 0; +} + +//--------------------------------------------------------------------- + +static PyTypeObject OutputClass = +{ + PyObject_HEAD_INIT(NULL) + 0, + tp_name: "Output", + tp_basicsize: sizeof(OutputObject), + tp_itemsize: 0, + tp_dealloc: output_dealloc, + tp_print: output_print, + tp_getattr: output_getattr, + tp_setattr: output_setattr, +}; +static PyTypeObject PageClass = +{ + PyObject_HEAD_INIT(NULL) + 0, + tp_name: "Page", + tp_basicsize: sizeof(PageObject), + tp_itemsize: 0, + tp_dealloc: page_dealloc, + tp_print: page_print, + tp_getattr: page_getattr, + tp_setattr: page_setattr, +}; +static PyTypeObject DriverClass = +{ + PyObject_HEAD_INIT(NULL) + 0, + tp_name: "PDF", + tp_basicsize: sizeof(DocObject), + tp_itemsize: 0, + tp_dealloc: doc_dealloc, + tp_print: doc_print, + tp_getattr: doc_getattr, + tp_setattr: doc_setattr, +}; + +//===================================================================== + +static PyObject* f_setoption(PyObject* self, PyObject* args, PyObject* kwargs) +{ + static char *kwlist[] = {"key", "value", NULL}; + char*key=0,*value=0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ss", kwlist, &key, &value)) + return NULL; + pdfdriver->set_parameter(key,value); + return PY_NONE; +} + +static PyObject* f_addfont(PyObject* self, PyObject* args, PyObject* kwargs) +{ + static char *kwlist[] = {"filename", NULL}; + char*filename=0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &filename)) + return NULL; + pdfdriver->set_parameter("font", filename); + return PY_NONE; +} + +static PyObject* f_addfontdir(PyObject* self, PyObject* args, PyObject* kwargs) +{ + static char *kwlist[] = {"filename", NULL}; + char*filename=0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &filename)) + return NULL; + pdfdriver->set_parameter("fontdir", filename); + return PY_NONE; +} + +static PyMethodDef pdf2swf_methods[] = +{ + /* module functions */ + {"open", (PyCFunction)f_open, METH_KEYWORDS, ""}, + {"addfont", (PyCFunction)f_addfont, METH_KEYWORDS, ""}, + {"addfontdir", (PyCFunction)f_addfontdir, METH_KEYWORDS, ""}, + {"setoption", (PyCFunction)f_setoption, METH_KEYWORDS, ""}, + {0, 0, 0, 0} +}; + +void initgfx(void) +{ + initLog(0,0,0,0,0,2); + OutputClass.ob_type = &PyType_Type; + PageClass.ob_type = &PyType_Type; + DriverClass.ob_type = &PyType_Type; + + pdfdriver = gfxsource_pdf_create(); + + PyObject*module = Py_InitModule("gfx", pdf2swf_methods); +} -- 1.7.10.4