#include <sys/time.h>
#include <svideo.h>
-#include "allobjects.h"
-#include "import.h"
-#include "modsupport.h"
+#include "Python.h"
#include "compile.h"
-#include "ceval.h"
#include "yuv.h" /* for YUV conversion functions */
typedef struct {
- OB_HEAD
+ PyObject_HEAD
SV_nodeP ob_svideo;
svCaptureInfo ob_info;
} svobject;
typedef struct {
- OB_HEAD
+ PyObject_HEAD
void *ob_capture;
int ob_mustunlock;
svCaptureInfo ob_info;
svobject *ob_svideo;
} captureobject;
-static object *SvError; /* exception sv.error */
+static PyObject *SvError; /* exception sv.error */
-static object *newcaptureobject PROTO((svobject *, void *, int));
+static PyObject *newcaptureobject Py_PROTO((svobject *, void *, int));
/* Set a SV-specific error from svideo_errno and return NULL */
-static object *
+static PyObject *
sv_error()
{
- err_setstr(SvError, svStrerror(svideo_errno));
+ PyErr_SetString(SvError, svStrerror(svideo_errno));
return NULL;
}
-static object *
+static PyObject *
svc_conversion(self, args, function, factor)
captureobject *self;
- object *args;
+ PyObject *args;
void (*function)();
float factor;
{
- object *output;
+ PyObject *output;
int invert;
+ char* outstr;
- if (!getargs(args, "i", &invert))
+ if (!PyArg_Parse(args, "i", &invert))
return NULL;
- output = newsizedstringobject(NULL, (int) (self->ob_info.width * self->ob_info.height * factor));
- if (output == NULL)
+ if (!(output = PyString_FromStringAndSize(
+ NULL,
+ (int)(self->ob_info.width * self->ob_info.height * factor))))
+ {
return NULL;
+ }
+ if (!(outstr = PyString_AsString(output))) {
+ Py_DECREF(output);
+ return NULL;
+ }
- (*function)((boolean) invert, self->ob_capture, getstringvalue(output),
+ (*function)((boolean)invert, self->ob_capture,
+ outstr,
self->ob_info.width, self->ob_info.height);
return output;
* 3 functions to convert from Starter Video YUV 4:1:1 format to
* Compression Library 4:2:2 Duplicate Chroma format.
*/
-static object *
+static PyObject *
svc_YUVtoYUV422DC(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
if (self->ob_info.format != SV_YUV411_FRAMES) {
- err_setstr(SvError, "data has bad format");
+ PyErr_SetString(SvError, "data has bad format");
return NULL;
}
return svc_conversion(self, args, yuv_sv411_to_cl422dc, 2.0);
}
-static object *
+static PyObject *
svc_YUVtoYUV422DC_quarter(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
if (self->ob_info.format != SV_YUV411_FRAMES) {
- err_setstr(SvError, "data has bad format");
+ PyErr_SetString(SvError, "data has bad format");
return NULL;
}
- return svc_conversion(self, args, yuv_sv411_to_cl422dc_quartersize, 0.5);
+ return svc_conversion(self, args,
+ yuv_sv411_to_cl422dc_quartersize, 0.5);
}
-static object *
+static PyObject *
svc_YUVtoYUV422DC_sixteenth(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
if (self->ob_info.format != SV_YUV411_FRAMES) {
- err_setstr(SvError, "data has bad format");
+ PyErr_SetString(SvError, "data has bad format");
return NULL;
}
- return svc_conversion(self, args, yuv_sv411_to_cl422dc_sixteenthsize, 0.125);
+ return svc_conversion(self, args,
+ yuv_sv411_to_cl422dc_sixteenthsize, 0.125);
}
-static object *
+static PyObject *
svc_YUVtoRGB(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
switch (self->ob_info.format) {
case SV_YUV411_FRAMES:
case SV_YUV411_FRAMES_AND_BLANKING_BUFFER:
break;
default:
- err_setstr(SvError, "data had bad format");
+ PyErr_SetString(SvError, "data had bad format");
return NULL;
}
return svc_conversion(self, args, svYUVtoRGB, (float) sizeof(long));
}
-static object *
+static PyObject *
svc_RGB8toRGB32(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
if (self->ob_info.format != SV_RGB8_FRAMES) {
- err_setstr(SvError, "data has bad format");
+ PyErr_SetString(SvError, "data has bad format");
return NULL;
}
return svc_conversion(self, args, svRGB8toRGB32, (float) sizeof(long));
}
-static object *
+static PyObject *
svc_InterleaveFields(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
if (self->ob_info.format != SV_RGB8_FRAMES) {
- err_setstr(SvError, "data has bad format");
+ PyErr_SetString(SvError, "data has bad format");
return NULL;
}
return svc_conversion(self, args, svInterleaveFields, 1.0);
}
-static object *
+static PyObject *
svc_GetFields(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
- object *f1, *f2, *ret;
+ PyObject *f1 = NULL;
+ PyObject *f2 = NULL;
+ PyObject *ret = NULL;
int fieldsize;
+ char* obcapture;
if (self->ob_info.format != SV_RGB8_FRAMES) {
- err_setstr(SvError, "data has bad format");
+ PyErr_SetString(SvError, "data has bad format");
return NULL;
}
fieldsize = self->ob_info.width * self->ob_info.height / 2;
- f1 = newsizedstringobject((char *) self->ob_capture, fieldsize);
- f2 = newsizedstringobject((char *) self->ob_capture + fieldsize, fieldsize);
- ret = mkvalue("(OO)", f1, f2);
- XDECREF(f1);
- XDECREF(f2);
+ obcapture = (char*)self->ob_capture;
+
+ if (!(f1 = PyString_FromStringAndSize(obcapture, fieldsize)))
+ goto finally;
+ if (!(f2 = PyString_FromStringAndSize(obcapture + fieldsize,
+ fieldsize)))
+ goto finally;
+ ret = Py_BuildValue("(OO)", f1, f2);
+
+ finally:
+ Py_XDECREF(f1);
+ Py_XDECREF(f2);
return ret;
}
-static object *
+static PyObject *
svc_UnlockCaptureData(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
if (!self->ob_mustunlock) {
- err_setstr(SvError, "buffer should not be unlocked");
+ PyErr_SetString(SvError, "buffer should not be unlocked");
return NULL;
}
self->ob_mustunlock = 0;
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#ifdef USE_GL
#include <gl.h>
-static object *
+static PyObject *
svc_lrectwrite(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
Screencoord x1, x2, y1, y2;
- if (!getargs(args, "(hhhh)", &x1, &x2, &y1, &y2))
+ if (!PyArg_Parse(args, "(hhhh)", &x1, &x2, &y1, &y2))
return NULL;
lrectwrite(x1, x2, y1, y2, (unsigned long *) self->ob_capture);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
-static object *
+static PyObject *
svc_writefile(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
- object *file;
+ PyObject *file;
int size;
+ FILE* fp;
- if (!getargs(args, "O", &file))
+ if (!PyArg_Parse(args, "O", &file))
return NULL;
- if (!is_fileobject(file)) {
- err_setstr(SvError, "not a file object");
+ if (!PyFile_Check(file)) {
+ PyErr_SetString(SvError, "not a file object");
return NULL;
}
+ if (!(fp = PyFile_AsFile(file)))
+ return NULL;
+
size = self->ob_info.width * self->ob_info.height;
- if (fwrite(self->ob_capture, sizeof(long), size, getfilefile(file)) != size) {
- err_setstr(SvError, "writing failed");
+ if (fwrite(self->ob_capture, sizeof(long), size, fp) != size) {
+ PyErr_SetString(SvError, "writing failed");
return NULL;
}
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
svc_FindVisibleRegion(self, args)
captureobject *self;
- object *args;
+ PyObject *args;
{
void *visible;
int width;
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
- if (svFindVisibleRegion(self->ob_svideo->ob_svideo, self->ob_capture, &visible, self->ob_info.width))
+ if (svFindVisibleRegion(self->ob_svideo->ob_svideo,
+ self->ob_capture, &visible,
+ self->ob_info.width))
return sv_error();
if (visible == NULL) {
- err_setstr(SvError, "data in wrong format");
+ PyErr_SetString(SvError, "data in wrong format");
return NULL;
}
return newcaptureobject(self->ob_svideo, visible, 0);
}
-static struct methodlist capture_methods[] = {
- {"YUVtoRGB", (method)svc_YUVtoRGB},
- {"RGB8toRGB32", (method)svc_RGB8toRGB32},
- {"InterleaveFields", (method)svc_InterleaveFields},
- {"UnlockCaptureData", (method)svc_UnlockCaptureData},
- {"FindVisibleRegion", (method)svc_FindVisibleRegion},
- {"GetFields", (method)svc_GetFields},
- {"YUVtoYUV422DC", (method)svc_YUVtoYUV422DC},
- {"YUVtoYUV422DC_quarter",(method)svc_YUVtoYUV422DC_quarter},
- {"YUVtoYUV422DC_sixteenth",(method)svc_YUVtoYUV422DC_sixteenth},
+static PyMethodDef capture_methods[] = {
+ {"YUVtoRGB", (PyCFunction)svc_YUVtoRGB},
+ {"RGB8toRGB32", (PyCFunction)svc_RGB8toRGB32},
+ {"InterleaveFields", (PyCFunction)svc_InterleaveFields},
+ {"UnlockCaptureData", (PyCFunction)svc_UnlockCaptureData},
+ {"FindVisibleRegion", (PyCFunction)svc_FindVisibleRegion},
+ {"GetFields", (PyCFunction)svc_GetFields},
+ {"YUVtoYUV422DC", (PyCFunction)svc_YUVtoYUV422DC},
+ {"YUVtoYUV422DC_quarter",(PyCFunction)svc_YUVtoYUV422DC_quarter},
+ {"YUVtoYUV422DC_sixteenth",(PyCFunction)svc_YUVtoYUV422DC_sixteenth},
#ifdef USE_GL
- {"lrectwrite", (method)svc_lrectwrite},
+ {"lrectwrite", (PyCFunction)svc_lrectwrite},
#endif
- {"writefile", (method)svc_writefile},
+ {"writefile", (PyCFunction)svc_writefile},
{NULL, NULL} /* sentinel */
};
{
if (self->ob_capture != NULL) {
if (self->ob_mustunlock)
- (void) svUnlockCaptureData(self->ob_svideo->ob_svideo, self->ob_capture);
+ (void)svUnlockCaptureData(self->ob_svideo->ob_svideo,
+ self->ob_capture);
self->ob_capture = NULL;
- DECREF(self->ob_svideo);
+ Py_DECREF(self->ob_svideo);
self->ob_svideo = NULL;
}
- DEL(self);
+ PyMem_DEL(self);
}
-static object *
+static PyObject *
capture_getattr(self, name)
svobject *self;
char *name;
{
- return findmethod(capture_methods, (object *)self, name);
+ return Py_FindMethod(capture_methods, (PyObject *)self, name);
}
-typeobject Capturetype = {
- OB_HEAD_INIT(&Typetype)
+PyTypeObject Capturetype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"capture", /*tp_name*/
sizeof(captureobject), /*tp_size*/
0, /*tp_repr*/
};
-static object *
+static PyObject *
newcaptureobject(self, ptr, mustunlock)
svobject *self;
void *ptr;
{
captureobject *p;
- p = NEWOBJ(captureobject, &Capturetype);
+ p = PyObject_NEW(captureobject, &Capturetype);
if (p == NULL)
return NULL;
p->ob_svideo = self;
- INCREF(self);
+ Py_INCREF(self);
p->ob_capture = ptr;
p->ob_mustunlock = mustunlock;
p->ob_info = self->ob_info;
- return (object *) p;
+ return (PyObject *) p;
}
-static object *
+static PyObject *
sv_GetCaptureData(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
void *ptr;
long fieldID;
- object *res, *c;
+ PyObject *res, *c;
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
if (svGetCaptureData(self->ob_svideo, &ptr, &fieldID))
return sv_error();
if (ptr == NULL) {
- err_setstr(SvError, "no data available");
+ PyErr_SetString(SvError, "no data available");
return NULL;
}
c = newcaptureobject(self, ptr, 1);
if (c == NULL)
return NULL;
- res = mkvalue("(Oi)", c, fieldID);
- DECREF(c);
+ res = Py_BuildValue("(Oi)", c, fieldID);
+ Py_DECREF(c);
return res;
}
-static object *
+static PyObject *
sv_BindGLWindow(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
long wid;
int mode;
- if (!getargs(args, "(ii)", &wid, &mode))
+ if (!PyArg_Parse(args, "(ii)", &wid, &mode))
return NULL;
if (svBindGLWindow(self->ob_svideo, wid, mode))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_EndContinuousCapture(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
if (svEndContinuousCapture(self->ob_svideo))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_IsVideoDisplayed(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
int v;
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
v = svIsVideoDisplayed(self->ob_svideo);
if (v == -1)
return sv_error();
- return newintobject((long) v);
+ return PyInt_FromLong((long) v);
}
-static object *
+static PyObject *
sv_OutputOffset(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
int x_offset;
int y_offset;
- if (!getargs(args, "(ii)", &x_offset, &y_offset))
+ if (!PyArg_Parse(args, "(ii)", &x_offset, &y_offset))
return NULL;
if (svOutputOffset(self->ob_svideo, x_offset, y_offset))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_PutFrame(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
char *buffer;
- if (!getargs(args, "s", &buffer))
+ if (!PyArg_Parse(args, "s", &buffer))
return NULL;
if (svPutFrame(self->ob_svideo, buffer))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_QuerySize(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
int w;
int h;
int rw;
int rh;
- if (!getargs(args, "(ii)", &w, &h))
+ if (!PyArg_Parse(args, "(ii)", &w, &h))
return NULL;
if (svQuerySize(self->ob_svideo, w, h, &rw, &rh))
return sv_error();
- return mkvalue("(ii)", (long) rw, (long) rh);
+ return Py_BuildValue("(ii)", (long) rw, (long) rh);
}
-static object *
+static PyObject *
sv_SetSize(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
int w;
int h;
- if (!getargs(args, "(ii)", &w, &h))
+ if (!PyArg_Parse(args, "(ii)", &w, &h))
return NULL;
if (svSetSize(self->ob_svideo, w, h))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_SetStdDefaults(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
if (svSetStdDefaults(self->ob_svideo))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_UseExclusive(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
boolean onoff;
int mode;
- if (!getargs(args, "(ii)", &onoff, &mode))
+ if (!PyArg_Parse(args, "(ii)", &onoff, &mode))
return NULL;
if (svUseExclusive(self->ob_svideo, onoff, mode))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_WindowOffset(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
int x_offset;
int y_offset;
- if (!getargs(args, "(ii)", &x_offset, &y_offset))
+ if (!PyArg_Parse(args, "(ii)", &x_offset, &y_offset))
return NULL;
if (svWindowOffset(self->ob_svideo, x_offset, y_offset))
return sv_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sv_CaptureBurst(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
int bytes, i;
svCaptureInfo info;
void *bitvector = NULL;
- object *videodata, *bitvecobj, *res;
- static object *evenitem, *odditem;
-
- if (!getargs(args, "(iiiii)", &info.format, &info.width, &info.height,
- &info.size, &info.samplingrate))
+ PyObject *videodata = NULL;
+ PyObject *bitvecobj = NULL;
+ PyObject* *res = NULL;
+ static PyObject *evenitem, *odditem;
+
+ if (!PyArg_Parse(args, "(iiiii)", &info.format,
+ &info.width, &info.height,
+ &info.size, &info.samplingrate))
return NULL;
switch (info.format) {
case SV_YUV411_FRAMES_AND_BLANKING_BUFFER:
break;
default:
- err_setstr(SvError, "illegal format specified");
+ PyErr_SetString(SvError, "illegal format specified");
return NULL;
}
if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes)) {
- if (bitvector)
- free(bitvector);
- return sv_error();
+ res = sv_error();
+ goto finally;
}
- videodata = newsizedstringobject(NULL, bytes);
- if (videodata == NULL) {
- if (bitvector)
- free(bitvector);
- return NULL;
- }
+ if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
+ goto finally;
/* XXX -- need to do something about the bitvector */
- if (svCaptureBurst(self->ob_svideo, &info, getstringvalue(videodata),
- bitvector)) {
- if (bitvector)
- free(bitvector);
- DECREF(videodata);
- return sv_error();
+ {
+ char* str = PyString_AsString(videodata);
+ if (!str)
+ goto finally;
+
+ if (svCaptureBurst(self->ob_svideo, &info, str, bitvector)) {
+ res = sv_error();
+ goto finally;
+ }
}
if (bitvector) {
if (evenitem == NULL) {
- evenitem = newintobject(0);
- if (evenitem == NULL) {
- free(bitvector);
- DECREF(videodata);
- return NULL;
- }
+ if (!(evenitem = PyInt_FromLong(0)))
+ goto finally;
}
if (odditem == NULL) {
- odditem = newintobject(1);
- if (odditem == NULL) {
- free(bitvector);
- DECREF(videodata);
- return NULL;
- }
- }
- bitvecobj = newtupleobject(2 * info.size);
- if (bitvecobj == NULL) {
- free(bitvecobj);
- DECREF(videodata);
- return NULL;
+ if (!(odditem = PyInt_FromLong(1)))
+ goto finally;
}
+ if (!(bitvecobj = PyTuple_New(2 * info.size)))
+ goto finally;
+
for (i = 0; i < 2 * info.size; i++) {
+ int sts;
+
if (SV_GET_FIELD(bitvector, i) == SV_EVEN_FIELD) {
- INCREF(evenitem);
- settupleitem(bitvecobj, i, evenitem);
+ Py_INCREF(evenitem);
+ sts = PyTuple_SetItem(bitvecobj, i, evenitem);
} else {
- INCREF(odditem);
- settupleitem(bitvecobj, i, odditem);
+ Py_INCREF(odditem);
+ sts = PyTuple_SetItem(bitvecobj, i, odditem);
}
+ if (sts < 0)
+ goto finally;
}
- free(bitvector);
} else {
- bitvecobj = None;
- INCREF(None);
+ bitvecobj = Py_None;
+ Py_INCREF(Py_None);
}
- res = mkvalue("((iiiii)OO)", info.format, info.width, info.height,
- info.size, info.samplingrate, videodata, bitvecobj);
- DECREF(videodata);
- DECREF(bitvecobj);
+ res = Py_BuildValue("((iiiii)OO)", info.format,
+ info.width, info.height,
+ info.size, info.samplingrate,
+ videodata, bitvecobj);
+
+ finally:
+ if (bitvector)
+ free(bitvector);
+
+ Py_XDECREF(videodata);
+ Py_XDECREF(bitvecobj);
return res;
}
-static object *
+static PyObject *
sv_CaptureOneFrame(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
svCaptureInfo info;
int format, width, height;
int bytes;
- object *videodata, *res;
+ PyObject *videodata = NULL;
+ PyObject *res = NULL;
- if (!getargs(args, "(iii)", &format, &width, &height))
+ if (!PyArg_Parse(args, "(iii)", &format, &width, &height))
return NULL;
+
info.format = format;
info.width = width;
info.height = height;
info.samplingrate = 0;
if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes))
return sv_error();
- videodata = newsizedstringobject(NULL, bytes);
- if (videodata == NULL)
+
+ if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
return NULL;
- if (svCaptureOneFrame(self->ob_svideo, format, &width, &height,
- getstringvalue(videodata))) {
- DECREF(videodata);
- return sv_error();
+
+ {
+ char* str = PyString_AsString(videodata);
+ if (!str)
+ goto finally;
+
+ if (svCaptureOneFrame(self->ob_svideo, format, &width, &height, str)) {
+ res = sv_error();
+ goto finally;
}
- res = mkvalue("(iiO)", width, height, videodata);
- DECREF(videodata);
+ res = Py_BuildValue("(iiO)", width, height, videodata);
+
+ finally:
+ Py_XDECREF(videodata);
return res;
}
-static object *
+static PyObject *
sv_InitContinuousCapture(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
svCaptureInfo info;
- if (!getargs(args, "(iiiii)", &info.format, &info.width, &info.height,
- &info.size, &info.samplingrate))
+ if (!PyArg_Parse(args, "(iiiii)", &info.format,
+ &info.width, &info.height,
+ &info.size, &info.samplingrate))
return NULL;
if (svInitContinuousCapture(self->ob_svideo, &info))
self->ob_info = info;
- return mkvalue("(iiiii)", info.format, info.width, info.height,
- info.size, info.samplingrate);
+ return Py_BuildValue("(iiiii)", info.format, info.width, info.height,
+ info.size, info.samplingrate);
}
-static object *
+static PyObject *
sv_LoadMap(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
- object *rgb, *v, *cell;
- rgb_tuple *mapp;
+ PyObject *rgb;
+ PyObject *res = NULL;
+ rgb_tuple *mapp = NULL;
int maptype;
- int i, j; /* indices */
+ int i, j; /* indices */
- if (!getargs(args, "(iO)", &maptype, &rgb))
+ if (!PyArg_Parse(args, "(iO)", &maptype, &rgb))
return NULL;
- if (!is_listobject(rgb) || getlistsize(rgb) != 256) {
- err_badarg();
+
+ if (!PyList_Check(rgb) || PyList_Size(rgb) != 256) {
+ PyErr_BadArgument();
return NULL;
}
- mapp = NEW(rgb_tuple, 256);
- if (mapp == NULL)
- return err_nomem();
+
+ if (!(mapp = PyMem_NEW(rgb_tuple, 256)))
+ return PyErr_NoMemory();
+
for (i = 0; i < 256; i++) {
- v = getlistitem(rgb, i);
- if (!is_tupleobject(v) || gettuplesize(v) != 3) {
- DEL(mapp);
- err_badarg();
- return NULL;
+ PyObject* v = PyList_GetItem(rgb, i);
+ if (!v)
+ goto finally;
+
+ if (!PyTuple_Check(v) || PyTuple_Size(v) != 3) {
+ PyErr_BadArgument();
+ goto finally;
}
for (j = 0; j < 3; j++) {
- cell = gettupleitem(v, j);
- if (!is_intobject(cell)) {
- DEL(mapp);
- err_badarg();
- return NULL;
+ PyObject* cell = PyTuple_GetItem(v, j);
+ if (!cell)
+ goto finally;
+
+ if (!PyInt_Check(cell)) {
+ PyErr_BadArgument();
+ goto finally;
}
switch (j) {
- case 0: mapp[i].red = getintvalue(cell); break;
- case 1: mapp[i].blue = getintvalue(cell); break;
- case 2: mapp[i].green = getintvalue(cell); break;
+ case 0: mapp[i].red = PyInt_AsLong(cell); break;
+ case 1: mapp[i].blue = PyInt_AsLong(cell); break;
+ case 2: mapp[i].green = PyInt_AsLong(cell); break;
}
+ if (PyErr_Occurred())
+ goto finally;
}
}
if (svLoadMap(self->ob_svideo, maptype, mapp)) {
- DEL(mapp);
- return sv_error();
+ res = sv_error();
+ goto finally;
}
- DEL(mapp);
+ Py_INCREF(Py_None);
+ res = Py_None;
- INCREF(None);
- return None;
+ finally:
+ PyMem_DEL(mapp);
+ return res;
}
-static object *
+static PyObject *
sv_CloseVideo(self, args)
svobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
if (svCloseVideo(self->ob_svideo))
return sv_error();
- self->ob_svideo = NULL;
- INCREF(None);
- return None;
+ self->ob_svideo = NULL;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
doParams(self, args, func, modified)
svobject *self;
- object *args;
+ PyObject *args;
int (*func)(SV_nodeP, long *, int);
int modified;
{
- object *list, *v;
- long *PVbuffer;
+ PyObject *list;
+ PyObject *res = NULL;
+ long *PVbuffer = NULL;
long length;
int i;
- if (!getargs(args, "O", &list))
+ if (!PyArg_Parse(args, "O", &list))
return NULL;
- if (!is_listobject(list)) {
- err_badarg();
+
+ if (!PyList_Check(list)) {
+ PyErr_BadArgument();
return NULL;
}
- length = getlistsize(list);
- PVbuffer = NEW(long, length);
+
+ if ((length = PyList_Size(list)) < 0)
+ return NULL;
+
+ PVbuffer = PyMem_NEW(long, length);
if (PVbuffer == NULL)
- return err_nomem();
+ return PyErr_NoMemory();
+
for (i = 0; i < length; i++) {
- v = getlistitem(list, i);
- if (!is_intobject(v)) {
- DEL(PVbuffer);
- err_badarg();
- return NULL;
+ PyObject *v = PyList_GetItem(list, i);
+ if (!v)
+ goto finally;
+
+ if (!PyInt_Check(v)) {
+ PyErr_BadArgument();
+ goto finally;
}
- PVbuffer[i] = getintvalue(v);
+ PVbuffer[i] = PyInt_AsLong(v);
+ /* can't just test the return value, because what if the
+ value was -1?!
+ */
+ if (PVbuffer[i] == -1 && PyErr_Occurred())
+ goto finally;
}
if ((*func)(self->ob_svideo, PVbuffer, length)) {
- DEL(PVbuffer);
- return sv_error();
+ res = sv_error();
+ goto finally;
}
if (modified) {
- for (i = 0; i < length; i++)
- setlistitem(list, i, newintobject(PVbuffer[i]));
+ for (i = 0; i < length; i++) {
+ PyObject* v = PyInt_FromLong(PVbuffer[i]);
+ if (!v || PyList_SetItem(list, i, v) < 0)
+ goto finally;
+ }
}
- DEL(PVbuffer);
+ Py_INCREF(Py_None);
+ res = Py_None;
- INCREF(None);
- return None;
+ finally:
+ PyMem_DEL(PVbuffer);
+ return res;
}
-static object *
+static PyObject *
sv_GetParam(self, args)
- object *self, *args;
+ PyObject *self, *args;
{
return doParams(self, args, svGetParam, 1);
}
-static object *
+static PyObject *
sv_GetParamRange(self, args)
- object *self, *args;
+ PyObject *self, *args;
{
return doParams(self, args, svGetParamRange, 1);
}
-static object *
+static PyObject *
sv_SetParam(self, args)
- object *self, *args;
+ PyObject *self, *args;
{
return doParams(self, args, svSetParam, 0);
}
-static struct methodlist svideo_methods[] = {
- {"BindGLWindow", (method)sv_BindGLWindow},
- {"EndContinuousCapture",(method)sv_EndContinuousCapture},
- {"IsVideoDisplayed", (method)sv_IsVideoDisplayed},
- {"OutputOffset", (method)sv_OutputOffset},
- {"PutFrame", (method)sv_PutFrame},
- {"QuerySize", (method)sv_QuerySize},
- {"SetSize", (method)sv_SetSize},
- {"SetStdDefaults", (method)sv_SetStdDefaults},
- {"UseExclusive", (method)sv_UseExclusive},
- {"WindowOffset", (method)sv_WindowOffset},
- {"InitContinuousCapture",(method)sv_InitContinuousCapture},
- {"CaptureBurst", (method)sv_CaptureBurst},
- {"CaptureOneFrame", (method)sv_CaptureOneFrame},
- {"GetCaptureData", (method)sv_GetCaptureData},
- {"CloseVideo", (method)sv_CloseVideo},
- {"LoadMap", (method)sv_LoadMap},
- {"GetParam", (method)sv_GetParam},
- {"GetParamRange", (method)sv_GetParamRange},
- {"SetParam", (method)sv_SetParam},
+static PyMethodDef svideo_methods[] = {
+ {"BindGLWindow", (PyCFunction)sv_BindGLWindow},
+ {"EndContinuousCapture",(PyCFunction)sv_EndContinuousCapture},
+ {"IsVideoDisplayed", (PyCFunction)sv_IsVideoDisplayed},
+ {"OutputOffset", (PyCFunction)sv_OutputOffset},
+ {"PutFrame", (PyCFunction)sv_PutFrame},
+ {"QuerySize", (PyCFunction)sv_QuerySize},
+ {"SetSize", (PyCFunction)sv_SetSize},
+ {"SetStdDefaults", (PyCFunction)sv_SetStdDefaults},
+ {"UseExclusive", (PyCFunction)sv_UseExclusive},
+ {"WindowOffset", (PyCFunction)sv_WindowOffset},
+ {"InitContinuousCapture",(PyCFunction)sv_InitContinuousCapture},
+ {"CaptureBurst", (PyCFunction)sv_CaptureBurst},
+ {"CaptureOneFrame", (PyCFunction)sv_CaptureOneFrame},
+ {"GetCaptureData", (PyCFunction)sv_GetCaptureData},
+ {"CloseVideo", (PyCFunction)sv_CloseVideo},
+ {"LoadMap", (PyCFunction)sv_LoadMap},
+ {"GetParam", (PyCFunction)sv_GetParam},
+ {"GetParamRange", (PyCFunction)sv_GetParamRange},
+ {"SetParam", (PyCFunction)sv_SetParam},
{NULL, NULL} /* sentinel */
};
-static object *
+static PyObject *
sv_conversion(self, args, function, inputfactor, factor)
- object *self, *args;
+ PyObject *self, *args;
void (*function)();
int inputfactor;
float factor;
{
int invert, width, height, inputlength;
- char *input;
- object *output;
+ char *input, *str;
+ PyObject *output;
- if (!getargs(args, "(is#ii)", &invert, &input, &inputlength, &width, &height))
+ if (!PyArg_Parse(args, "(is#ii)", &invert,
+ &input, &inputlength, &width, &height))
return NULL;
if (width * height * inputfactor > inputlength) {
- err_setstr(SvError, "input buffer not long enough");
+ PyErr_SetString(SvError, "input buffer not long enough");
return NULL;
}
- output = newsizedstringobject(NULL, (int) (width * height * factor));
- if (output == NULL)
+ if (!(output = PyString_FromStringAndSize(NULL,
+ (int)(width * height * factor))))
return NULL;
- (*function)(invert, input, getstringvalue(output), width, height);
+ str = PyString_AsString(output);
+ if (!str) {
+ Py_DECREF(output);
+ return NULL;
+ }
+ (*function)(invert, input, str, width, height);
return output;
}
-static object *
+static PyObject *
sv_InterleaveFields(self, args)
- object *self, *args;
+ PyObject *self, *args;
{
return sv_conversion(self, args, svInterleaveFields, 1, 1.0);
}
-static object *
+static PyObject *
sv_RGB8toRGB32(self, args)
- object *self, *args;
+ PyObject *self, *args;
{
return sv_conversion(self, args, svRGB8toRGB32, 1, (float) sizeof(long));
}
-static object *
+static PyObject *
sv_YUVtoRGB(self, args)
- object *self, *args;
+ PyObject *self, *args;
{
return sv_conversion(self, args, svYUVtoRGB, 2, (float) sizeof(long));
}
{
if (self->ob_svideo != NULL)
(void) svCloseVideo(self->ob_svideo);
- DEL(self);
+ PyMem_DEL(self);
}
-static object *
+static PyObject *
svideo_getattr(self, name)
svobject *self;
char *name;
{
- return findmethod(svideo_methods, (object *)self, name);
+ return Py_FindMethod(svideo_methods, (PyObject *)self, name);
}
-typeobject Svtype = {
- OB_HEAD_INIT(&Typetype)
+PyTypeObject Svtype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"sv", /*tp_name*/
sizeof(svobject), /*tp_size*/
0, /*tp_repr*/
};
-static object *
+static PyObject *
newsvobject(svp)
SV_nodeP svp;
{
svobject *p;
- p = NEWOBJ(svobject, &Svtype);
+ p = PyObject_NEW(svobject, &Svtype);
if (p == NULL)
return NULL;
p->ob_svideo = svp;
p->ob_info.width = 0;
p->ob_info.height = 0;
p->ob_info.samplingrate = 0;
- return (object *) p;
+ return (PyObject *) p;
}
-static object *
+static PyObject *
sv_OpenVideo(self, args)
- object *self, *args;
+ PyObject *self, *args;
{
SV_nodeP svp;
- if (!getnoarg(args))
+ if (!PyArg_Parse(args, ""))
return NULL;
svp = svOpenVideo();
return newsvobject(svp);
}
-static struct methodlist sv_methods[] = {
- {"InterleaveFields", (method)sv_InterleaveFields},
- {"RGB8toRGB32", (method)sv_RGB8toRGB32},
- {"YUVtoRGB", (method)sv_YUVtoRGB},
- {"OpenVideo", (method)sv_OpenVideo},
+static PyMethodDef sv_methods[] = {
+ {"InterleaveFields", (PyCFunction)sv_InterleaveFields},
+ {"RGB8toRGB32", (PyCFunction)sv_RGB8toRGB32},
+ {"YUVtoRGB", (PyCFunction)sv_YUVtoRGB},
+ {"OpenVideo", (PyCFunction)sv_OpenVideo},
{NULL, NULL} /* Sentinel */
};
void
initsv()
{
- object *m, *d;
+ PyObject *m, *d;
- m = initmodule("sv", sv_methods);
- d = getmoduledict(m);
+ m = Py_InitModule("sv", sv_methods);
+ d = PyModule_GetDict(m);
- SvError = newstringobject("sv.error");
- if (SvError == NULL || dictinsert(d, "error", SvError) != 0)
- fatal("can't define sv.error");
+ SvError = PyString_FromString("sv.error");
+ if (SvError == NULL || PyDict_SetItemString(d, "error", SvError) != 0)
+ Py_FatalError("can't define sv.error");
}
projects / thirdparty / Python / cpython.git / commitdiff
