Modules/svmodule.c

   1 /* SV module -- interface to the Indigo video board */
   2
   3 /* WARNING! This module is for hardware that we don't have any more,
   4    so it hasn't been tested.  It has been converted to the new coding
   5    style, and it is possible that this conversion has broken something
   6    -- user beware! */
   7
   8 #include <sys/time.h>
   9 #include <svideo.h>
  10 #include "Python.h"
  11 #include "compile.h"
  12 #include "yuv.h"                /* for YUV conversion functions */
  13
  14 typedef struct {
  15         PyObject_HEAD
  16         SV_nodeP ob_svideo;
  17         svCaptureInfo ob_info;
  18 } svobject;
  19
  20 typedef struct {
  21         PyObject_HEAD
  22         void *ob_capture;
  23         int ob_mustunlock;
  24         svCaptureInfo ob_info;
  25         svobject *ob_svideo;
  26 } captureobject;
  27
  28 static PyObject *SvError;               /* exception sv.error */
  29
  30 static PyObject *newcaptureobject(svobject *, void *, int);
  31
  32 /* Set a SV-specific error from svideo_errno and return NULL */
  33 static PyObject *
  34 sv_error(void)
  35 {
  36         PyErr_SetString(SvError, svStrerror(svideo_errno));
  37         return NULL;
  38 }
  39
  40 static PyObject *
  41 svc_conversion(captureobject *self, PyObject *args, void (*function)(), float factor)
  42 {
  43         PyObject *output;
  44         int invert;
  45         char* outstr;
  46
  47         if (!PyArg_Parse(args, "i", &invert))
  48                 return NULL;
  49
  50         if (!(output = PyString_FromStringAndSize(
  51                 NULL,
  52                 (int)(self->ob_info.width * self->ob_info.height * factor))))
  53         {
  54                 return NULL;
  55         }
  56         if (!(outstr = PyString_AsString(output))) {
  57                 Py_DECREF(output);
  58                 return NULL;
  59         }
  60
  61         (*function)((boolean)invert, self->ob_capture,
  62                     outstr,
  63                     self->ob_info.width, self->ob_info.height);
  64
  65         return output;
  66 }
  67
  68 /*
  69  * 3 functions to convert from Starter Video YUV 4:1:1 format to
  70  * Compression Library 4:2:2 Duplicate Chroma format.
  71  */
  72 static PyObject *
  73 svc_YUVtoYUV422DC(captureobject *self, PyObject *args)
  74 {
  75         if (self->ob_info.format != SV_YUV411_FRAMES) {
  76                 PyErr_SetString(SvError, "data has bad format");
  77                 return NULL;
  78         }
  79         return svc_conversion(self, args, yuv_sv411_to_cl422dc, 2.0);
  80 }
  81
  82 static PyObject *
  83 svc_YUVtoYUV422DC_quarter(captureobject *self, PyObject *args)
  84 {
  85         if (self->ob_info.format != SV_YUV411_FRAMES) {
  86                 PyErr_SetString(SvError, "data has bad format");
  87                 return NULL;
  88         }
  89         return svc_conversion(self, args,
  90                               yuv_sv411_to_cl422dc_quartersize, 0.5);
  91 }
  92
  93 static PyObject *
  94 svc_YUVtoYUV422DC_sixteenth(captureobject *self, PyObject *args)
  95 {
  96         if (self->ob_info.format != SV_YUV411_FRAMES) {
  97                 PyErr_SetString(SvError, "data has bad format");
  98                 return NULL;
  99         }
 100         return svc_conversion(self, args,
 101                               yuv_sv411_to_cl422dc_sixteenthsize, 0.125);
 102 }
 103
 104 static PyObject *
 105 svc_YUVtoRGB(captureobject *self, PyObject *args)
 106 {
 107         switch (self->ob_info.format) {
 108         case SV_YUV411_FRAMES:
 109         case SV_YUV411_FRAMES_AND_BLANKING_BUFFER:
 110                 break;
 111         default:
 112                 PyErr_SetString(SvError, "data had bad format");
 113                 return NULL;
 114         }
 115         return svc_conversion(self, args, svYUVtoRGB, (float) sizeof(long));
 116 }
 117
 118 static PyObject *
 119 svc_RGB8toRGB32(captureobject *self, PyObject *args)
 120 {
 121         if (self->ob_info.format != SV_RGB8_FRAMES) {
 122                 PyErr_SetString(SvError, "data has bad format");
 123                 return NULL;
 124         }
 125         return svc_conversion(self, args, svRGB8toRGB32, (float) sizeof(long));
 126 }
 127
 128 static PyObject *
 129 svc_InterleaveFields(captureobject *self, PyObject *args)
 130 {
 131         if (self->ob_info.format != SV_RGB8_FRAMES) {
 132                 PyErr_SetString(SvError, "data has bad format");
 133                 return NULL;
 134         }
 135         return svc_conversion(self, args, svInterleaveFields, 1.0);
 136 }
 137
 138 static PyObject *
 139 svc_GetFields(captureobject *self, PyObject *args)
 140 {
 141         PyObject *f1 = NULL;
 142         PyObject *f2 = NULL;
 143         PyObject *ret = NULL;
 144         int fieldsize;
 145         char* obcapture;
 146
 147         if (self->ob_info.format != SV_RGB8_FRAMES) {
 148                 PyErr_SetString(SvError, "data has bad format");
 149                 return NULL;
 150         }
 151
 152         fieldsize = self->ob_info.width * self->ob_info.height / 2;
 153         obcapture = (char*)self->ob_capture;
 154
 155         if (!(f1 = PyString_FromStringAndSize(obcapture, fieldsize)))
 156                 goto finally;
 157         if (!(f2 = PyString_FromStringAndSize(obcapture + fieldsize,
 158                                               fieldsize)))
 159                 goto finally;
 160         ret = PyTuple_Pack(2, f1, f2);
 161
 162   finally:
 163         Py_XDECREF(f1);
 164         Py_XDECREF(f2);
 165         return ret;
 166 }
 167
 168 static PyObject *
 169 svc_UnlockCaptureData(captureobject *self, PyObject *args)
 170 {
 171         if (!PyArg_Parse(args, ""))
 172                 return NULL;
 173
 174         if (!self->ob_mustunlock) {
 175                 PyErr_SetString(SvError, "buffer should not be unlocked");
 176                 return NULL;
 177         }
 178
 179         if (svUnlockCaptureData(self->ob_svideo->ob_svideo, self->ob_capture))
 180                 return sv_error();
 181
 182         self->ob_mustunlock = 0;
 183
 184         Py_INCREF(Py_None);
 185         return Py_None;
 186 }
 187
 188 #ifdef USE_GL
 189 #include <gl.h>
 190
 191 static PyObject *
 192 svc_lrectwrite(captureobject *self, PyObject *args)
 193 {
 194         Screencoord x1, x2, y1, y2;
 195
 196         if (!PyArg_Parse(args, "(hhhh)", &x1, &x2, &y1, &y2))
 197                 return NULL;
 198
 199         lrectwrite(x1, x2, y1, y2, (unsigned long *) self->ob_capture);
 200
 201         Py_INCREF(Py_None);
 202         return Py_None;
 203 }
 204 #endif
 205
 206 static PyObject *
 207 svc_writefile(captureobject *self, PyObject *args)
 208 {
 209         PyObject *file;
 210         int size;
 211         FILE* fp;
 212
 213         if (!PyArg_Parse(args, "O", &file))
 214                 return NULL;
 215
 216         if (!PyFile_Check(file)) {
 217                 PyErr_SetString(SvError, "not a file object");
 218                 return NULL;
 219         }
 220
 221         if (!(fp = PyFile_AsFile(file)))
 222                 return NULL;
 223
 224         size = self->ob_info.width * self->ob_info.height;
 225
 226         if (fwrite(self->ob_capture, sizeof(long), size, fp) != size) {
 227                 PyErr_SetString(SvError, "writing failed");
 228                 return NULL;
 229         }
 230
 231         Py_INCREF(Py_None);
 232         return Py_None;
 233 }
 234
 235 static PyObject *
 236 svc_FindVisibleRegion(captureobject *self, PyObject *args)
 237 {
 238         void *visible;
 239         int width;
 240
 241         if (!PyArg_Parse(args, ""))
 242                 return NULL;
 243
 244         if (svFindVisibleRegion(self->ob_svideo->ob_svideo,
 245                                 self->ob_capture, &visible,
 246                                 self->ob_info.width))
 247                 return sv_error();
 248
 249         if (visible == NULL) {
 250                 PyErr_SetString(SvError, "data in wrong format");
 251                 return NULL;
 252         }
 253
 254         return newcaptureobject(self->ob_svideo, visible, 0);
 255 }
 256
 257 static PyMethodDef capture_methods[] = {
 258         {"YUVtoRGB",            (PyCFunction)svc_YUVtoRGB, METH_OLDARGS},
 259         {"RGB8toRGB32",         (PyCFunction)svc_RGB8toRGB32, METH_OLDARGS},
 260         {"InterleaveFields",    (PyCFunction)svc_InterleaveFields, METH_OLDARGS},
 261         {"UnlockCaptureData",   (PyCFunction)svc_UnlockCaptureData, METH_OLDARGS},
 262         {"FindVisibleRegion",   (PyCFunction)svc_FindVisibleRegion, METH_OLDARGS},
 263         {"GetFields",           (PyCFunction)svc_GetFields, METH_OLDARGS},
 264         {"YUVtoYUV422DC",       (PyCFunction)svc_YUVtoYUV422DC, METH_OLDARGS},
 265         {"YUVtoYUV422DC_quarter",(PyCFunction)svc_YUVtoYUV422DC_quarter, METH_OLDARGS},
 266         {"YUVtoYUV422DC_sixteenth",(PyCFunction)svc_YUVtoYUV422DC_sixteenth, METH_OLDARGS},
 267 #ifdef USE_GL
 268         {"lrectwrite",          (PyCFunction)svc_lrectwrite, METH_OLDARGS},
 269 #endif
 270         {"writefile",           (PyCFunction)svc_writefile, METH_OLDARGS},
 271         {NULL,                  NULL}           /* sentinel */
 272 };
 273
 274 static void
 275 capture_dealloc(captureobject *self)
 276 {
 277         if (self->ob_capture != NULL) {
 278                 if (self->ob_mustunlock)
 279                         (void)svUnlockCaptureData(self->ob_svideo->ob_svideo,
 280                                                   self->ob_capture);
 281                 self->ob_capture = NULL;
 282                 Py_DECREF(self->ob_svideo);
 283                 self->ob_svideo = NULL;
 284         }
 285         PyObject_Del(self);
 286 }
 287
 288 static PyObject *
 289 capture_getattr(svobject *self, char *name)
 290 {
 291         return Py_FindMethod(capture_methods, (PyObject *)self, name);
 292 }
 293
 294 PyTypeObject Capturetype = {
 295         PyObject_HEAD_INIT(&PyType_Type)
 296         0,                              /*ob_size*/
 297         "sv.capture",                   /*tp_name*/
 298         sizeof(captureobject),          /*tp_size*/
 299         0,                              /*tp_itemsize*/
 300         /* methods */
 301         (destructor)capture_dealloc,    /*tp_dealloc*/
 302         0,                              /*tp_print*/
 303         (getattrfunc)capture_getattr,   /*tp_getattr*/
 304         0,                              /*tp_setattr*/
 305         0,                              /*tp_compare*/
 306         0,                              /*tp_repr*/
 307 };
 308
 309 static PyObject *
 310 newcaptureobject(svobject *self, void *ptr, int mustunlock)
 311 {
 312         captureobject *p;
 313
 314         p = PyObject_New(captureobject, &Capturetype);
 315         if (p == NULL)
 316                 return NULL;
 317         p->ob_svideo = self;
 318         Py_INCREF(self);
 319         p->ob_capture = ptr;
 320         p->ob_mustunlock = mustunlock;
 321         p->ob_info = self->ob_info;
 322         return (PyObject *) p;
 323 }
 324
 325 static PyObject *
 326 sv_GetCaptureData(svobject *self, PyObject *args)
 327 {
 328         void *ptr;
 329         long fieldID;
 330         PyObject *res, *c;
 331
 332         if (!PyArg_Parse(args, ""))
 333                 return NULL;
 334
 335         if (svGetCaptureData(self->ob_svideo, &ptr, &fieldID))
 336                 return sv_error();
 337
 338         if (ptr == NULL) {
 339                 PyErr_SetString(SvError, "no data available");
 340                 return NULL;
 341         }
 342
 343         c = newcaptureobject(self, ptr, 1);
 344         if (c == NULL)
 345                 return NULL;
 346         res = Py_BuildValue("(Oi)", c, fieldID);
 347         Py_DECREF(c);
 348         return res;
 349 }
 350
 351 static PyObject *
 352 sv_BindGLWindow(svobject *self, PyObject *args)
 353 {
 354         long wid;
 355         int mode;
 356
 357         if (!PyArg_Parse(args, "(ii)", &wid, &mode))
 358                 return NULL;
 359
 360         if (svBindGLWindow(self->ob_svideo, wid, mode))
 361                 return sv_error();
 362
 363         Py_INCREF(Py_None);
 364         return Py_None;
 365 }
 366
 367 static PyObject *
 368 sv_EndContinuousCapture(svobject *self, PyObject *args)
 369 {
 370
 371         if (!PyArg_Parse(args, ""))
 372                 return NULL;
 373
 374         if (svEndContinuousCapture(self->ob_svideo))
 375                 return sv_error();
 376
 377         Py_INCREF(Py_None);
 378         return Py_None;
 379 }
 380
 381 static PyObject *
 382 sv_IsVideoDisplayed(svobject *self, PyObject *args)
 383 {
 384         int v;
 385
 386         if (!PyArg_Parse(args, ""))
 387                 return NULL;
 388
 389         v = svIsVideoDisplayed(self->ob_svideo);
 390         if (v == -1)
 391                 return sv_error();
 392
 393         return PyInt_FromLong((long) v);
 394 }
 395
 396 static PyObject *
 397 sv_OutputOffset(svobject *self, PyObject *args)
 398 {
 399         int x_offset;
 400         int y_offset;
 401
 402         if (!PyArg_Parse(args, "(ii)", &x_offset, &y_offset))
 403                 return NULL;
 404
 405         if (svOutputOffset(self->ob_svideo, x_offset, y_offset))
 406                 return sv_error();
 407
 408         Py_INCREF(Py_None);
 409         return Py_None;
 410 }
 411
 412 static PyObject *
 413 sv_PutFrame(svobject *self, PyObject *args)
 414 {
 415         char *buffer;
 416
 417         if (!PyArg_Parse(args, "s", &buffer))
 418                 return NULL;
 419
 420         if (svPutFrame(self->ob_svideo, buffer))
 421                 return sv_error();
 422
 423         Py_INCREF(Py_None);
 424         return Py_None;
 425 }
 426
 427 static PyObject *
 428 sv_QuerySize(svobject *self, PyObject *args)
 429 {
 430         int w;
 431         int h;
 432         int rw;
 433         int rh;
 434
 435         if (!PyArg_Parse(args, "(ii)", &w, &h))
 436                 return NULL;
 437
 438         if (svQuerySize(self->ob_svideo, w, h, &rw, &rh))
 439                 return sv_error();
 440
 441         return Py_BuildValue("(ii)", (long) rw, (long) rh);
 442 }
 443
 444 static PyObject *
 445 sv_SetSize(svobject *self, PyObject *args)
 446 {
 447         int w;
 448         int h;
 449
 450         if (!PyArg_Parse(args, "(ii)", &w, &h))
 451                 return NULL;
 452
 453         if (svSetSize(self->ob_svideo, w, h))
 454                 return sv_error();
 455
 456         Py_INCREF(Py_None);
 457         return Py_None;
 458 }
 459
 460 static PyObject *
 461 sv_SetStdDefaults(svobject *self, PyObject *args)
 462 {
 463
 464         if (!PyArg_Parse(args, ""))
 465                 return NULL;
 466
 467         if (svSetStdDefaults(self->ob_svideo))
 468                 return sv_error();
 469
 470         Py_INCREF(Py_None);
 471         return Py_None;
 472 }
 473
 474 static PyObject *
 475 sv_UseExclusive(svobject *self, PyObject *args)
 476 {
 477         boolean onoff;
 478         int mode;
 479
 480         if (!PyArg_Parse(args, "(ii)", &onoff, &mode))
 481                 return NULL;
 482
 483         if (svUseExclusive(self->ob_svideo, onoff, mode))
 484                 return sv_error();
 485
 486         Py_INCREF(Py_None);
 487         return Py_None;
 488 }
 489
 490 static PyObject *
 491 sv_WindowOffset(svobject *self, PyObject *args)
 492 {
 493         int x_offset;
 494         int y_offset;
 495
 496         if (!PyArg_Parse(args, "(ii)", &x_offset, &y_offset))
 497                 return NULL;
 498
 499         if (svWindowOffset(self->ob_svideo, x_offset, y_offset))
 500                 return sv_error();
 501
 502         Py_INCREF(Py_None);
 503         return Py_None;
 504 }
 505
 506 static PyObject *
 507 sv_CaptureBurst(svobject *self, PyObject *args)
 508 {
 509         int bytes, i;
 510         svCaptureInfo info;
 511         void *bitvector = NULL;
 512         PyObject *videodata = NULL;
 513         PyObject *bitvecobj = NULL;
 514         PyObject *res = NULL;
 515         static PyObject *evenitem, *odditem;
 516
 517         if (!PyArg_Parse(args, "(iiiii)", &info.format,
 518                          &info.width, &info.height,
 519                          &info.size, &info.samplingrate))
 520                 return NULL;
 521
 522         switch (info.format) {
 523         case SV_RGB8_FRAMES:
 524                 bitvector = malloc(SV_BITVEC_SIZE(info.size));
 525                 break;
 526         case SV_YUV411_FRAMES_AND_BLANKING_BUFFER:
 527                 break;
 528         default:
 529                 PyErr_SetString(SvError, "illegal format specified");
 530                 return NULL;
 531         }
 532
 533         if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes)) {
 534                 res = sv_error();
 535                 goto finally;
 536         }
 537
 538         if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
 539                 goto finally;
 540
 541         /* XXX -- need to do something about the bitvector */
 542         {
 543                 char* str = PyString_AsString(videodata);
 544                 if (!str)
 545                         goto finally;
 546
 547                 if (svCaptureBurst(self->ob_svideo, &info, str, bitvector)) {
 548                         res = sv_error();
 549                         goto finally;
 550                 }
 551         }
 552
 553         if (bitvector) {
 554                 if (evenitem == NULL) {
 555                         if (!(evenitem = PyInt_FromLong(0)))
 556                                 goto finally;
 557                 }
 558                 if (odditem == NULL) {
 559                         if (!(odditem = PyInt_FromLong(1)))
 560                                 goto finally;
 561                 }
 562                 if (!(bitvecobj = PyTuple_New(2 * info.size)))
 563                         goto finally;
 564
 565                 for (i = 0; i < 2 * info.size; i++) {
 566                         int sts;
 567
 568                         if (SV_GET_FIELD(bitvector, i) == SV_EVEN_FIELD) {
 569                                 Py_INCREF(evenitem);
 570                                 sts = PyTuple_SetItem(bitvecobj, i, evenitem);
 571                         } else {
 572                                 Py_INCREF(odditem);
 573                                 sts = PyTuple_SetItem(bitvecobj, i, odditem);
 574                         }
 575                         if (sts < 0)
 576                                 goto finally;
 577                 }
 578         } else {
 579                 bitvecobj = Py_None;
 580                 Py_INCREF(Py_None);
 581         }
 582
 583         res = Py_BuildValue("((iiiii)OO)", info.format,
 584                             info.width, info.height,
 585                             info.size, info.samplingrate,
 586                             videodata, bitvecobj);
 587
 588   finally:
 589         if (bitvector)
 590                 free(bitvector);
 591
 592         Py_XDECREF(videodata);
 593         Py_XDECREF(bitvecobj);
 594         return res;
 595 }
 596
 597 static PyObject *
 598 sv_CaptureOneFrame(svobject *self, PyObject *args)
 599 {
 600         svCaptureInfo info;
 601         int format, width, height;
 602         int bytes;
 603         PyObject *videodata = NULL;
 604         PyObject *res = NULL;
 605         char *str;
 606
 607         if (!PyArg_Parse(args, "(iii)", &format, &width, &height))
 608                 return NULL;
 609
 610         info.format = format;
 611         info.width = width;
 612         info.height = height;
 613         info.size = 0;
 614         info.samplingrate = 0;
 615         if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes))
 616                 return sv_error();
 617
 618         if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
 619                 return NULL;
 620
 621         str = PyString_AsString(videodata);
 622         if (!str)
 623                 goto finally;
 624
 625         if (svCaptureOneFrame(self->ob_svideo, format, &width, &height, str)) {
 626                 res = sv_error();
 627                 goto finally;
 628         }
 629
 630         res = Py_BuildValue("(iiO)", width, height, videodata);
 631
 632   finally:
 633         Py_XDECREF(videodata);
 634         return res;
 635 }
 636
 637 static PyObject *
 638 sv_InitContinuousCapture(svobject *self, PyObject *args)
 639 {
 640         svCaptureInfo info;
 641
 642         if (!PyArg_Parse(args, "(iiiii)", &info.format,
 643                          &info.width, &info.height,
 644                          &info.size, &info.samplingrate))
 645                 return NULL;
 646
 647         if (svInitContinuousCapture(self->ob_svideo, &info))
 648                 return sv_error();
 649
 650         self->ob_info = info;
 651
 652         return Py_BuildValue("(iiiii)", info.format, info.width, info.height,
 653                              info.size, info.samplingrate);
 654 }
 655
 656 static PyObject *
 657 sv_LoadMap(svobject *self, PyObject *args)
 658 {
 659         PyObject *rgb;
 660         PyObject *res = NULL;
 661         rgb_tuple *mapp = NULL;
 662         int maptype;
 663         int i, j;                            /* indices */
 664
 665         if (!PyArg_Parse(args, "(iO)", &maptype, &rgb))
 666                 return NULL;
 667
 668         if (!PyList_Check(rgb) || PyList_Size(rgb) != 256) {
 669                 PyErr_BadArgument();
 670                 return NULL;
 671         }
 672
 673         if (!(mapp = PyMem_NEW(rgb_tuple, 256)))
 674                 return PyErr_NoMemory();
 675
 676         for (i = 0; i < 256; i++) {
 677                 PyObject* v = PyList_GetItem(rgb, i);
 678                 if (!v)
 679                         goto finally;
 680
 681                 if (!PyTuple_Check(v) || PyTuple_Size(v) != 3) {
 682                         PyErr_BadArgument();
 683                         goto finally;
 684                 }
 685                 for (j = 0; j < 3; j++) {
 686                         PyObject* cell = PyTuple_GetItem(v, j);
 687                         if (!cell)
 688                                 goto finally;
 689
 690                         if (!PyInt_Check(cell)) {
 691                                 PyErr_BadArgument();
 692                                 goto finally;
 693                         }
 694                         switch (j) {
 695                         case 0: mapp[i].red = PyInt_AsLong(cell); break;
 696                         case 1: mapp[i].blue = PyInt_AsLong(cell); break;
 697                         case 2: mapp[i].green = PyInt_AsLong(cell); break;
 698                         }
 699                         if (PyErr_Occurred())
 700                                 goto finally;
 701                 }
 702         }
 703
 704         if (svLoadMap(self->ob_svideo, maptype, mapp)) {
 705                 res = sv_error();
 706                 goto finally;
 707         }
 708
 709         Py_INCREF(Py_None);
 710         res = Py_None;
 711
 712   finally:
 713         PyMem_DEL(mapp);
 714         return res;
 715 }
 716
 717 static PyObject *
 718 sv_CloseVideo(svobject *self, PyObject *args)
 719 {
 720         if (!PyArg_Parse(args, ""))
 721                 return NULL;
 722
 723         if (svCloseVideo(self->ob_svideo))
 724                 return sv_error();
 725
 726         self->ob_svideo = NULL;
 727         Py_INCREF(Py_None);
 728         return Py_None;
 729 }
 730
 731 static PyObject *
 732 doParams(svobject *self, PyObject *args,
 733          int (*func)(SV_nodeP, long *, int), int modified)
 734 {
 735         PyObject *list;
 736         PyObject *res = NULL;
 737         long *PVbuffer = NULL;
 738         long length;
 739         int i;
 740
 741         if (!PyArg_Parse(args, "O", &list))
 742                 return NULL;
 743
 744         if (!PyList_Check(list)) {
 745                 PyErr_BadArgument();
 746                 return NULL;
 747         }
 748
 749         if ((length = PyList_Size(list)) < 0)
 750                 return NULL;
 751
 752         PVbuffer = PyMem_NEW(long, length);
 753         if (PVbuffer == NULL)
 754                 return PyErr_NoMemory();
 755
 756         for (i = 0; i < length; i++) {
 757                 PyObject *v = PyList_GetItem(list, i);
 758                 if (!v)
 759                         goto finally;
 760
 761                 if (!PyInt_Check(v)) {
 762                         PyErr_BadArgument();
 763                         goto finally;
 764                 }
 765                 PVbuffer[i] = PyInt_AsLong(v);
 766                 /* can't just test the return value, because what if the
 767                    value was -1?!
 768                 */
 769                 if (PVbuffer[i] == -1 && PyErr_Occurred())
 770                         goto finally;
 771         }
 772
 773         if ((*func)(self->ob_svideo, PVbuffer, length)) {
 774                 res = sv_error();
 775                 goto finally;
 776         }
 777
 778         if (modified) {
 779                 for (i = 0; i < length; i++) {
 780                         PyObject* v = PyInt_FromLong(PVbuffer[i]);
 781                         if (!v || PyList_SetItem(list, i, v) < 0)
 782                                 goto finally;
 783                 }
 784         }
 785
 786         Py_INCREF(Py_None);
 787         res = Py_None;
 788
 789   finally:
 790         PyMem_DEL(PVbuffer);
 791         return res;
 792 }
 793
 794 static PyObject *
 795 sv_GetParam(PyObject *self, PyObject *args)
 796 {
 797         return doParams(self, args, svGetParam, 1);
 798 }
 799
 800 static PyObject *
 801 sv_GetParamRange(PyObject *self, PyObject *args)
 802 {
 803         return doParams(self, args, svGetParamRange, 1);
 804 }
 805
 806 static PyObject *
 807 sv_SetParam(PyObject *self, PyObject *args)
 808 {
 809         return doParams(self, args, svSetParam, 0);
 810 }
 811
 812 static PyMethodDef svideo_methods[] = {
 813         {"BindGLWindow",        (PyCFunction)sv_BindGLWindow, METH_OLDARGS},
 814         {"EndContinuousCapture",(PyCFunction)sv_EndContinuousCapture, METH_OLDARGS},
 815         {"IsVideoDisplayed",    (PyCFunction)sv_IsVideoDisplayed, METH_OLDARGS},
 816         {"OutputOffset",        (PyCFunction)sv_OutputOffset, METH_OLDARGS},
 817         {"PutFrame",            (PyCFunction)sv_PutFrame, METH_OLDARGS},
 818         {"QuerySize",           (PyCFunction)sv_QuerySize, METH_OLDARGS},
 819         {"SetSize",             (PyCFunction)sv_SetSize, METH_OLDARGS},
 820         {"SetStdDefaults",      (PyCFunction)sv_SetStdDefaults, METH_OLDARGS},
 821         {"UseExclusive",        (PyCFunction)sv_UseExclusive, METH_OLDARGS},
 822         {"WindowOffset",        (PyCFunction)sv_WindowOffset, METH_OLDARGS},
 823         {"InitContinuousCapture",(PyCFunction)sv_InitContinuousCapture, METH_OLDARGS},
 824         {"CaptureBurst",        (PyCFunction)sv_CaptureBurst, METH_OLDARGS},
 825         {"CaptureOneFrame",     (PyCFunction)sv_CaptureOneFrame, METH_OLDARGS},
 826         {"GetCaptureData",      (PyCFunction)sv_GetCaptureData, METH_OLDARGS},
 827         {"CloseVideo",          (PyCFunction)sv_CloseVideo, METH_OLDARGS},
 828         {"LoadMap",             (PyCFunction)sv_LoadMap, METH_OLDARGS},
 829         {"GetParam",            (PyCFunction)sv_GetParam, METH_OLDARGS},
 830         {"GetParamRange",       (PyCFunction)sv_GetParamRange, METH_OLDARGS},
 831         {"SetParam",            (PyCFunction)sv_SetParam, METH_OLDARGS},
 832         {NULL,                  NULL}           /* sentinel */
 833 };
 834
 835 static PyObject *
 836 sv_conversion(PyObject *self, PyObject *args, void (*function)(),
 837               int inputfactor, float factor)
 838 {
 839         int invert, width, height, inputlength;
 840         char *input, *str;
 841         PyObject *output;
 842
 843         if (!PyArg_Parse(args, "(is#ii)", &invert,
 844                          &input, &inputlength, &width, &height))
 845                 return NULL;
 846
 847         if (width * height * inputfactor > inputlength) {
 848                 PyErr_SetString(SvError, "input buffer not long enough");
 849                 return NULL;
 850         }
 851
 852         if (!(output = PyString_FromStringAndSize(NULL,
 853                                               (int)(width * height * factor))))
 854                 return NULL;
 855
 856         str = PyString_AsString(output);
 857         if (!str) {
 858                 Py_DECREF(output);
 859                 return NULL;
 860         }
 861         (*function)(invert, input, str, width, height);
 862
 863         return output;
 864 }
 865
 866 static PyObject *
 867 sv_InterleaveFields(PyObject *self, PyObject *args)
 868 {
 869         return sv_conversion(self, args, svInterleaveFields, 1, 1.0);
 870 }
 871
 872 static PyObject *
 873 sv_RGB8toRGB32(PyObject *self, PyObject *args)
 874 {
 875         return sv_conversion(self, args, svRGB8toRGB32, 1, (float) sizeof(long));
 876 }
 877
 878 static PyObject *
 879 sv_YUVtoRGB(PyObject *self, PyObject *args)
 880 {
 881         return sv_conversion(self, args, svYUVtoRGB, 2, (float) sizeof(long));
 882 }
 883
 884 static void
 885 svideo_dealloc(svobject *self)
 886 {
 887         if (self->ob_svideo != NULL)
 888                 (void) svCloseVideo(self->ob_svideo);
 889         PyObject_Del(self);
 890 }
 891
 892 static PyObject *
 893 svideo_getattr(svobject *self, char *name)
 894 {
 895         return Py_FindMethod(svideo_methods, (PyObject *)self, name);
 896 }
 897
 898 PyTypeObject Svtype = {
 899         PyObject_HEAD_INIT(&PyType_Type)
 900         0,                      /*ob_size*/
 901         "sv.sv",                /*tp_name*/
 902         sizeof(svobject),       /*tp_size*/
 903         0,                      /*tp_itemsize*/
 904         /* methods */
 905         (destructor)svideo_dealloc, /*tp_dealloc*/
 906         0,                      /*tp_print*/
 907         (getattrfunc)svideo_getattr, /*tp_getattr*/
 908         0,                      /*tp_setattr*/
 909         0,                      /*tp_compare*/
 910         0,                      /*tp_repr*/
 911 };
 912
 913 static PyObject *
 914 newsvobject(SV_nodeP svp)
 915 {
 916         svobject *p;
 917
 918         p = PyObject_New(svobject, &Svtype);
 919         if (p == NULL)
 920                 return NULL;
 921         p->ob_svideo = svp;
 922         p->ob_info.format = 0;
 923         p->ob_info.size = 0;
 924         p->ob_info.width = 0;
 925         p->ob_info.height = 0;
 926         p->ob_info.samplingrate = 0;
 927         return (PyObject *) p;
 928 }
 929
 930 static PyObject *
 931 sv_OpenVideo(PyObject *self, PyObject *args)
 932 {
 933         SV_nodeP svp;
 934
 935         if (!PyArg_Parse(args, ""))
 936                 return NULL;
 937
 938         svp = svOpenVideo();
 939         if (svp == NULL)
 940                 return sv_error();
 941
 942         return newsvobject(svp);
 943 }
 944
 945 static PyMethodDef sv_methods[] = {
 946         {"InterleaveFields",    (PyCFunction)sv_InterleaveFields, METH_OLDARGS},
 947         {"RGB8toRGB32",         (PyCFunction)sv_RGB8toRGB32, METH_OLDARGS},
 948         {"YUVtoRGB",            (PyCFunction)sv_YUVtoRGB, METH_OLDARGS},
 949         {"OpenVideo",           (PyCFunction)sv_OpenVideo, METH_OLDARGS},
 950         {NULL,                  NULL}   /* Sentinel */
 951 };
 952
 953 void
 954 initsv(void)
 955 {
 956         PyObject *m, *d;
 957
 958         m = Py_InitModule("sv", sv_methods);
 959         if (m == NULL)
 960                 return;
 961         d = PyModule_GetDict(m);
 962
 963         SvError = PyErr_NewException("sv.error", NULL, NULL);
 964         if (SvError == NULL || PyDict_SetItemString(d, "error", SvError) != 0)
 965                 return;
 966 }