--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Modules/svmodule.c	Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,970 @@
+/* SV module -- interface to the Indigo video board */
+
+/* WARNING! This module is for hardware that we don't have any more,
+   so it hasn't been tested.  It has been converted to the new coding
+   style, and it is possible that this conversion has broken something
+   -- user beware! */
+
+#include <sys/time.h>
+#include <svideo.h>
+#include "Python.h"
+#include "compile.h"
+#include "yuv.h"		/* for YUV conversion functions */
+
+typedef struct {
+	PyObject_HEAD
+	SV_nodeP ob_svideo;
+	svCaptureInfo ob_info;
+} svobject;
+
+typedef struct {
+	PyObject_HEAD
+	void *ob_capture;
+	int ob_mustunlock;
+	svCaptureInfo ob_info;
+	svobject *ob_svideo;
+} captureobject;
+
+static PyObject *SvError;		/* exception sv.error */
+
+static PyObject *newcaptureobject(svobject *, void *, int);
+
+/* Set a SV-specific error from svideo_errno and return NULL */
+static PyObject *
+sv_error(void)
+{
+	PyErr_SetString(SvError, svStrerror(svideo_errno));
+	return NULL;
+}
+
+static PyObject *
+svc_conversion(captureobject *self, PyObject *args, void (*function)(),	float factor)
+{
+	PyObject *output;
+	int invert;
+	char* outstr;
+
+	if (!PyArg_Parse(args, "i", &invert))
+		return 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,
+		    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 PyObject *
+svc_YUVtoYUV422DC(captureobject *self, PyObject *args)
+{
+	if (self->ob_info.format != SV_YUV411_FRAMES) {
+		PyErr_SetString(SvError, "data has bad format");
+		return NULL;
+	}
+	return svc_conversion(self, args, yuv_sv411_to_cl422dc, 2.0);
+}
+
+static PyObject *
+svc_YUVtoYUV422DC_quarter(captureobject *self, PyObject *args)
+{
+	if (self->ob_info.format != SV_YUV411_FRAMES) {
+		PyErr_SetString(SvError, "data has bad format");
+		return NULL;
+	}
+	return svc_conversion(self, args,
+			      yuv_sv411_to_cl422dc_quartersize, 0.5);
+}
+
+static PyObject *
+svc_YUVtoYUV422DC_sixteenth(captureobject *self, PyObject *args)
+{
+	if (self->ob_info.format != SV_YUV411_FRAMES) {
+		PyErr_SetString(SvError, "data has bad format");
+		return NULL;
+	}
+	return svc_conversion(self, args,
+			      yuv_sv411_to_cl422dc_sixteenthsize, 0.125);
+}
+
+static PyObject *
+svc_YUVtoRGB(captureobject *self, PyObject *args)
+{
+	switch (self->ob_info.format) {
+	case SV_YUV411_FRAMES:
+	case SV_YUV411_FRAMES_AND_BLANKING_BUFFER:
+		break;
+	default:
+		PyErr_SetString(SvError, "data had bad format");
+		return NULL;
+	}
+	return svc_conversion(self, args, svYUVtoRGB, (float) sizeof(long));
+}
+
+static PyObject *
+svc_RGB8toRGB32(captureobject *self, PyObject *args)
+{
+	if (self->ob_info.format != SV_RGB8_FRAMES) {
+		PyErr_SetString(SvError, "data has bad format");
+		return NULL;
+	}
+	return svc_conversion(self, args, svRGB8toRGB32, (float) sizeof(long));
+}
+
+static PyObject *
+svc_InterleaveFields(captureobject *self, PyObject *args)
+{
+	if (self->ob_info.format != SV_RGB8_FRAMES) {
+		PyErr_SetString(SvError, "data has bad format");
+		return NULL;
+	}
+	return svc_conversion(self, args, svInterleaveFields, 1.0);
+}
+
+static PyObject *
+svc_GetFields(captureobject *self, PyObject *args)
+{
+	PyObject *f1 = NULL;
+	PyObject *f2 = NULL;
+	PyObject *ret = NULL;
+	int fieldsize;
+	char* obcapture;
+
+	if (self->ob_info.format != SV_RGB8_FRAMES) {
+		PyErr_SetString(SvError, "data has bad format");
+		return NULL;
+	}
+
+	fieldsize = self->ob_info.width * self->ob_info.height / 2;
+	obcapture = (char*)self->ob_capture;
+	
+	if (!(f1 = PyString_FromStringAndSize(obcapture, fieldsize)))
+		goto finally;
+	if (!(f2 = PyString_FromStringAndSize(obcapture + fieldsize,
+					      fieldsize)))
+		goto finally;
+	ret = PyTuple_Pack(2, f1, f2);
+
+  finally:
+	Py_XDECREF(f1);
+	Py_XDECREF(f2);
+	return ret;
+}
+	
+static PyObject *
+svc_UnlockCaptureData(captureobject *self, PyObject *args)
+{
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	if (!self->ob_mustunlock) {
+		PyErr_SetString(SvError, "buffer should not be unlocked");
+		return NULL;
+	}
+
+	if (svUnlockCaptureData(self->ob_svideo->ob_svideo, self->ob_capture))
+		return sv_error();
+
+	self->ob_mustunlock = 0;
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+#ifdef USE_GL
+#include <gl.h>
+
+static PyObject *
+svc_lrectwrite(captureobject *self, PyObject *args)
+{
+	Screencoord 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);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+#endif
+
+static PyObject *
+svc_writefile(captureobject *self, PyObject *args)
+{
+	PyObject *file;
+	int size;
+	FILE* fp;
+
+	if (!PyArg_Parse(args, "O", &file))
+		return NULL;
+
+	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, fp) != size) {
+		PyErr_SetString(SvError, "writing failed");
+		return NULL;
+	}
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+svc_FindVisibleRegion(captureobject *self, PyObject *args)
+{
+	void *visible;
+	int width;
+
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	if (svFindVisibleRegion(self->ob_svideo->ob_svideo,
+				self->ob_capture, &visible,
+				self->ob_info.width))
+		return sv_error();
+
+	if (visible == NULL) {
+		PyErr_SetString(SvError, "data in wrong format");
+		return NULL;
+	}
+
+	return newcaptureobject(self->ob_svideo, visible, 0);
+}
+
+static PyMethodDef capture_methods[] = {
+	{"YUVtoRGB",		(PyCFunction)svc_YUVtoRGB, METH_OLDARGS},
+	{"RGB8toRGB32",		(PyCFunction)svc_RGB8toRGB32, METH_OLDARGS},
+	{"InterleaveFields",	(PyCFunction)svc_InterleaveFields, METH_OLDARGS},
+	{"UnlockCaptureData",	(PyCFunction)svc_UnlockCaptureData, METH_OLDARGS},
+	{"FindVisibleRegion",	(PyCFunction)svc_FindVisibleRegion, METH_OLDARGS},
+	{"GetFields",		(PyCFunction)svc_GetFields, METH_OLDARGS},
+	{"YUVtoYUV422DC",	(PyCFunction)svc_YUVtoYUV422DC, METH_OLDARGS},
+	{"YUVtoYUV422DC_quarter",(PyCFunction)svc_YUVtoYUV422DC_quarter, METH_OLDARGS},
+	{"YUVtoYUV422DC_sixteenth",(PyCFunction)svc_YUVtoYUV422DC_sixteenth, METH_OLDARGS},
+#ifdef USE_GL
+	{"lrectwrite",		(PyCFunction)svc_lrectwrite, METH_OLDARGS},
+#endif
+	{"writefile",		(PyCFunction)svc_writefile, METH_OLDARGS},
+	{NULL,			NULL} 		/* sentinel */
+};
+
+static void
+capture_dealloc(captureobject *self)
+{
+	if (self->ob_capture != NULL) {
+		if (self->ob_mustunlock)
+			(void)svUnlockCaptureData(self->ob_svideo->ob_svideo,
+						  self->ob_capture);
+		self->ob_capture = NULL;
+		Py_DECREF(self->ob_svideo);
+		self->ob_svideo = NULL;
+	}
+	PyObject_Del(self);
+}
+
+static PyObject *
+capture_getattr(svobject *self, char *name)
+{
+	return Py_FindMethod(capture_methods, (PyObject *)self, name);
+}
+
+PyTypeObject Capturetype = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,				/*ob_size*/
+	"sv.capture",			/*tp_name*/
+	sizeof(captureobject),		/*tp_size*/
+	0,				/*tp_itemsize*/
+	/* methods */
+	(destructor)capture_dealloc,	/*tp_dealloc*/
+	0,				/*tp_print*/
+	(getattrfunc)capture_getattr,	/*tp_getattr*/
+	0,				/*tp_setattr*/
+	0,				/*tp_compare*/
+	0,				/*tp_repr*/
+};
+
+static PyObject *
+newcaptureobject(svobject *self, void *ptr, int mustunlock)
+{
+	captureobject *p;
+
+	p = PyObject_New(captureobject, &Capturetype);
+	if (p == NULL)
+		return NULL;
+	p->ob_svideo = self;
+	Py_INCREF(self);
+	p->ob_capture = ptr;
+	p->ob_mustunlock = mustunlock;
+	p->ob_info = self->ob_info;
+	return (PyObject *) p;
+}
+
+static PyObject *
+sv_GetCaptureData(svobject *self, PyObject *args)
+{
+	void *ptr;
+	long fieldID;
+	PyObject *res, *c;
+
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	if (svGetCaptureData(self->ob_svideo, &ptr, &fieldID))
+		return sv_error();
+
+	if (ptr == NULL) {
+		PyErr_SetString(SvError, "no data available");
+		return NULL;
+	}
+
+	c = newcaptureobject(self, ptr, 1);
+	if (c == NULL)
+		return NULL;
+	res = Py_BuildValue("(Oi)", c, fieldID);
+	Py_DECREF(c);
+	return res;
+}
+
+static PyObject *
+sv_BindGLWindow(svobject *self, PyObject *args)
+{
+	long wid;
+	int mode;
+
+	if (!PyArg_Parse(args, "(ii)", &wid, &mode))
+		return NULL;
+
+	if (svBindGLWindow(self->ob_svideo, wid, mode))
+		return sv_error();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_EndContinuousCapture(svobject *self, PyObject *args)
+{
+
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	if (svEndContinuousCapture(self->ob_svideo))
+		return sv_error();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_IsVideoDisplayed(svobject *self, PyObject *args)
+{
+	int v;
+
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	v = svIsVideoDisplayed(self->ob_svideo);
+	if (v == -1)
+		return sv_error();
+
+	return PyInt_FromLong((long) v);
+}
+
+static PyObject *
+sv_OutputOffset(svobject *self, PyObject *args)
+{
+	int x_offset;
+	int 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();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_PutFrame(svobject *self, PyObject *args)
+{
+	char *buffer;
+
+	if (!PyArg_Parse(args, "s", &buffer))
+		return NULL;
+
+	if (svPutFrame(self->ob_svideo, buffer))
+		return sv_error();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_QuerySize(svobject *self, PyObject *args)
+{
+	int w;
+	int h;
+	int rw;
+	int rh;
+
+	if (!PyArg_Parse(args, "(ii)", &w, &h))
+		return NULL;
+
+	if (svQuerySize(self->ob_svideo, w, h, &rw, &rh))
+		return sv_error();
+
+	return Py_BuildValue("(ii)", (long) rw, (long) rh);
+}
+
+static PyObject *
+sv_SetSize(svobject *self, PyObject *args)
+{
+	int w;
+	int h;
+
+	if (!PyArg_Parse(args, "(ii)", &w, &h))
+		return NULL;
+
+	if (svSetSize(self->ob_svideo, w, h))
+		return sv_error();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_SetStdDefaults(svobject *self, PyObject *args)
+{
+
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	if (svSetStdDefaults(self->ob_svideo))
+		return sv_error();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_UseExclusive(svobject *self, PyObject *args)
+{
+	boolean onoff;
+	int mode;
+
+	if (!PyArg_Parse(args, "(ii)", &onoff, &mode))
+		return NULL;
+
+	if (svUseExclusive(self->ob_svideo, onoff, mode))
+		return sv_error();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_WindowOffset(svobject *self, PyObject *args)
+{
+	int x_offset;
+	int 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();
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+sv_CaptureBurst(svobject *self, PyObject *args)
+{
+	int bytes, i;
+	svCaptureInfo info;
+	void *bitvector = NULL;
+	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_RGB8_FRAMES:
+		bitvector = malloc(SV_BITVEC_SIZE(info.size));
+		break;
+	case SV_YUV411_FRAMES_AND_BLANKING_BUFFER:
+		break;
+	default:
+		PyErr_SetString(SvError, "illegal format specified");
+		return NULL;
+	}
+
+	if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes)) {
+		res = sv_error();
+		goto finally;
+	}
+
+	if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
+		goto finally;
+
+	/* XXX -- need to do something about the bitvector */
+	{
+		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) {
+			if (!(evenitem = PyInt_FromLong(0)))
+				goto finally;
+		}
+		if (odditem == 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) {
+				Py_INCREF(evenitem);
+				sts = PyTuple_SetItem(bitvecobj, i, evenitem);
+			} else {
+				Py_INCREF(odditem);
+				sts = PyTuple_SetItem(bitvecobj, i, odditem);
+			}
+			if (sts < 0)
+				goto finally;
+		}
+	} else {
+		bitvecobj = Py_None;
+		Py_INCREF(Py_None);
+	}
+
+	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 PyObject *
+sv_CaptureOneFrame(svobject *self, PyObject *args)
+{
+	svCaptureInfo info;
+	int format, width, height;
+	int bytes;
+	PyObject *videodata = NULL;
+	PyObject *res = NULL;
+	char *str;
+	
+	if (!PyArg_Parse(args, "(iii)", &format, &width, &height))
+		return NULL;
+
+	info.format = format;
+	info.width = width;
+	info.height = height;
+	info.size = 0;
+	info.samplingrate = 0;
+	if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes))
+		return sv_error();
+
+	if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
+		return NULL;
+	
+	str = PyString_AsString(videodata);
+	if (!str)
+		goto finally;
+
+	if (svCaptureOneFrame(self->ob_svideo, format, &width, &height, str)) {
+		res = sv_error();
+		goto finally;
+	}
+
+	res = Py_BuildValue("(iiO)", width, height, videodata);
+
+  finally:
+	Py_XDECREF(videodata);
+	return res;
+}
+
+static PyObject *
+sv_InitContinuousCapture(svobject *self, PyObject *args)
+{
+	svCaptureInfo info;
+
+	if (!PyArg_Parse(args, "(iiiii)", &info.format,
+			 &info.width, &info.height,
+			 &info.size, &info.samplingrate))
+		return NULL;
+
+	if (svInitContinuousCapture(self->ob_svideo, &info))
+		return sv_error();
+
+	self->ob_info = info;
+
+	return Py_BuildValue("(iiiii)", info.format, info.width, info.height,
+			     info.size, info.samplingrate);
+}
+
+static PyObject *
+sv_LoadMap(svobject *self, PyObject *args)
+{
+	PyObject *rgb;
+	PyObject *res = NULL;
+	rgb_tuple *mapp = NULL;
+	int maptype;
+	int i, j;			     /* indices */
+
+	if (!PyArg_Parse(args, "(iO)", &maptype, &rgb))
+		return NULL;
+
+	if (!PyList_Check(rgb) || PyList_Size(rgb) != 256) {
+		PyErr_BadArgument();
+		return NULL;
+	}
+
+	if (!(mapp = PyMem_NEW(rgb_tuple, 256)))
+		return PyErr_NoMemory();
+
+	for (i = 0; i < 256; i++) {
+		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++) {
+			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 = 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)) {
+		res = sv_error();
+		goto finally;
+	}
+
+	Py_INCREF(Py_None);
+	res = Py_None;
+
+  finally:
+	PyMem_DEL(mapp);
+	return res;
+}
+		
+static PyObject *
+sv_CloseVideo(svobject *self, PyObject *args)
+{
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	if (svCloseVideo(self->ob_svideo))
+		return sv_error();
+
+	self->ob_svideo = NULL;
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+doParams(svobject *self, PyObject *args,
+         int (*func)(SV_nodeP, long *, int), int modified)
+{
+	PyObject *list;
+	PyObject *res = NULL;
+	long *PVbuffer = NULL;
+	long length;
+	int i;
+	
+	if (!PyArg_Parse(args, "O", &list))
+		return NULL;
+
+	if (!PyList_Check(list)) {
+		PyErr_BadArgument();
+		return NULL;
+	}
+
+	if ((length = PyList_Size(list)) < 0)
+		return NULL;
+
+	PVbuffer = PyMem_NEW(long, length);
+	if (PVbuffer == NULL)
+		return PyErr_NoMemory();
+
+	for (i = 0; i < length; i++) {
+		PyObject *v = PyList_GetItem(list, i);
+		if (!v)
+			goto finally;
+
+		if (!PyInt_Check(v)) {
+			PyErr_BadArgument();
+			goto finally;
+		}
+		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)) {
+		res = sv_error();
+		goto finally;
+	}
+
+	if (modified) {
+		for (i = 0; i < length; i++) {
+			PyObject* v = PyInt_FromLong(PVbuffer[i]);
+			if (!v || PyList_SetItem(list, i, v) < 0)
+				goto finally;
+		}
+	}
+
+	Py_INCREF(Py_None);
+	res = Py_None;
+
+  finally:
+	PyMem_DEL(PVbuffer);
+	return res;
+}
+
+static PyObject *
+sv_GetParam(PyObject *self, PyObject *args)
+{
+	return doParams(self, args, svGetParam, 1);
+}
+
+static PyObject *
+sv_GetParamRange(PyObject *self, PyObject *args)
+{
+	return doParams(self, args, svGetParamRange, 1);
+}
+
+static PyObject *
+sv_SetParam(PyObject *self, PyObject *args)
+{
+	return doParams(self, args, svSetParam, 0);
+}
+
+static PyMethodDef svideo_methods[] = {
+	{"BindGLWindow",	(PyCFunction)sv_BindGLWindow, METH_OLDARGS},
+	{"EndContinuousCapture",(PyCFunction)sv_EndContinuousCapture, METH_OLDARGS},
+	{"IsVideoDisplayed",	(PyCFunction)sv_IsVideoDisplayed, METH_OLDARGS},
+	{"OutputOffset",	(PyCFunction)sv_OutputOffset, METH_OLDARGS},
+	{"PutFrame",		(PyCFunction)sv_PutFrame, METH_OLDARGS},
+	{"QuerySize",		(PyCFunction)sv_QuerySize, METH_OLDARGS},
+	{"SetSize",		(PyCFunction)sv_SetSize, METH_OLDARGS},
+	{"SetStdDefaults",	(PyCFunction)sv_SetStdDefaults, METH_OLDARGS},
+	{"UseExclusive",	(PyCFunction)sv_UseExclusive, METH_OLDARGS},
+	{"WindowOffset",	(PyCFunction)sv_WindowOffset, METH_OLDARGS},
+	{"InitContinuousCapture",(PyCFunction)sv_InitContinuousCapture, METH_OLDARGS},
+	{"CaptureBurst",	(PyCFunction)sv_CaptureBurst, METH_OLDARGS},
+	{"CaptureOneFrame",	(PyCFunction)sv_CaptureOneFrame, METH_OLDARGS},
+	{"GetCaptureData",	(PyCFunction)sv_GetCaptureData, METH_OLDARGS},
+	{"CloseVideo",		(PyCFunction)sv_CloseVideo, METH_OLDARGS},
+	{"LoadMap",		(PyCFunction)sv_LoadMap, METH_OLDARGS},
+	{"GetParam",		(PyCFunction)sv_GetParam, METH_OLDARGS},
+	{"GetParamRange",	(PyCFunction)sv_GetParamRange, METH_OLDARGS},
+	{"SetParam",		(PyCFunction)sv_SetParam, METH_OLDARGS},
+	{NULL,			NULL} 		/* sentinel */
+};
+
+static PyObject *
+sv_conversion(PyObject *self, PyObject *args, void (*function)(),
+              int inputfactor, float factor)
+{
+	int invert, width, height, inputlength;
+	char *input, *str;
+	PyObject *output;
+
+	if (!PyArg_Parse(args, "(is#ii)", &invert,
+			 &input, &inputlength, &width, &height))
+		return NULL;
+
+	if (width * height * inputfactor > inputlength) {
+		PyErr_SetString(SvError, "input buffer not long enough");
+		return NULL;
+	}
+
+	if (!(output = PyString_FromStringAndSize(NULL,
+					      (int)(width * height * factor))))
+		return NULL;
+
+	str = PyString_AsString(output);
+	if (!str) {
+		Py_DECREF(output);
+		return NULL;
+	}
+	(*function)(invert, input, str, width, height);
+
+	return output;
+}
+
+static PyObject *
+sv_InterleaveFields(PyObject *self, PyObject *args)
+{
+	return sv_conversion(self, args, svInterleaveFields, 1, 1.0);
+}
+
+static PyObject *
+sv_RGB8toRGB32(PyObject *self, PyObject *args)
+{
+	return sv_conversion(self, args, svRGB8toRGB32, 1, (float) sizeof(long));
+}
+
+static PyObject *
+sv_YUVtoRGB(PyObject *self, PyObject *args)
+{
+	return sv_conversion(self, args, svYUVtoRGB, 2, (float) sizeof(long));
+}
+
+static void
+svideo_dealloc(svobject *self)
+{
+	if (self->ob_svideo != NULL)
+		(void) svCloseVideo(self->ob_svideo);
+	PyObject_Del(self);
+}
+
+static PyObject *
+svideo_getattr(svobject *self, char *name)
+{
+	return Py_FindMethod(svideo_methods, (PyObject *)self, name);
+}
+
+PyTypeObject Svtype = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,			/*ob_size*/
+	"sv.sv",		/*tp_name*/
+	sizeof(svobject),	/*tp_size*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	(destructor)svideo_dealloc, /*tp_dealloc*/
+	0,			/*tp_print*/
+	(getattrfunc)svideo_getattr, /*tp_getattr*/
+	0,			/*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+};
+
+static PyObject *
+newsvobject(SV_nodeP svp)
+{
+	svobject *p;
+
+	p = PyObject_New(svobject, &Svtype);
+	if (p == NULL)
+		return NULL;
+	p->ob_svideo = svp;
+	p->ob_info.format = 0;
+	p->ob_info.size = 0;
+	p->ob_info.width = 0;
+	p->ob_info.height = 0;
+	p->ob_info.samplingrate = 0;
+	return (PyObject *) p;
+}
+
+static PyObject *
+sv_OpenVideo(PyObject *self, PyObject *args)
+{
+	SV_nodeP svp;
+
+	if (!PyArg_Parse(args, ""))
+		return NULL;
+
+	svp = svOpenVideo();
+	if (svp == NULL)
+		return sv_error();
+
+	return newsvobject(svp);
+}
+
+static PyMethodDef sv_methods[] = {
+	{"InterleaveFields",	(PyCFunction)sv_InterleaveFields, METH_OLDARGS},
+	{"RGB8toRGB32",		(PyCFunction)sv_RGB8toRGB32, METH_OLDARGS},
+	{"YUVtoRGB",		(PyCFunction)sv_YUVtoRGB, METH_OLDARGS},
+	{"OpenVideo",		(PyCFunction)sv_OpenVideo, METH_OLDARGS},
+	{NULL,			NULL}	/* Sentinel */
+};
+
+void
+initsv(void)
+{
+	PyObject *m, *d;
+	
+	if (PyErr_WarnPy3k("the sv module has been removed in "
+	                   "Python 3.0", 2) < 0)
+	    return;
+
+	m = Py_InitModule("sv", sv_methods);
+	if (m == NULL)
+		return;
+	d = PyModule_GetDict(m);
+
+	SvError = PyErr_NewException("sv.error", NULL, NULL);
+	if (SvError == NULL || PyDict_SetItemString(d, "error", SvError) != 0)
+		return;
+}