source: python/trunk/Modules/svmodule.c@ 281

Last change on this file since 281 was 2, checked in by Yuri Dario, 15 years ago

Initial import for vendor code.
  • Property svn:eol-style set to native
File size: 20.6 KB
Line 
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
14typedef struct {
15 PyObject_HEAD
16 SV_nodeP ob_svideo;
17 svCaptureInfo ob_info;
18} svobject;
19
20typedef struct {
21 PyObject_HEAD
22 void *ob_capture;
23 int ob_mustunlock;
24 svCaptureInfo ob_info;
25 svobject *ob_svideo;
26} captureobject;
27
28static PyObject *SvError; /* exception sv.error */
29
30static PyObject *newcaptureobject(svobject *, void *, int);
31
32/* Set a SV-specific error from svideo_errno and return NULL */
33static PyObject *
34sv_error(void)
35{
36 PyErr_SetString(SvError, svStrerror(svideo_errno));
37 return NULL;
38}
39
40static PyObject *
41svc_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 */
72static PyObject *
73svc_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
82static PyObject *
83svc_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
93static PyObject *
94svc_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
104static PyObject *
105svc_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
118static PyObject *
119svc_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
128static PyObject *
129svc_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
138static PyObject *
139svc_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
168static PyObject *
169svc_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
191static PyObject *
192svc_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
206static PyObject *
207svc_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
235static PyObject *
236svc_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
257static 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
274static void
275capture_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
288static PyObject *
289capture_getattr(svobject *self, char *name)
290{
291 return Py_FindMethod(capture_methods, (PyObject *)self, name);
292}
293
294PyTypeObject 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
309static PyObject *
310newcaptureobject(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
325static PyObject *
326sv_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
351static PyObject *
352sv_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
367static PyObject *
368sv_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
381static PyObject *
382sv_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
396static PyObject *
397sv_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
412static PyObject *
413sv_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
427static PyObject *
428sv_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
444static PyObject *
445sv_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
460static PyObject *
461sv_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
474static PyObject *
475sv_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
490static PyObject *
491sv_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
506static PyObject *
507sv_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
597static PyObject *
598sv_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
637static PyObject *
638sv_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
656static PyObject *
657sv_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
717static PyObject *
718sv_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
731static PyObject *
732doParams(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
794static PyObject *
795sv_GetParam(PyObject *self, PyObject *args)
796{
797 return doParams(self, args, svGetParam, 1);
798}
799
800static PyObject *
801sv_GetParamRange(PyObject *self, PyObject *args)
802{
803 return doParams(self, args, svGetParamRange, 1);
804}
805
806static PyObject *
807sv_SetParam(PyObject *self, PyObject *args)
808{
809 return doParams(self, args, svSetParam, 0);
810}
811
812static 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
835static PyObject *
836sv_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
866static PyObject *
867sv_InterleaveFields(PyObject *self, PyObject *args)
868{
869 return sv_conversion(self, args, svInterleaveFields, 1, 1.0);
870}
871
872static PyObject *
873sv_RGB8toRGB32(PyObject *self, PyObject *args)
874{
875 return sv_conversion(self, args, svRGB8toRGB32, 1, (float) sizeof(long));
876}
877
878static PyObject *
879sv_YUVtoRGB(PyObject *self, PyObject *args)
880{
881 return sv_conversion(self, args, svYUVtoRGB, 2, (float) sizeof(long));
882}
883
884static void
885svideo_dealloc(svobject *self)
886{
887 if (self->ob_svideo != NULL)
888 (void) svCloseVideo(self->ob_svideo);
889 PyObject_Del(self);
890}
891
892static PyObject *
893svideo_getattr(svobject *self, char *name)
894{
895 return Py_FindMethod(svideo_methods, (PyObject *)self, name);
896}
897
898PyTypeObject 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
913static PyObject *
914newsvobject(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
930static PyObject *
931sv_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
945static 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
953void
954initsv(void)
955{
956 PyObject *m, *d;
957
958 if (PyErr_WarnPy3k("the sv module has been removed in "
959 "Python 3.0", 2) < 0)
960 return;
961
962 m = Py_InitModule("sv", sv_methods);
963 if (m == NULL)
964 return;
965 d = PyModule_GetDict(m);
966
967 SvError = PyErr_NewException("sv.error", NULL, NULL);
968 if (SvError == NULL || PyDict_SetItemString(d, "error", SvError) != 0)
969 return;
970}
Note: See TracBrowser for help on using the repository browser.