Modules/svmodule.c

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