source: vendor/python/2.5/Modules/svmodule.c@ 3225

Last change on this file since 3225 was 3225, checked in by bird, 19 years ago

Python 2.5
File size: 20.5 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