?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove an unnecessary check from test_decimal.
[python.git] / Modules / clmodule.c
blobd3e0edf3e5b14ea80b74e06ed100e90d9317bd4c
1
2
3 /* Cl objects */
4
5 #define CLDEBUG
6
7 #include <stdarg.h>
8 #include <cl.h>
9 #if defined(CL_JPEG_SOFTWARE) && !defined(CL_JPEG_COSMO)
10 #include <dmedia/cl_cosmo.h>
11 #endif
12 #include "Python.h"
13
14 typedef struct {
15 PyObject_HEAD
16 int ob_isCompressor; /* Compressor or Decompressor */
17 CL_Handle ob_compressorHdl;
18 int *ob_paramtypes;
19 int ob_nparams;
20 } clobject;
21
22 static PyObject *ClError; /* exception cl.error */
23
24 static int error_handler_called = 0;
25
26 /*
27 * We want to use the function prototypes that are available in the C
28 * compiler on the SGI. Because of that, we need to declare the first
29 * argument of the compressor and decompressor methods as "object *",
30 * even though they are really "clobject *". Therefore we cast the
31 * argument to the proper type using this macro.
32 */
33 #define SELF ((clobject *) self)
34
35 /********************************************************************
36 Utility routines.
37 ********************************************************************/
38 static void
39 cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...)
40 {
41 va_list ap;
42 char errbuf[BUFSIZ]; /* hopefully big enough */
43 char *p;
44
45 if (PyErr_Occurred()) /* don't change existing error */
46 return;
47 error_handler_called = 1;
48 va_start(ap, fmt);
49 vsprintf(errbuf, fmt, ap);
50 va_end(ap);
51 p = &errbuf[strlen(errbuf) - 1]; /* swat the line feed */
52 if (*p == '\n')
53 *p = 0;
54 PyErr_SetString(ClError, errbuf);
55 }
56
57 /*
58 * This assumes that params are always in the range 0 to some maximum.
59 */
60 static int
61 param_type_is_float(clobject *self, int param)
62 {
63 int bufferlength;
64
65 if (self->ob_paramtypes == NULL) {
66 error_handler_called = 0;
67 bufferlength = clQueryParams(self->ob_compressorHdl, 0, 0);
68 if (error_handler_called)
69 return -1;
70
71 self->ob_paramtypes = PyMem_NEW(int, bufferlength);
72 if (self->ob_paramtypes == NULL)
73 return -1;
74 self->ob_nparams = bufferlength / 2;
75
76 (void) clQueryParams(self->ob_compressorHdl,
77 self->ob_paramtypes, bufferlength);
78 if (error_handler_called) {
79 PyMem_DEL(self->ob_paramtypes);
80 self->ob_paramtypes = NULL;
81 return -1;
82 }
83 }
84
85 if (param < 0 || param >= self->ob_nparams)
86 return -1;
87
88 if (self->ob_paramtypes[param*2 + 1] == CL_FLOATING_ENUM_VALUE ||
89 self->ob_paramtypes[param*2 + 1] == CL_FLOATING_RANGE_VALUE)
90 return 1;
91 else
92 return 0;
93 }
94
95 /********************************************************************
96 Single image compression/decompression.
97 ********************************************************************/
98 static PyObject *
99 cl_CompressImage(PyObject *self, PyObject *args)
100 {
101 int compressionScheme, width, height, originalFormat;
102 float compressionRatio;
103 int frameBufferSize, compressedBufferSize;
104 char *frameBuffer;
105 PyObject *compressedBuffer;
106
107 if (!PyArg_ParseTuple(args, "iiiifs#", &compressionScheme,
108 &width, &height,
109 &originalFormat, &compressionRatio, &frameBuffer,
110 &frameBufferSize))
111 return NULL;
112
113 retry:
114 compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
115 if (compressedBuffer == NULL)
116 return NULL;
117
118 compressedBufferSize = frameBufferSize;
119 error_handler_called = 0;
120 if (clCompressImage(compressionScheme, width, height, originalFormat,
121 compressionRatio, (void *) frameBuffer,
122 &compressedBufferSize,
123 (void *) PyString_AsString(compressedBuffer))
124 == FAILURE || error_handler_called) {
125 Py_DECREF(compressedBuffer);
126 if (!error_handler_called)
127 PyErr_SetString(ClError, "clCompressImage failed");
128 return NULL;
129 }
130
131 if (compressedBufferSize > frameBufferSize) {
132 frameBufferSize = compressedBufferSize;
133 Py_DECREF(compressedBuffer);
134 goto retry;
135 }
136
137 if (compressedBufferSize < frameBufferSize)
138 _PyString_Resize(&compressedBuffer, compressedBufferSize);
139
140 return compressedBuffer;
141 }
142
143 static PyObject *
144 cl_DecompressImage(PyObject *self, PyObject *args)
145 {
146 int compressionScheme, width, height, originalFormat;
147 char *compressedBuffer;
148 int compressedBufferSize, frameBufferSize;
149 PyObject *frameBuffer;
150
151 if (!PyArg_ParseTuple(args, "iiiis#", &compressionScheme, &width, &height,
152 &originalFormat, &compressedBuffer,
153 &compressedBufferSize))
154 return NULL;
155
156 frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);
157
158 frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
159 if (frameBuffer == NULL)
160 return NULL;
161
162 error_handler_called = 0;
163 if (clDecompressImage(compressionScheme, width, height, originalFormat,
164 compressedBufferSize, compressedBuffer,
165 (void *) PyString_AsString(frameBuffer))
166 == FAILURE || error_handler_called) {
167 Py_DECREF(frameBuffer);
168 if (!error_handler_called)
169 PyErr_SetString(ClError, "clDecompressImage failed");
170 return NULL;
171 }
172
173 return frameBuffer;
174 }
175
176 /********************************************************************
177 Sequential compression/decompression.
178 ********************************************************************/
179 #define CheckCompressor(self) if ((self)->ob_compressorHdl == NULL) { \
180 PyErr_SetString(PyExc_RuntimeError, "(de)compressor not active"); \
181 return NULL; \
182 }
183
184 static PyObject *
185 doClose(clobject *self, int (*close_func)(CL_Handle))
186 {
187 CheckCompressor(self);
188
189 error_handler_called = 0;
190 if ((*close_func)(self->ob_compressorHdl) == FAILURE ||
191 error_handler_called) {
192 if (!error_handler_called)
193 PyErr_SetString(ClError, "close failed");
194 return NULL;
195 }
196
197 self->ob_compressorHdl = NULL;
198
199 if (self->ob_paramtypes)
200 PyMem_DEL(self->ob_paramtypes);
201 self->ob_paramtypes = NULL;
202
203 Py_INCREF(Py_None);
204 return Py_None;
205 }
206
207 static PyObject *
208 clm_CloseCompressor(PyObject *self)
209 {
210 return doClose(SELF, clCloseCompressor);
211 }
212
213 static PyObject *
214 clm_CloseDecompressor(PyObject *self)
215 {
216 return doClose(SELF, clCloseDecompressor);
217 }
218
219 static PyObject *
220 clm_Compress(PyObject *self, PyObject *args)
221 {
222 int numberOfFrames;
223 int frameBufferSize, compressedBufferSize, size;
224 char *frameBuffer;
225 PyObject *data;
226
227 CheckCompressor(SELF);
228
229 if (!PyArg_Parse(args, "(is#)", &numberOfFrames,
230 &frameBuffer, &frameBufferSize))
231 return NULL;
232
233 error_handler_called = 0;
234 size = clGetParam(SELF->ob_compressorHdl, CL_COMPRESSED_BUFFER_SIZE);
235 compressedBufferSize = size;
236 if (error_handler_called)
237 return NULL;
238
239 data = PyString_FromStringAndSize(NULL, size);
240 if (data == NULL)
241 return NULL;
242
243 error_handler_called = 0;
244 if (clCompress(SELF->ob_compressorHdl, numberOfFrames,
245 (void *) frameBuffer, &compressedBufferSize,
246 (void *) PyString_AsString(data)) == FAILURE ||
247 error_handler_called) {
248 Py_DECREF(data);
249 if (!error_handler_called)
250 PyErr_SetString(ClError, "compress failed");
251 return NULL;
252 }
253
254 if (compressedBufferSize < size)
255 if (_PyString_Resize(&data, compressedBufferSize))
256 return NULL;
257
258 if (compressedBufferSize > size) {
259 /* we didn't get all "compressed" data */
260 Py_DECREF(data);
261 PyErr_SetString(ClError,
262 "compressed data is more than fitted");
263 return NULL;
264 }
265
266 return data;
267 }
268
269 static PyObject *
270 clm_Decompress(PyObject *self, PyObject *args)
271 {
272 PyObject *data;
273 int numberOfFrames;
274 char *compressedData;
275 int compressedDataSize, dataSize;
276
277 CheckCompressor(SELF);
278
279 if (!PyArg_Parse(args, "(is#)", &numberOfFrames, &compressedData,
280 &compressedDataSize))
281 return NULL;
282
283 error_handler_called = 0;
284 dataSize = clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE);
285 if (error_handler_called)
286 return NULL;
287
288 data = PyString_FromStringAndSize(NULL, dataSize);
289 if (data == NULL)
290 return NULL;
291
292 error_handler_called = 0;
293 if (clDecompress(SELF->ob_compressorHdl, numberOfFrames,
294 compressedDataSize, (void *) compressedData,
295 (void *) PyString_AsString(data)) == FAILURE ||
296 error_handler_called) {
297 Py_DECREF(data);
298 if (!error_handler_called)
299 PyErr_SetString(ClError, "decompress failed");
300 return NULL;
301 }
302
303 return data;
304 }
305
306 static PyObject *
307 doParams(clobject *self, PyObject *args, int (*func)(CL_Handle, int *, int),
308 int modified)
309 {
310 PyObject *list, *v;
311 int *PVbuffer;
312 int length;
313 int i;
314 float number;
315
316 CheckCompressor(self);
317
318 if (!PyArg_Parse(args, "O", &list))
319 return NULL;
320 if (!PyList_Check(list)) {
321 PyErr_BadArgument();
322 return NULL;
323 }
324 length = PyList_Size(list);
325 PVbuffer = PyMem_NEW(int, length);
326 if (PVbuffer == NULL)
327 return PyErr_NoMemory();
328 for (i = 0; i < length; i++) {
329 v = PyList_GetItem(list, i);
330 if (PyFloat_Check(v)) {
331 number = PyFloat_AsDouble(v);
332 PVbuffer[i] = CL_TypeIsInt(number);
333 } else if (PyInt_Check(v)) {
334 PVbuffer[i] = PyInt_AsLong(v);
335 if ((i & 1) &&
336 param_type_is_float(self, PVbuffer[i-1]) > 0) {
337 number = PVbuffer[i];
338 PVbuffer[i] = CL_TypeIsInt(number);
339 }
340 } else {
341 PyMem_DEL(PVbuffer);
342 PyErr_BadArgument();
343 return NULL;
344 }
345 }
346
347 error_handler_called = 0;
348 (*func)(self->ob_compressorHdl, PVbuffer, length);
349 if (error_handler_called) {
350 PyMem_DEL(PVbuffer);
351 return NULL;
352 }
353
354 if (modified) {
355 for (i = 0; i < length; i++) {
356 if ((i & 1) &&
357 param_type_is_float(self, PVbuffer[i-1]) > 0) {
358 number = CL_TypeIsFloat(PVbuffer[i]);
359 v = PyFloat_FromDouble(number);
360 } else
361 v = PyInt_FromLong(PVbuffer[i]);
362 PyList_SetItem(list, i, v);
363 }
364 }
365
366 PyMem_DEL(PVbuffer);
367
368 Py_INCREF(Py_None);
369 return Py_None;
370 }
371
372 static PyObject *
373 clm_GetParams(PyObject *self, PyObject *args)
374 {
375 return doParams(SELF, args, clGetParams, 1);
376 }
377
378 static PyObject *
379 clm_SetParams(PyObject *self, PyObject *args)
380 {
381 return doParams(SELF, args, clSetParams, 0);
382 }
383
384 static PyObject *
385 do_get(clobject *self, PyObject *args, int (*func)(CL_Handle, int))
386 {
387 int paramID, value;
388 float fvalue;
389
390 CheckCompressor(self);
391
392 if (!PyArg_Parse(args, "i", &paramID))
393 return NULL;
394
395 error_handler_called = 0;
396 value = (*func)(self->ob_compressorHdl, paramID);
397 if (error_handler_called)
398 return NULL;
399
400 if (param_type_is_float(self, paramID) > 0) {
401 fvalue = CL_TypeIsFloat(value);
402 return PyFloat_FromDouble(fvalue);
403 }
404
405 return PyInt_FromLong(value);
406 }
407
408 static PyObject *
409 clm_GetParam(PyObject *self, PyObject *args)
410 {
411 return do_get(SELF, args, clGetParam);
412 }
413
414 static PyObject *
415 clm_GetDefault(PyObject *self, PyObject *args)
416 {
417 return do_get(SELF, args, clGetDefault);
418 }
419
420 static PyObject *
421 clm_SetParam(PyObject *self, PyObject *args)
422 {
423 int paramID, value;
424 float fvalue;
425
426 CheckCompressor(SELF);
427
428 if (!PyArg_Parse(args, "(ii)", &paramID, &value)) {
429 PyErr_Clear();
430 if (!PyArg_Parse(args, "(if)", &paramID, &fvalue)) {
431 PyErr_Clear();
432 PyErr_SetString(PyExc_TypeError,
433 "bad argument list (format '(ii)' or '(if)')");
434 return NULL;
435 }
436 value = CL_TypeIsInt(fvalue);
437 } else {
438 if (param_type_is_float(SELF, paramID) > 0) {
439 fvalue = value;
440 value = CL_TypeIsInt(fvalue);
441 }
442 }
443
444 error_handler_called = 0;
445 value = clSetParam(SELF->ob_compressorHdl, paramID, value);
446 if (error_handler_called)
447 return NULL;
448
449 if (param_type_is_float(SELF, paramID) > 0)
450 return PyFloat_FromDouble(CL_TypeIsFloat(value));
451 else
452 return PyInt_FromLong(value);
453 }
454
455 static PyObject *
456 clm_GetParamID(PyObject *self, PyObject *args)
457 {
458 char *name;
459 int value;
460
461 CheckCompressor(SELF);
462
463 if (!PyArg_Parse(args, "s", &name))
464 return NULL;
465
466 error_handler_called = 0;
467 value = clGetParamID(SELF->ob_compressorHdl, name);
468 if (value == FAILURE || error_handler_called) {
469 if (!error_handler_called)
470 PyErr_SetString(ClError, "getparamid failed");
471 return NULL;
472 }
473
474 return PyInt_FromLong(value);
475 }
476
477 static PyObject *
478 clm_QueryParams(PyObject *self)
479 {
480 int bufferlength;
481 int *PVbuffer;
482 PyObject *list;
483 int i;
484
485 CheckCompressor(SELF);
486
487 error_handler_called = 0;
488 bufferlength = clQueryParams(SELF->ob_compressorHdl, 0, 0);
489 if (error_handler_called)
490 return NULL;
491
492 PVbuffer = PyMem_NEW(int, bufferlength);
493 if (PVbuffer == NULL)
494 return PyErr_NoMemory();
495
496 bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer,
497 bufferlength);
498 if (error_handler_called) {
499 PyMem_DEL(PVbuffer);
500 return NULL;
501 }
502
503 list = PyList_New(bufferlength);
504 if (list == NULL) {
505 PyMem_DEL(PVbuffer);
506 return NULL;
507 }
508
509 for (i = 0; i < bufferlength; i++) {
510 if (i & 1)
511 PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
512 else if (PVbuffer[i] == 0) {
513 Py_INCREF(Py_None);
514 PyList_SetItem(list, i, Py_None);
515 } else
516 PyList_SetItem(list, i,
517 PyString_FromString((char *) PVbuffer[i]));
518 }
519
520 PyMem_DEL(PVbuffer);
521
522 return list;
523 }
524
525 static PyObject *
526 clm_GetMinMax(PyObject *self, PyObject *args)
527 {
528 int param, min, max;
529 float fmin, fmax;
530
531 CheckCompressor(SELF);
532
533 if (!PyArg_Parse(args, "i", &param))
534 return NULL;
535
536 clGetMinMax(SELF->ob_compressorHdl, param, &min, &max);
537
538 if (param_type_is_float(SELF, param) > 0) {
539 fmin = CL_TypeIsFloat(min);
540 fmax = CL_TypeIsFloat(max);
541 return Py_BuildValue("(ff)", fmin, fmax);
542 }
543
544 return Py_BuildValue("(ii)", min, max);
545 }
546
547 static PyObject *
548 clm_GetName(PyObject *self, PyObject *args)
549 {
550 int param;
551 char *name;
552
553 CheckCompressor(SELF);
554
555 if (!PyArg_Parse(args, "i", &param))
556 return NULL;
557
558 error_handler_called = 0;
559 name = clGetName(SELF->ob_compressorHdl, param);
560 if (name == NULL || error_handler_called) {
561 if (!error_handler_called)
562 PyErr_SetString(ClError, "getname failed");
563 return NULL;
564 }
565
566 return PyString_FromString(name);
567 }
568
569 static PyObject *
570 clm_QuerySchemeFromHandle(PyObject *self)
571 {
572 CheckCompressor(SELF);
573 return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
574 }
575
576 static PyObject *
577 clm_ReadHeader(PyObject *self, PyObject *args)
578 {
579 char *header;
580 int headerSize;
581
582 CheckCompressor(SELF);
583
584 if (!PyArg_Parse(args, "s#", &header, &headerSize))
585 return NULL;
586
587 return PyInt_FromLong(clReadHeader(SELF->ob_compressorHdl,
588 headerSize, header));
589 }
590
591 static PyMethodDef compressor_methods[] = {
592 {"close", clm_CloseCompressor, METH_NOARGS}, /* alias */
593 {"CloseCompressor", clm_CloseCompressor, METH_NOARGS},
594 {"Compress", clm_Compress, METH_OLDARGS},
595 {"GetDefault", clm_GetDefault, METH_OLDARGS},
596 {"GetMinMax", clm_GetMinMax, METH_OLDARGS},
597 {"GetName", clm_GetName, METH_OLDARGS},
598 {"GetParam", clm_GetParam, METH_OLDARGS},
599 {"GetParamID", clm_GetParamID, METH_OLDARGS},
600 {"GetParams", clm_GetParams, METH_OLDARGS},
601 {"QueryParams", clm_QueryParams, METH_NOARGS},
602 {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS},
603 {"SetParam", clm_SetParam, METH_OLDARGS},
604 {"SetParams", clm_SetParams, METH_OLDARGS},
605 {NULL, NULL} /* sentinel */
606 };
607
608 static PyMethodDef decompressor_methods[] = {
609 {"close", clm_CloseDecompressor, METH_NOARGS}, /* alias */
610 {"CloseDecompressor", clm_CloseDecompressor, METH_NOARGS},
611 {"Decompress", clm_Decompress, METH_OLDARGS},
612 {"GetDefault", clm_GetDefault, METH_OLDARGS},
613 {"GetMinMax", clm_GetMinMax, METH_OLDARGS},
614 {"GetName", clm_GetName, METH_OLDARGS},
615 {"GetParam", clm_GetParam, METH_OLDARGS},
616 {"GetParamID", clm_GetParamID, METH_OLDARGS},
617 {"GetParams", clm_GetParams, METH_OLDARGS},
618 {"ReadHeader", clm_ReadHeader, METH_OLDARGS},
619 {"QueryParams", clm_QueryParams, METH_NOARGS},
620 {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS},
621 {"SetParam", clm_SetParam, METH_OLDARGS},
622 {"SetParams", clm_SetParams, METH_OLDARGS},
623 {NULL, NULL} /* sentinel */
624 };
625
626 static void
627 cl_dealloc(PyObject *self)
628 {
629 if (SELF->ob_compressorHdl) {
630 if (SELF->ob_isCompressor)
631 clCloseCompressor(SELF->ob_compressorHdl);
632 else
633 clCloseDecompressor(SELF->ob_compressorHdl);
634 }
635 PyObject_Del(self);
636 }
637
638 static PyObject *
639 cl_getattr(PyObject *self, char *name)
640 {
641 if (SELF->ob_isCompressor)
642 return Py_FindMethod(compressor_methods, self, name);
643 else
644 return Py_FindMethod(decompressor_methods, self, name);
645 }
646
647 static PyTypeObject Cltype = {
648 PyObject_HEAD_INIT(&PyType_Type)
649 0, /*ob_size*/
650 "cl.cl", /*tp_name*/
651 sizeof(clobject), /*tp_size*/
652 0, /*tp_itemsize*/
653 /* methods */
654 (destructor)cl_dealloc, /*tp_dealloc*/
655 0, /*tp_print*/
656 (getattrfunc)cl_getattr, /*tp_getattr*/
657 0, /*tp_setattr*/
658 0, /*tp_compare*/
659 0, /*tp_repr*/
660 0, /*tp_as_number*/
661 0, /*tp_as_sequence*/
662 0, /*tp_as_mapping*/
663 };
664
665 static PyObject *
666 doOpen(PyObject *self, PyObject *args, int (*open_func)(int, CL_Handle *),
667 int iscompressor)
668 {
669 int scheme;
670 clobject *new;
671
672 if (!PyArg_ParseTuple(args, "i", &scheme))
673 return NULL;
674
675 new = PyObject_New(clobject, &Cltype);
676 if (new == NULL)
677 return NULL;
678
679 new->ob_compressorHdl = NULL;
680 new->ob_isCompressor = iscompressor;
681 new->ob_paramtypes = NULL;
682
683 error_handler_called = 0;
684 if ((*open_func)(scheme, &new->ob_compressorHdl) == FAILURE ||
685 error_handler_called) {
686 Py_DECREF(new);
687 if (!error_handler_called)
688 PyErr_SetString(ClError, "Open(De)Compressor failed");
689 return NULL;
690 }
691 return (PyObject *)new;
692 }
693
694 static PyObject *
695 cl_OpenCompressor(PyObject *self, PyObject *args)
696 {
697 return doOpen(self, args, clOpenCompressor, 1);
698 }
699
700 static PyObject *
701 cl_OpenDecompressor(PyObject *self, PyObject *args)
702 {
703 return doOpen(self, args, clOpenDecompressor, 0);
704 }
705
706 static PyObject *
707 cl_QueryScheme(PyObject *self, PyObject *args)
708 {
709 char *header;
710 int headerlen;
711 int scheme;
712
713 if (!PyArg_ParseTuple(args, "s#", &header, &headerlen))
714 return NULL;
715
716 scheme = clQueryScheme(header);
717 if (scheme < 0) {
718 PyErr_SetString(ClError, "unknown compression scheme");
719 return NULL;
720 }
721
722 return PyInt_FromLong(scheme);
723 }
724
725 static PyObject *
726 cl_QueryMaxHeaderSize(PyObject *self, PyObject *args)
727 {
728 int scheme;
729
730 if (!PyArg_ParseTuple(args, "i", &scheme))
731 return NULL;
732
733 return PyInt_FromLong(clQueryMaxHeaderSize(scheme));
734 }
735
736 static PyObject *
737 cl_QueryAlgorithms(PyObject *self, PyObject *args)
738 {
739 int algorithmMediaType;
740 int bufferlength;
741 int *PVbuffer;
742 PyObject *list;
743 int i;
744
745 if (!PyArg_ParseTuple(args, "i", &algorithmMediaType))
746 return NULL;
747
748 error_handler_called = 0;
749 bufferlength = clQueryAlgorithms(algorithmMediaType, 0, 0);
750 if (error_handler_called)
751 return NULL;
752
753 PVbuffer = PyMem_NEW(int, bufferlength);
754 if (PVbuffer == NULL)
755 return PyErr_NoMemory();
756
757 bufferlength = clQueryAlgorithms(algorithmMediaType, PVbuffer,
758 bufferlength);
759 if (error_handler_called) {
760 PyMem_DEL(PVbuffer);
761 return NULL;
762 }
763
764 list = PyList_New(bufferlength);
765 if (list == NULL) {
766 PyMem_DEL(PVbuffer);
767 return NULL;
768 }
769
770 for (i = 0; i < bufferlength; i++) {
771 if (i & 1)
772 PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
773 else if (PVbuffer[i] == 0) {
774 Py_INCREF(Py_None);
775 PyList_SetItem(list, i, Py_None);
776 } else
777 PyList_SetItem(list, i,
778 PyString_FromString((char *) PVbuffer[i]));
779 }
780
781 PyMem_DEL(PVbuffer);
782
783 return list;
784 }
785
786 static PyObject *
787 cl_QuerySchemeFromName(PyObject *self, PyObject *args)
788 {
789 int algorithmMediaType;
790 char *name;
791 int scheme;
792
793 if (!PyArg_ParseTuple(args, "is", &algorithmMediaType, &name))
794 return NULL;
795
796 error_handler_called = 0;
797 scheme = clQuerySchemeFromName(algorithmMediaType, name);
798 if (error_handler_called) {
799 PyErr_SetString(ClError, "unknown compression scheme");
800 return NULL;
801 }
802
803 return PyInt_FromLong(scheme);
804 }
805
806 static PyObject *
807 cl_GetAlgorithmName(PyObject *self, PyObject *args)
808 {
809 int scheme;
810 char *name;
811
812 if (!PyArg_ParseTuple(args, "i", &scheme))
813 return NULL;
814
815 name = clGetAlgorithmName(scheme);
816 if (name == 0) {
817 PyErr_SetString(ClError, "unknown compression scheme");
818 return NULL;
819 }
820
821 return PyString_FromString(name);
822 }
823
824 static PyObject *
825 do_set(PyObject *self, PyObject *args, int (*func)(int, int, int))
826 {
827 int scheme, paramID, value;
828 float fvalue;
829 int is_float = 0;
830
831 if (!PyArg_ParseTuple(args, "iii", &scheme, &paramID, &value)) {
832 PyErr_Clear();
833 if (!PyArg_ParseTuple(args, "iif", &scheme, &paramID, &fvalue)) {
834 PyErr_Clear();
835 PyErr_SetString(PyExc_TypeError,
836 "bad argument list (format '(iii)' or '(iif)')");
837 return NULL;
838 }
839 value = CL_TypeIsInt(fvalue);
840 is_float = 1;
841 } else {
842 /* check some parameters which we know to be floats */
843 switch (scheme) {
844 case CL_COMPRESSION_RATIO:
845 case CL_SPEED:
846 fvalue = value;
847 value = CL_TypeIsInt(fvalue);
848 is_float = 1;
849 break;
850 }
851 }
852
853 error_handler_called = 0;
854 value = (*func)(scheme, paramID, value);
855 if (error_handler_called)
856 return NULL;
857
858 if (is_float)
859 return PyFloat_FromDouble(CL_TypeIsFloat(value));
860 else
861 return PyInt_FromLong(value);
862 }
863
864 static PyObject *
865 cl_SetDefault(PyObject *self, PyObject *args)
866 {
867 return do_set(self, args, clSetDefault);
868 }
869
870 static PyObject *
871 cl_SetMin(PyObject *self, PyObject *args)
872 {
873 return do_set(self, args, clSetMin);
874 }
875
876 static PyObject *
877 cl_SetMax(PyObject *self, PyObject *args)
878 {
879 return do_set(self, args, clSetMax);
880 }
881
882 #define func(name, handler) \
883 static PyObject *cl_##name(PyObject *self, PyObject *args) \
884 { \
885 int x; \
886 if (!PyArg_ParseTuple(args, "i", &x)) return NULL; \
887 return Py##handler(CL_##name(x)); \
888 }
889
890 #define func2(name, handler) \
891 static PyObject *cl_##name(PyObject *self, PyObject *args) \
892 { \
893 int a1, a2; \
894 if (!PyArg_ParseTuple(args, "ii", &a1, &a2)) return NULL; \
895 return Py##handler(CL_##name(a1, a2)); \
896 }
897
898 func(BytesPerSample, Int_FromLong)
899 func(BytesPerPixel, Int_FromLong)
900 func(AudioFormatName, String_FromString)
901 func(VideoFormatName, String_FromString)
902 func(AlgorithmNumber, Int_FromLong)
903 func(AlgorithmType, Int_FromLong)
904 func2(Algorithm, Int_FromLong)
905 func(ParamNumber, Int_FromLong)
906 func(ParamType, Int_FromLong)
907 func2(ParamID, Int_FromLong)
908
909 #ifdef CLDEBUG
910 static PyObject *
911 cvt_type(PyObject *self, PyObject *args)
912 {
913 int number;
914 float fnumber;
915
916 if (PyArg_Parse(args, "i", &number))
917 return PyFloat_FromDouble(CL_TypeIsFloat(number));
918 else {
919 PyErr_Clear();
920 if (PyArg_Parse(args, "f", &fnumber))
921 return PyInt_FromLong(CL_TypeIsInt(fnumber));
922 return NULL;
923 }
924 }
925 #endif
926
927 static PyMethodDef cl_methods[] = {
928 {"CompressImage", cl_CompressImage, METH_VARARGS},
929 {"DecompressImage", cl_DecompressImage, METH_VARARGS},
930 {"GetAlgorithmName", cl_GetAlgorithmName, METH_VARARGS},
931 {"OpenCompressor", cl_OpenCompressor, METH_VARARGS},
932 {"OpenDecompressor", cl_OpenDecompressor, METH_VARARGS},
933 {"QueryAlgorithms", cl_QueryAlgorithms, METH_VARARGS},
934 {"QueryMaxHeaderSize", cl_QueryMaxHeaderSize, METH_VARARGS},
935 {"QueryScheme", cl_QueryScheme, METH_VARARGS},
936 {"QuerySchemeFromName", cl_QuerySchemeFromName, METH_VARARGS},
937 {"SetDefault", cl_SetDefault, METH_VARARGS},
938 {"SetMax", cl_SetMax, METH_VARARGS},
939 {"SetMin", cl_SetMin, METH_VARARGS},
940 {"BytesPerSample", cl_BytesPerSample, METH_VARARGS},
941 {"BytesPerPixel", cl_BytesPerPixel, METH_VARARGS},
942 {"AudioFormatName", cl_AudioFormatName, METH_VARARGS},
943 {"VideoFormatName", cl_VideoFormatName, METH_VARARGS},
944 {"AlgorithmNumber", cl_AlgorithmNumber, METH_VARARGS},
945 {"AlgorithmType", cl_AlgorithmType, METH_VARARGS},
946 {"Algorithm", cl_Algorithm, METH_VARARGS},
947 {"ParamNumber", cl_ParamNumber, METH_VARARGS},
948 {"ParamType", cl_ParamType, METH_VARARGS},
949 {"ParamID", cl_ParamID, METH_VARARGS},
950 #ifdef CLDEBUG
951 {"cvt_type", cvt_type, METH_VARARGS},
952 #endif
953 {NULL, NULL} /* Sentinel */
954 };
955
956 #ifdef CL_JPEG_SOFTWARE
957 #define IRIX_5_3_LIBRARY
958 #endif
959
960 void
961 initcl(void)
962 {
963 PyObject *m, *d, *x;
964
965 if (PyErr_WarnPy3k("the cl module has been removed in "
966 "Python 3.0", 2) < 0)
967 return;
968
969 m = Py_InitModule("cl", cl_methods);
970 if (m == NULL)
971 return;
972 d = PyModule_GetDict(m);
973
974 ClError = PyErr_NewException("cl.error", NULL, NULL);
975 (void) PyDict_SetItemString(d, "error", ClError);
976
977 #ifdef CL_ADDED_ALGORITHM_ERROR
978 x = PyInt_FromLong(CL_ADDED_ALGORITHM_ERROR);
979 if (x == NULL || PyDict_SetItemString(d, "ADDED_ALGORITHM_ERROR", x) < 0)
980 return;
981 Py_DECREF(x);
982 #endif
983 #ifdef CL_ALAW
984 x = PyInt_FromLong(CL_ALAW);
985 if (x == NULL || PyDict_SetItemString(d, "ALAW", x) < 0)
986 return;
987 Py_DECREF(x);
988 #endif
989 #ifdef CL_ALGORITHM_ID
990 x = PyInt_FromLong(CL_ALGORITHM_ID);
991 if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_ID", x) < 0)
992 return;
993 Py_DECREF(x);
994 #endif
995 #ifdef CL_ALGORITHM_TABLE_FULL
996 x = PyInt_FromLong(CL_ALGORITHM_TABLE_FULL);
997 if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_TABLE_FULL", x) < 0)
998 return;
999 Py_DECREF(x);
1000 #endif
1001 #ifdef CL_ALGORITHM_VERSION
1002 x = PyInt_FromLong(CL_ALGORITHM_VERSION);
1003 if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_VERSION", x) < 0)
1004 return;
1005 Py_DECREF(x);
1006 #endif
1007 #ifdef CL_ALG_AUDIO
1008 x = PyInt_FromLong(CL_ALG_AUDIO);
1009 if (x == NULL || PyDict_SetItemString(d, "ALG_AUDIO", x) < 0)
1010 return;
1011 Py_DECREF(x);
1012 #endif
1013 #ifdef CL_ALG_VIDEO
1014 x = PyInt_FromLong(CL_ALG_VIDEO);
1015 if (x == NULL || PyDict_SetItemString(d, "ALG_VIDEO", x) < 0)
1016 return;
1017 Py_DECREF(x);
1018 #endif
1019 #ifdef CL_AUDIO
1020 x = PyInt_FromLong(CL_AUDIO);
1021 if (x == NULL || PyDict_SetItemString(d, "AUDIO", x) < 0)
1022 return;
1023 Py_DECREF(x);
1024 #endif
1025 #ifdef CL_AWARE_BITRATE_POLICY
1026 x = PyInt_FromLong(CL_AWARE_BITRATE_POLICY);
1027 if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_POLICY", x) < 0)
1028 return;
1029 Py_DECREF(x);
1030 #endif
1031 #ifdef CL_AWARE_BITRATE_TARGET
1032 x = PyInt_FromLong(CL_AWARE_BITRATE_TARGET);
1033 if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_TARGET", x) < 0)
1034 return;
1035 Py_DECREF(x);
1036 #endif
1037 #ifdef CL_AWARE_CHANNEL_POLICY
1038 x = PyInt_FromLong(CL_AWARE_CHANNEL_POLICY);
1039 if (x == NULL || PyDict_SetItemString(d, "AWARE_CHANNEL_POLICY", x) < 0)
1040 return;
1041 Py_DECREF(x);
1042 #endif
1043 #ifdef CL_AWARE_CONST_QUAL
1044 x = PyInt_FromLong(CL_AWARE_CONST_QUAL);
1045 if (x == NULL || PyDict_SetItemString(d, "AWARE_CONST_QUAL", x) < 0)
1046 return;
1047 Py_DECREF(x);
1048 #endif
1049 #ifdef CL_AWARE_ERROR
1050 x = PyInt_FromLong(CL_AWARE_ERROR);
1051 if (x == NULL || PyDict_SetItemString(d, "AWARE_ERROR", x) < 0)
1052 return;
1053 Py_DECREF(x);
1054 #endif
1055 #ifdef CL_AWARE_FIXED_RATE
1056 x = PyInt_FromLong(CL_AWARE_FIXED_RATE);
1057 if (x == NULL || PyDict_SetItemString(d, "AWARE_FIXED_RATE", x) < 0)
1058 return;
1059 Py_DECREF(x);
1060 #endif
1061 #ifdef CL_AWARE_INDEPENDENT
1062 x = PyInt_FromLong(CL_AWARE_INDEPENDENT);
1063 if (x == NULL || PyDict_SetItemString(d, "AWARE_INDEPENDENT", x) < 0)
1064 return;
1065 Py_DECREF(x);
1066 #endif
1067 #ifdef CL_AWARE_JOINT_STEREO
1068 x = PyInt_FromLong(CL_AWARE_JOINT_STEREO);
1069 if (x == NULL || PyDict_SetItemString(d, "AWARE_JOINT_STEREO", x) < 0)
1070 return;
1071 Py_DECREF(x);
1072 #endif
1073 #ifdef CL_AWARE_LAYER
1074 x = PyInt_FromLong(CL_AWARE_LAYER);
1075 if (x == NULL || PyDict_SetItemString(d, "AWARE_LAYER", x) < 0)
1076 return;
1077 Py_DECREF(x);
1078 #endif
1079 #ifdef CL_AWARE_LOSSLESS
1080 x = PyInt_FromLong(CL_AWARE_LOSSLESS);
1081 if (x == NULL || PyDict_SetItemString(d, "AWARE_LOSSLESS", x) < 0)
1082 return;
1083 Py_DECREF(x);
1084 #endif
1085 #ifdef CL_AWARE_MPEG_AUDIO
1086 x = PyInt_FromLong(CL_AWARE_MPEG_AUDIO);
1087 if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_AUDIO", x) < 0)
1088 return;
1089 Py_DECREF(x);
1090 #endif
1091 #ifdef CL_AWARE_MPEG_LAYER_I
1092 x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_I);
1093 if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_I", x) < 0)
1094 return;
1095 Py_DECREF(x);
1096 #endif
1097 #ifdef CL_AWARE_MPEG_LAYER_II
1098 x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_II);
1099 if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_II", x) < 0)
1100 return;
1101 Py_DECREF(x);
1102 #endif
1103 #ifdef CL_AWARE_MULTIRATE
1104 x = PyInt_FromLong(CL_AWARE_MULTIRATE);
1105 if (x == NULL || PyDict_SetItemString(d, "AWARE_MULTIRATE", x) < 0)
1106 return;
1107 Py_DECREF(x);
1108 #endif
1109 #ifdef CL_AWARE_NOISE_MARGIN
1110 x = PyInt_FromLong(CL_AWARE_NOISE_MARGIN);
1111 if (x == NULL || PyDict_SetItemString(d, "AWARE_NOISE_MARGIN", x) < 0)
1112 return;
1113 Py_DECREF(x);
1114 #endif
1115 #ifdef CL_AWARE_STEREO
1116 x = PyInt_FromLong(CL_AWARE_STEREO);
1117 if (x == NULL || PyDict_SetItemString(d, "AWARE_STEREO", x) < 0)
1118 return;
1119 Py_DECREF(x);
1120 #endif
1121 #ifdef CL_BAD_ALGORITHM_NAME
1122 x = PyInt_FromLong(CL_BAD_ALGORITHM_NAME);
1123 if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_NAME", x) < 0)
1124 return;
1125 Py_DECREF(x);
1126 #endif
1127 #ifdef CL_BAD_ALGORITHM_TYPE
1128 x = PyInt_FromLong(CL_BAD_ALGORITHM_TYPE);
1129 if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_TYPE", x) < 0)
1130 return;
1131 Py_DECREF(x);
1132 #endif
1133 #ifdef CL_BAD_BLOCK_SIZE
1134 x = PyInt_FromLong(CL_BAD_BLOCK_SIZE);
1135 if (x == NULL || PyDict_SetItemString(d, "BAD_BLOCK_SIZE", x) < 0)
1136 return;
1137 Py_DECREF(x);
1138 #endif
1139 #ifdef CL_BAD_BOARD
1140 x = PyInt_FromLong(CL_BAD_BOARD);
1141 if (x == NULL || PyDict_SetItemString(d, "BAD_BOARD", x) < 0)
1142 return;
1143 Py_DECREF(x);
1144 #endif
1145 #ifdef CL_BAD_BUFFERING
1146 x = PyInt_FromLong(CL_BAD_BUFFERING);
1147 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERING", x) < 0)
1148 return;
1149 Py_DECREF(x);
1150 #endif
1151 #ifdef CL_BAD_BUFFERLENGTH_NEG
1152 x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_NEG);
1153 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
1154 return;
1155 Py_DECREF(x);
1156 #endif
1157 #ifdef CL_BAD_BUFFERLENGTH_ODD
1158 x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_ODD);
1159 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
1160 return;
1161 Py_DECREF(x);
1162 #endif
1163 #ifdef CL_BAD_BUFFER_EXISTS
1164 x = PyInt_FromLong(CL_BAD_BUFFER_EXISTS);
1165 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_EXISTS", x) < 0)
1166 return;
1167 Py_DECREF(x);
1168 #endif
1169 #ifdef CL_BAD_BUFFER_HANDLE
1170 x = PyInt_FromLong(CL_BAD_BUFFER_HANDLE);
1171 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_HANDLE", x) < 0)
1172 return;
1173 Py_DECREF(x);
1174 #endif
1175 #ifdef CL_BAD_BUFFER_POINTER
1176 x = PyInt_FromLong(CL_BAD_BUFFER_POINTER);
1177 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_POINTER", x) < 0)
1178 return;
1179 Py_DECREF(x);
1180 #endif
1181 #ifdef CL_BAD_BUFFER_QUERY_SIZE
1182 x = PyInt_FromLong(CL_BAD_BUFFER_QUERY_SIZE);
1183 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_QUERY_SIZE", x) < 0)
1184 return;
1185 Py_DECREF(x);
1186 #endif
1187 #ifdef CL_BAD_BUFFER_SIZE
1188 x = PyInt_FromLong(CL_BAD_BUFFER_SIZE);
1189 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE", x) < 0)
1190 return;
1191 Py_DECREF(x);
1192 #endif
1193 #ifdef CL_BAD_BUFFER_SIZE_POINTER
1194 x = PyInt_FromLong(CL_BAD_BUFFER_SIZE_POINTER);
1195 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE_POINTER", x) < 0)
1196 return;
1197 Py_DECREF(x);
1198 #endif
1199 #ifdef CL_BAD_BUFFER_TYPE
1200 x = PyInt_FromLong(CL_BAD_BUFFER_TYPE);
1201 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_TYPE", x) < 0)
1202 return;
1203 Py_DECREF(x);
1204 #endif
1205 #ifdef CL_BAD_COMPRESSION_SCHEME
1206 x = PyInt_FromLong(CL_BAD_COMPRESSION_SCHEME);
1207 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSION_SCHEME", x) < 0)
1208 return;
1209 Py_DECREF(x);
1210 #endif
1211 #ifdef CL_BAD_COMPRESSOR_HANDLE
1212 x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE);
1213 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE", x) < 0)
1214 return;
1215 Py_DECREF(x);
1216 #endif
1217 #ifdef CL_BAD_COMPRESSOR_HANDLE_POINTER
1218 x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE_POINTER);
1219 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE_POINTER", x) < 0)
1220 return;
1221 Py_DECREF(x);
1222 #endif
1223 #ifdef CL_BAD_FRAME_SIZE
1224 x = PyInt_FromLong(CL_BAD_FRAME_SIZE);
1225 if (x == NULL || PyDict_SetItemString(d, "BAD_FRAME_SIZE", x) < 0)
1226 return;
1227 Py_DECREF(x);
1228 #endif
1229 #ifdef CL_BAD_FUNCTIONALITY
1230 x = PyInt_FromLong(CL_BAD_FUNCTIONALITY);
1231 if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTIONALITY", x) < 0)
1232 return;
1233 Py_DECREF(x);
1234 #endif
1235 #ifdef CL_BAD_FUNCTION_POINTER
1236 x = PyInt_FromLong(CL_BAD_FUNCTION_POINTER);
1237 if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTION_POINTER", x) < 0)
1238 return;
1239 Py_DECREF(x);
1240 #endif
1241 #ifdef CL_BAD_HEADER_SIZE
1242 x = PyInt_FromLong(CL_BAD_HEADER_SIZE);
1243 if (x == NULL || PyDict_SetItemString(d, "BAD_HEADER_SIZE", x) < 0)
1244 return;
1245 Py_DECREF(x);
1246 #endif
1247 #ifdef CL_BAD_INITIAL_VALUE
1248 x = PyInt_FromLong(CL_BAD_INITIAL_VALUE);
1249 if (x == NULL || PyDict_SetItemString(d, "BAD_INITIAL_VALUE", x) < 0)
1250 return;
1251 Py_DECREF(x);
1252 #endif
1253 #ifdef CL_BAD_INTERNAL_FORMAT
1254 x = PyInt_FromLong(CL_BAD_INTERNAL_FORMAT);
1255 if (x == NULL || PyDict_SetItemString(d, "BAD_INTERNAL_FORMAT", x) < 0)
1256 return;
1257 Py_DECREF(x);
1258 #endif
1259 #ifdef CL_BAD_LICENSE
1260 x = PyInt_FromLong(CL_BAD_LICENSE);
1261 if (x == NULL || PyDict_SetItemString(d, "BAD_LICENSE", x) < 0)
1262 return;
1263 Py_DECREF(x);
1264 #endif
1265 #ifdef CL_BAD_MIN_GT_MAX
1266 x = PyInt_FromLong(CL_BAD_MIN_GT_MAX);
1267 if (x == NULL || PyDict_SetItemString(d, "BAD_MIN_GT_MAX", x) < 0)
1268 return;
1269 Py_DECREF(x);
1270 #endif
1271 #ifdef CL_BAD_NO_BUFFERSPACE
1272 x = PyInt_FromLong(CL_BAD_NO_BUFFERSPACE);
1273 if (x == NULL || PyDict_SetItemString(d, "BAD_NO_BUFFERSPACE", x) < 0)
1274 return;
1275 Py_DECREF(x);
1276 #endif
1277 #ifdef CL_BAD_NUMBER_OF_BLOCKS
1278 x = PyInt_FromLong(CL_BAD_NUMBER_OF_BLOCKS);
1279 if (x == NULL || PyDict_SetItemString(d, "BAD_NUMBER_OF_BLOCKS", x) < 0)
1280 return;
1281 Py_DECREF(x);
1282 #endif
1283 #ifdef CL_BAD_PARAM
1284 x = PyInt_FromLong(CL_BAD_PARAM);
1285 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
1286 return;
1287 Py_DECREF(x);
1288 #endif
1289 #ifdef CL_BAD_PARAM_ID_POINTER
1290 x = PyInt_FromLong(CL_BAD_PARAM_ID_POINTER);
1291 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_ID_POINTER", x) < 0)
1292 return;
1293 Py_DECREF(x);
1294 #endif
1295 #ifdef CL_BAD_PARAM_TYPE
1296 x = PyInt_FromLong(CL_BAD_PARAM_TYPE);
1297 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_TYPE", x) < 0)
1298 return;
1299 Py_DECREF(x);
1300 #endif
1301 #ifdef CL_BAD_POINTER
1302 x = PyInt_FromLong(CL_BAD_POINTER);
1303 if (x == NULL || PyDict_SetItemString(d, "BAD_POINTER", x) < 0)
1304 return;
1305 Py_DECREF(x);
1306 #endif
1307 #ifdef CL_BAD_PVBUFFER
1308 x = PyInt_FromLong(CL_BAD_PVBUFFER);
1309 if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
1310 return;
1311 Py_DECREF(x);
1312 #endif
1313 #ifdef CL_BAD_SCHEME_POINTER
1314 x = PyInt_FromLong(CL_BAD_SCHEME_POINTER);
1315 if (x == NULL || PyDict_SetItemString(d, "BAD_SCHEME_POINTER", x) < 0)
1316 return;
1317 Py_DECREF(x);
1318 #endif
1319 #ifdef CL_BAD_STREAM_HEADER
1320 x = PyInt_FromLong(CL_BAD_STREAM_HEADER);
1321 if (x == NULL || PyDict_SetItemString(d, "BAD_STREAM_HEADER", x) < 0)
1322 return;
1323 Py_DECREF(x);
1324 #endif
1325 #ifdef CL_BAD_STRING_POINTER
1326 x = PyInt_FromLong(CL_BAD_STRING_POINTER);
1327 if (x == NULL || PyDict_SetItemString(d, "BAD_STRING_POINTER", x) < 0)
1328 return;
1329 Py_DECREF(x);
1330 #endif
1331 #ifdef CL_BAD_TEXT_STRING_PTR
1332 x = PyInt_FromLong(CL_BAD_TEXT_STRING_PTR);
1333 if (x == NULL || PyDict_SetItemString(d, "BAD_TEXT_STRING_PTR", x) < 0)
1334 return;
1335 Py_DECREF(x);
1336 #endif
1337 #ifdef CL_BEST_FIT
1338 x = PyInt_FromLong(CL_BEST_FIT);
1339 if (x == NULL || PyDict_SetItemString(d, "BEST_FIT", x) < 0)
1340 return;
1341 Py_DECREF(x);
1342 #endif
1343 #ifdef CL_BIDIRECTIONAL
1344 x = PyInt_FromLong(CL_BIDIRECTIONAL);
1345 if (x == NULL || PyDict_SetItemString(d, "BIDIRECTIONAL", x) < 0)
1346 return;
1347 Py_DECREF(x);
1348 #endif
1349 #ifdef CL_BITRATE
1350 x = PyInt_FromLong(CL_BITRATE);
1351 if (x == NULL || PyDict_SetItemString(d, "BITRATE", x) < 0)
1352 return;
1353 Py_DECREF(x);
1354 #endif
1355 #ifdef CL_BITRATE_POLICY
1356 x = PyInt_FromLong(CL_BITRATE_POLICY);
1357 if (x == NULL || PyDict_SetItemString(d, "BITRATE_POLICY", x) < 0)
1358 return;
1359 Py_DECREF(x);
1360 #endif
1361 #ifdef CL_BITRATE_TARGET
1362 x = PyInt_FromLong(CL_BITRATE_TARGET);
1363 if (x == NULL || PyDict_SetItemString(d, "BITRATE_TARGET", x) < 0)
1364 return;
1365 Py_DECREF(x);
1366 #endif
1367 #ifdef CL_BITS_PER_COMPONENT
1368 x = PyInt_FromLong(CL_BITS_PER_COMPONENT);
1369 if (x == NULL || PyDict_SetItemString(d, "BITS_PER_COMPONENT", x) < 0)
1370 return;
1371 Py_DECREF(x);
1372 #endif
1373 #ifdef CL_BLENDING
1374 x = PyInt_FromLong(CL_BLENDING);
1375 if (x == NULL || PyDict_SetItemString(d, "BLENDING", x) < 0)
1376 return;
1377 Py_DECREF(x);
1378 #endif
1379 #ifdef CL_BLOCK_SIZE
1380 x = PyInt_FromLong(CL_BLOCK_SIZE);
1381 if (x == NULL || PyDict_SetItemString(d, "BLOCK_SIZE", x) < 0)
1382 return;
1383 Py_DECREF(x);
1384 #endif
1385 #ifdef CL_BOTTOM_UP
1386 x = PyInt_FromLong(CL_BOTTOM_UP);
1387 if (x == NULL || PyDict_SetItemString(d, "BOTTOM_UP", x) < 0)
1388 return;
1389 Py_DECREF(x);
1390 #endif
1391 #ifdef CL_BUFFER_NOT_CREATED
1392 x = PyInt_FromLong(CL_BUFFER_NOT_CREATED);
1393 if (x == NULL || PyDict_SetItemString(d, "BUFFER_NOT_CREATED", x) < 0)
1394 return;
1395 Py_DECREF(x);
1396 #endif
1397 #ifdef CL_BUF_COMPRESSED
1398 x = PyInt_FromLong(CL_BUF_COMPRESSED);
1399 if (x == NULL || PyDict_SetItemString(d, "BUF_COMPRESSED", x) < 0)
1400 return;
1401 Py_DECREF(x);
1402 #endif
1403 #ifdef CL_BUF_DATA
1404 x = PyInt_FromLong(CL_BUF_DATA);
1405 if (x == NULL || PyDict_SetItemString(d, "BUF_DATA", x) < 0)
1406 return;
1407 Py_DECREF(x);
1408 #endif
1409 #ifdef CL_BUF_FRAME
1410 x = PyInt_FromLong(CL_BUF_FRAME);
1411 if (x == NULL || PyDict_SetItemString(d, "BUF_FRAME", x) < 0)
1412 return;
1413 Py_DECREF(x);
1414 #endif
1415 #ifdef CL_CHANNEL_POLICY
1416 x = PyInt_FromLong(CL_CHANNEL_POLICY);
1417 if (x == NULL || PyDict_SetItemString(d, "CHANNEL_POLICY", x) < 0)
1418 return;
1419 Py_DECREF(x);
1420 #endif
1421 #ifdef CL_CHROMA_THRESHOLD
1422 x = PyInt_FromLong(CL_CHROMA_THRESHOLD);
1423 if (x == NULL || PyDict_SetItemString(d, "CHROMA_THRESHOLD", x) < 0)
1424 return;
1425 Py_DECREF(x);
1426 #endif
1427 #ifdef CL_CODEC
1428 x = PyInt_FromLong(CL_CODEC);
1429 if (x == NULL || PyDict_SetItemString(d, "CODEC", x) < 0)
1430 return;
1431 Py_DECREF(x);
1432 #endif
1433 #ifdef CL_COMPONENTS
1434 x = PyInt_FromLong(CL_COMPONENTS);
1435 if (x == NULL || PyDict_SetItemString(d, "COMPONENTS", x) < 0)
1436 return;
1437 Py_DECREF(x);
1438 #endif
1439 #ifdef CL_COMPRESSED_BUFFER_SIZE
1440 x = PyInt_FromLong(CL_COMPRESSED_BUFFER_SIZE);
1441 if (x == NULL || PyDict_SetItemString(d, "COMPRESSED_BUFFER_SIZE", x) < 0)
1442 return;
1443 Py_DECREF(x);
1444 #endif
1445 #ifdef CL_COMPRESSION_RATIO
1446 x = PyInt_FromLong(CL_COMPRESSION_RATIO);
1447 if (x == NULL || PyDict_SetItemString(d, "COMPRESSION_RATIO", x) < 0)
1448 return;
1449 Py_DECREF(x);
1450 #endif
1451 #ifdef CL_COMPRESSOR
1452 x = PyInt_FromLong(CL_COMPRESSOR);
1453 if (x == NULL || PyDict_SetItemString(d, "COMPRESSOR", x) < 0)
1454 return;
1455 Py_DECREF(x);
1456 #endif
1457 #ifdef CL_CONTINUOUS_BLOCK
1458 x = PyInt_FromLong(CL_CONTINUOUS_BLOCK);
1459 if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_BLOCK", x) < 0)
1460 return;
1461 Py_DECREF(x);
1462 #endif
1463 #ifdef CL_CONTINUOUS_NONBLOCK
1464 x = PyInt_FromLong(CL_CONTINUOUS_NONBLOCK);
1465 if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_NONBLOCK", x) < 0)
1466 return;
1467 Py_DECREF(x);
1468 #endif
1469 #ifdef CL_COSMO_CODEC_CONTROL
1470 x = PyInt_FromLong(CL_COSMO_CODEC_CONTROL);
1471 if (x == NULL || PyDict_SetItemString(d, "COSMO_CODEC_CONTROL", x) < 0)
1472 return;
1473 Py_DECREF(x);
1474 #endif
1475 #ifdef CL_COSMO_NUM_PARAMS
1476 x = PyInt_FromLong(CL_COSMO_NUM_PARAMS);
1477 if (x == NULL || PyDict_SetItemString(d, "COSMO_NUM_PARAMS", x) < 0)
1478 return;
1479 Py_DECREF(x);
1480 #endif
1481 #ifdef CL_COSMO_VALUE_BASE
1482 x = PyInt_FromLong(CL_COSMO_VALUE_BASE);
1483 if (x == NULL || PyDict_SetItemString(d, "COSMO_VALUE_BASE", x) < 0)
1484 return;
1485 Py_DECREF(x);
1486 #endif
1487 #ifdef CL_COSMO_VIDEO_MANUAL_CONTROL
1488 x = PyInt_FromLong(CL_COSMO_VIDEO_MANUAL_CONTROL);
1489 if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_MANUAL_CONTROL", x) < 0)
1490 return;
1491 Py_DECREF(x);
1492 #endif
1493 #ifdef CL_COSMO_VIDEO_TRANSFER_MODE
1494 x = PyInt_FromLong(CL_COSMO_VIDEO_TRANSFER_MODE);
1495 if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_TRANSFER_MODE", x) < 0)
1496 return;
1497 Py_DECREF(x);
1498 #endif
1499 #ifdef CL_DATA
1500 x = PyInt_FromLong(CL_DATA);
1501 if (x == NULL || PyDict_SetItemString(d, "DATA", x) < 0)
1502 return;
1503 Py_DECREF(x);
1504 #endif
1505 #ifdef CL_DECOMPRESSOR
1506 x = PyInt_FromLong(CL_DECOMPRESSOR);
1507 if (x == NULL || PyDict_SetItemString(d, "DECOMPRESSOR", x) < 0)
1508 return;
1509 Py_DECREF(x);
1510 #endif
1511 #ifdef CL_DSO_ERROR
1512 x = PyInt_FromLong(CL_DSO_ERROR);
1513 if (x == NULL || PyDict_SetItemString(d, "DSO_ERROR", x) < 0)
1514 return;
1515 Py_DECREF(x);
1516 #endif
1517 #ifdef CL_EDGE_THRESHOLD
1518 x = PyInt_FromLong(CL_EDGE_THRESHOLD);
1519 if (x == NULL || PyDict_SetItemString(d, "EDGE_THRESHOLD", x) < 0)
1520 return;
1521 Py_DECREF(x);
1522 #endif
1523 #ifdef CL_ENABLE_IMAGEINFO
1524 x = PyInt_FromLong(CL_ENABLE_IMAGEINFO);
1525 if (x == NULL || PyDict_SetItemString(d, "ENABLE_IMAGEINFO", x) < 0)
1526 return;
1527 Py_DECREF(x);
1528 #endif
1529 #ifdef CL_END_OF_SEQUENCE
1530 x = PyInt_FromLong(CL_END_OF_SEQUENCE);
1531 if (x == NULL || PyDict_SetItemString(d, "END_OF_SEQUENCE", x) < 0)
1532 return;
1533 Py_DECREF(x);
1534 #endif
1535 #ifdef CL_ENUM_VALUE
1536 x = PyInt_FromLong(CL_ENUM_VALUE);
1537 if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
1538 return;
1539 Py_DECREF(x);
1540 #endif
1541 #ifdef CL_EXACT_COMPRESSION_RATIO
1542 x = PyInt_FromLong(CL_EXACT_COMPRESSION_RATIO);
1543 if (x == NULL || PyDict_SetItemString(d, "EXACT_COMPRESSION_RATIO", x) < 0)
1544 return;
1545 Py_DECREF(x);
1546 #endif
1547 #ifdef CL_EXTERNAL_DEVICE
1548 x = PyInt_FromLong((long) CL_EXTERNAL_DEVICE);
1549 if (x == NULL || PyDict_SetItemString(d, "EXTERNAL_DEVICE", x) < 0)
1550 return;
1551 Py_DECREF(x);
1552 #endif
1553 #ifdef CL_FLOATING_ENUM_VALUE
1554 x = PyInt_FromLong(CL_FLOATING_ENUM_VALUE);
1555 if (x == NULL || PyDict_SetItemString(d, "FLOATING_ENUM_VALUE", x) < 0)
1556 return;
1557 Py_DECREF(x);
1558 #endif
1559 #ifdef CL_FLOATING_RANGE_VALUE
1560 x = PyInt_FromLong(CL_FLOATING_RANGE_VALUE);
1561 if (x == NULL || PyDict_SetItemString(d, "FLOATING_RANGE_VALUE", x) < 0)
1562 return;
1563 Py_DECREF(x);
1564 #endif
1565 #ifdef CL_FORMAT
1566 x = PyInt_FromLong(CL_FORMAT);
1567 if (x == NULL || PyDict_SetItemString(d, "FORMAT", x) < 0)
1568 return;
1569 Py_DECREF(x);
1570 #endif
1571 #ifdef CL_FORMAT_ABGR
1572 x = PyInt_FromLong(CL_FORMAT_ABGR);
1573 if (x == NULL || PyDict_SetItemString(d, "FORMAT_ABGR", x) < 0)
1574 return;
1575 Py_DECREF(x);
1576 #endif
1577 #ifdef CL_FORMAT_BGR
1578 x = PyInt_FromLong(CL_FORMAT_BGR);
1579 if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR", x) < 0)
1580 return;
1581 Py_DECREF(x);
1582 #endif
1583 #ifdef CL_FORMAT_BGR233
1584 x = PyInt_FromLong(CL_FORMAT_BGR233);
1585 if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR233", x) < 0)
1586 return;
1587 Py_DECREF(x);
1588 #endif
1589 #ifdef CL_FORMAT_GRAYSCALE
1590 x = PyInt_FromLong(CL_FORMAT_GRAYSCALE);
1591 if (x == NULL || PyDict_SetItemString(d, "FORMAT_GRAYSCALE", x) < 0)
1592 return;
1593 Py_DECREF(x);
1594 #endif
1595 #ifdef CL_FORMAT_MONO
1596 x = PyInt_FromLong(CL_FORMAT_MONO);
1597 if (x == NULL || PyDict_SetItemString(d, "FORMAT_MONO", x) < 0)
1598 return;
1599 Py_DECREF(x);
1600 #endif
1601 #ifdef CL_FORMAT_RBG323
1602 x = PyInt_FromLong(CL_FORMAT_RBG323);
1603 if (x == NULL || PyDict_SetItemString(d, "FORMAT_RBG323", x) < 0)
1604 return;
1605 Py_DECREF(x);
1606 #endif
1607 #ifdef CL_FORMAT_STEREO_INTERLEAVED
1608 x = PyInt_FromLong(CL_FORMAT_STEREO_INTERLEAVED);
1609 if (x == NULL || PyDict_SetItemString(d, "FORMAT_STEREO_INTERLEAVED", x) < 0)
1610 return;
1611 Py_DECREF(x);
1612 #endif
1613 #ifdef CL_FORMAT_XBGR
1614 x = PyInt_FromLong(CL_FORMAT_XBGR);
1615 if (x == NULL || PyDict_SetItemString(d, "FORMAT_XBGR", x) < 0)
1616 return;
1617 Py_DECREF(x);
1618 #endif
1619 #ifdef CL_FORMAT_YCbCr
1620 x = PyInt_FromLong(CL_FORMAT_YCbCr);
1621 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr", x) < 0)
1622 return;
1623 Py_DECREF(x);
1624 #endif
1625 #ifdef CL_FORMAT_YCbCr422
1626 x = PyInt_FromLong(CL_FORMAT_YCbCr422);
1627 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422", x) < 0)
1628 return;
1629 Py_DECREF(x);
1630 #endif
1631 #ifdef CL_FORMAT_YCbCr422DC
1632 x = PyInt_FromLong(CL_FORMAT_YCbCr422DC);
1633 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422DC", x) < 0)
1634 return;
1635 Py_DECREF(x);
1636 #endif
1637 #ifdef CL_FRAME
1638 x = PyInt_FromLong(CL_FRAME);
1639 if (x == NULL || PyDict_SetItemString(d, "FRAME", x) < 0)
1640 return;
1641 Py_DECREF(x);
1642 #endif
1643 #ifdef CL_FRAMES_PER_CHUNK
1644 x = PyInt_FromLong(CL_FRAMES_PER_CHUNK);
1645 if (x == NULL || PyDict_SetItemString(d, "FRAMES_PER_CHUNK", x) < 0)
1646 return;
1647 Py_DECREF(x);
1648 #endif
1649 #ifdef CL_FRAME_BUFFER_SIZE
1650 x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE);
1651 if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE", x) < 0)
1652 return;
1653 Py_DECREF(x);
1654 #endif
1655 #ifdef CL_FRAME_BUFFER_SIZE_ZERO
1656 x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE_ZERO);
1657 if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE_ZERO", x) < 0)
1658 return;
1659 Py_DECREF(x);
1660 #endif
1661 #ifdef CL_FRAME_INDEX
1662 x = PyInt_FromLong(CL_FRAME_INDEX);
1663 if (x == NULL || PyDict_SetItemString(d, "FRAME_INDEX", x) < 0)
1664 return;
1665 Py_DECREF(x);
1666 #endif
1667 #ifdef CL_FRAME_RATE
1668 x = PyInt_FromLong(CL_FRAME_RATE);
1669 if (x == NULL || PyDict_SetItemString(d, "FRAME_RATE", x) < 0)
1670 return;
1671 Py_DECREF(x);
1672 #endif
1673 #ifdef CL_FRAME_SIZE
1674 x = PyInt_FromLong(CL_FRAME_SIZE);
1675 if (x == NULL || PyDict_SetItemString(d, "FRAME_SIZE", x) < 0)
1676 return;
1677 Py_DECREF(x);
1678 #endif
1679 #ifdef CL_FRAME_TYPE
1680 x = PyInt_FromLong(CL_FRAME_TYPE);
1681 if (x == NULL || PyDict_SetItemString(d, "FRAME_TYPE", x) < 0)
1682 return;
1683 Py_DECREF(x);
1684 #endif
1685 #ifdef CL_G711_ALAW
1686 x = PyInt_FromLong(CL_G711_ALAW);
1687 if (x == NULL || PyDict_SetItemString(d, "G711_ALAW", x) < 0)
1688 return;
1689 Py_DECREF(x);
1690 #endif
1691 #ifdef CL_G711_ALAW_SOFTWARE
1692 x = PyInt_FromLong(CL_G711_ALAW_SOFTWARE);
1693 if (x == NULL || PyDict_SetItemString(d, "G711_ALAW_SOFTWARE", x) < 0)
1694 return;
1695 Py_DECREF(x);
1696 #endif
1697 #ifdef CL_G711_ULAW
1698 x = PyInt_FromLong(CL_G711_ULAW);
1699 if (x == NULL || PyDict_SetItemString(d, "G711_ULAW", x) < 0)
1700 return;
1701 Py_DECREF(x);
1702 #endif
1703 #ifdef CL_G711_ULAW_SOFTWARE
1704 x = PyInt_FromLong(CL_G711_ULAW_SOFTWARE);
1705 if (x == NULL || PyDict_SetItemString(d, "G711_ULAW_SOFTWARE", x) < 0)
1706 return;
1707 Py_DECREF(x);
1708 #endif
1709 #ifdef CL_GRAYSCALE
1710 x = PyInt_FromLong(CL_GRAYSCALE);
1711 if (x == NULL || PyDict_SetItemString(d, "GRAYSCALE", x) < 0)
1712 return;
1713 Py_DECREF(x);
1714 #endif
1715 #ifdef CL_HDCC
1716 x = PyInt_FromLong(CL_HDCC);
1717 if (x == NULL || PyDict_SetItemString(d, "HDCC", x) < 0)
1718 return;
1719 Py_DECREF(x);
1720 #endif
1721 #ifdef CL_HDCC_SAMPLES_PER_TILE
1722 x = PyInt_FromLong(CL_HDCC_SAMPLES_PER_TILE);
1723 if (x == NULL || PyDict_SetItemString(d, "HDCC_SAMPLES_PER_TILE", x) < 0)
1724 return;
1725 Py_DECREF(x);
1726 #endif
1727 #ifdef CL_HDCC_SOFTWARE
1728 x = PyInt_FromLong(CL_HDCC_SOFTWARE);
1729 if (x == NULL || PyDict_SetItemString(d, "HDCC_SOFTWARE", x) < 0)
1730 return;
1731 Py_DECREF(x);
1732 #endif
1733 #ifdef CL_HDCC_TILE_THRESHOLD
1734 x = PyInt_FromLong(CL_HDCC_TILE_THRESHOLD);
1735 if (x == NULL || PyDict_SetItemString(d, "HDCC_TILE_THRESHOLD", x) < 0)
1736 return;
1737 Py_DECREF(x);
1738 #endif
1739 #ifdef CL_HEADER_START_CODE
1740 x = PyInt_FromLong(CL_HEADER_START_CODE);
1741 if (x == NULL || PyDict_SetItemString(d, "HEADER_START_CODE", x) < 0)
1742 return;
1743 Py_DECREF(x);
1744 #endif
1745 #ifdef CL_IMAGEINFO_FIELDMASK
1746 x = PyInt_FromLong(CL_IMAGEINFO_FIELDMASK);
1747 if (x == NULL || PyDict_SetItemString(d, "IMAGEINFO_FIELDMASK", x) < 0)
1748 return;
1749 Py_DECREF(x);
1750 #endif
1751 #ifdef CL_IMAGE_CROP_BOTTOM
1752 x = PyInt_FromLong(CL_IMAGE_CROP_BOTTOM);
1753 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_BOTTOM", x) < 0)
1754 return;
1755 Py_DECREF(x);
1756 #endif
1757 #ifdef CL_IMAGE_CROP_LEFT
1758 x = PyInt_FromLong(CL_IMAGE_CROP_LEFT);
1759 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_LEFT", x) < 0)
1760 return;
1761 Py_DECREF(x);
1762 #endif
1763 #ifdef CL_IMAGE_CROP_RIGHT
1764 x = PyInt_FromLong(CL_IMAGE_CROP_RIGHT);
1765 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_RIGHT", x) < 0)
1766 return;
1767 Py_DECREF(x);
1768 #endif
1769 #ifdef CL_IMAGE_CROP_TOP
1770 x = PyInt_FromLong(CL_IMAGE_CROP_TOP);
1771 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_TOP", x) < 0)
1772 return;
1773 Py_DECREF(x);
1774 #endif
1775 #ifdef CL_IMAGE_HEIGHT
1776 x = PyInt_FromLong(CL_IMAGE_HEIGHT);
1777 if (x == NULL || PyDict_SetItemString(d, "IMAGE_HEIGHT", x) < 0)
1778 return;
1779 Py_DECREF(x);
1780 #endif
1781 #ifdef CL_IMAGE_WIDTH
1782 x = PyInt_FromLong(CL_IMAGE_WIDTH);
1783 if (x == NULL || PyDict_SetItemString(d, "IMAGE_WIDTH", x) < 0)
1784 return;
1785 Py_DECREF(x);
1786 #endif
1787 #ifdef CL_IMPACT_CODEC_CONTROL
1788 x = PyInt_FromLong(CL_IMPACT_CODEC_CONTROL);
1789 if (x == NULL || PyDict_SetItemString(d, "IMPACT_CODEC_CONTROL", x) < 0)
1790 return;
1791 Py_DECREF(x);
1792 #endif
1793 #ifdef CL_IMPACT_FRAME_INTERLEAVE
1794 x = PyInt_FromLong(CL_IMPACT_FRAME_INTERLEAVE);
1795 if (x == NULL || PyDict_SetItemString(d, "IMPACT_FRAME_INTERLEAVE", x) < 0)
1796 return;
1797 Py_DECREF(x);
1798 #endif
1799 #ifdef CL_IMPACT_NUM_PARAMS
1800 x = PyInt_FromLong(CL_IMPACT_NUM_PARAMS);
1801 if (x == NULL || PyDict_SetItemString(d, "IMPACT_NUM_PARAMS", x) < 0)
1802 return;
1803 Py_DECREF(x);
1804 #endif
1805 #ifdef CL_INTERNAL_FORMAT
1806 x = PyInt_FromLong(CL_INTERNAL_FORMAT);
1807 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_FORMAT", x) < 0)
1808 return;
1809 Py_DECREF(x);
1810 #endif
1811 #ifdef CL_INTERNAL_IMAGE_HEIGHT
1812 x = PyInt_FromLong(CL_INTERNAL_IMAGE_HEIGHT);
1813 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_HEIGHT", x) < 0)
1814 return;
1815 Py_DECREF(x);
1816 #endif
1817 #ifdef CL_INTERNAL_IMAGE_WIDTH
1818 x = PyInt_FromLong(CL_INTERNAL_IMAGE_WIDTH);
1819 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_WIDTH", x) < 0)
1820 return;
1821 Py_DECREF(x);
1822 #endif
1823 #ifdef CL_INTRA
1824 x = PyInt_FromLong(CL_INTRA);
1825 if (x == NULL || PyDict_SetItemString(d, "INTRA", x) < 0)
1826 return;
1827 Py_DECREF(x);
1828 #endif
1829 #ifdef CL_JPEG
1830 x = PyInt_FromLong(CL_JPEG);
1831 if (x == NULL || PyDict_SetItemString(d, "JPEG", x) < 0)
1832 return;
1833 Py_DECREF(x);
1834 #endif
1835 #ifdef CL_JPEG_COSMO
1836 x = PyInt_FromLong(CL_JPEG_COSMO);
1837 if (x == NULL || PyDict_SetItemString(d, "JPEG_COSMO", x) < 0)
1838 return;
1839 Py_DECREF(x);
1840 #endif
1841 #ifdef CL_JPEG_ERROR
1842 x = PyInt_FromLong(CL_JPEG_ERROR);
1843 if (x == NULL || PyDict_SetItemString(d, "JPEG_ERROR", x) < 0)
1844 return;
1845 Py_DECREF(x);
1846 #endif
1847 #ifdef CL_JPEG_IMPACT
1848 x = PyInt_FromLong(CL_JPEG_IMPACT);
1849 if (x == NULL || PyDict_SetItemString(d, "JPEG_IMPACT", x) < 0)
1850 return;
1851 Py_DECREF(x);
1852 #endif
1853 #ifdef CL_JPEG_NUM_PARAMS
1854 x = PyInt_FromLong(CL_JPEG_NUM_PARAMS);
1855 if (x == NULL || PyDict_SetItemString(d, "JPEG_NUM_PARAMS", x) < 0)
1856 return;
1857 Py_DECREF(x);
1858 #endif
1859 #ifdef CL_JPEG_QUALITY_FACTOR
1860 x = PyInt_FromLong(CL_JPEG_QUALITY_FACTOR);
1861 if (x == NULL || PyDict_SetItemString(d, "JPEG_QUALITY_FACTOR", x) < 0)
1862 return;
1863 Py_DECREF(x);
1864 #endif
1865 #ifdef CL_JPEG_QUANTIZATION_TABLES
1866 x = PyInt_FromLong(CL_JPEG_QUANTIZATION_TABLES);
1867 if (x == NULL || PyDict_SetItemString(d, "JPEG_QUANTIZATION_TABLES", x) < 0)
1868 return;
1869 Py_DECREF(x);
1870 #endif
1871 #ifdef CL_JPEG_SOFTWARE
1872 x = PyInt_FromLong(CL_JPEG_SOFTWARE);
1873 if (x == NULL || PyDict_SetItemString(d, "JPEG_SOFTWARE", x) < 0)
1874 return;
1875 Py_DECREF(x);
1876 #endif
1877 #ifdef CL_JPEG_STREAM_HEADERS
1878 x = PyInt_FromLong(CL_JPEG_STREAM_HEADERS);
1879 if (x == NULL || PyDict_SetItemString(d, "JPEG_STREAM_HEADERS", x) < 0)
1880 return;
1881 Py_DECREF(x);
1882 #endif
1883 #ifdef CL_KEYFRAME
1884 x = PyInt_FromLong(CL_KEYFRAME);
1885 if (x == NULL || PyDict_SetItemString(d, "KEYFRAME", x) < 0)
1886 return;
1887 Py_DECREF(x);
1888 #endif
1889 #ifdef CL_KEYFRAME_DISTANCE
1890 x = PyInt_FromLong(CL_KEYFRAME_DISTANCE);
1891 if (x == NULL || PyDict_SetItemString(d, "KEYFRAME_DISTANCE", x) < 0)
1892 return;
1893 Py_DECREF(x);
1894 #endif
1895 #ifdef CL_LAST_FRAME_INDEX
1896 x = PyInt_FromLong(CL_LAST_FRAME_INDEX);
1897 if (x == NULL || PyDict_SetItemString(d, "LAST_FRAME_INDEX", x) < 0)
1898 return;
1899 Py_DECREF(x);
1900 #endif
1901 #ifdef CL_LAYER
1902 x = PyInt_FromLong(CL_LAYER);
1903 if (x == NULL || PyDict_SetItemString(d, "LAYER", x) < 0)
1904 return;
1905 Py_DECREF(x);
1906 #endif
1907 #ifdef CL_LUMA_THRESHOLD
1908 x = PyInt_FromLong(CL_LUMA_THRESHOLD);
1909 if (x == NULL || PyDict_SetItemString(d, "LUMA_THRESHOLD", x) < 0)
1910 return;
1911 Py_DECREF(x);
1912 #endif
1913 #ifdef CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS
1914 x = PyInt_FromLong(CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS);
1915 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_AUDIO_ALGORITHMS", x) < 0)
1916 return;
1917 Py_DECREF(x);
1918 #endif
1919 #ifdef CL_MAX_NUMBER_OF_FORMATS
1920 x = PyInt_FromLong(CL_MAX_NUMBER_OF_FORMATS);
1921 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_FORMATS", x) < 0)
1922 return;
1923 Py_DECREF(x);
1924 #endif
1925 #ifdef CL_MAX_NUMBER_OF_ORIGINAL_FORMATS
1926 x = PyInt_FromLong(CL_MAX_NUMBER_OF_ORIGINAL_FORMATS);
1927 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_ORIGINAL_FORMATS", x) < 0)
1928 return;
1929 Py_DECREF(x);
1930 #endif
1931 #ifdef CL_MAX_NUMBER_OF_PARAMS
1932 x = PyInt_FromLong(CL_MAX_NUMBER_OF_PARAMS);
1933 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_PARAMS", x) < 0)
1934 return;
1935 Py_DECREF(x);
1936 #endif
1937 #ifdef CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS
1938 x = PyInt_FromLong(CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS);
1939 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_VIDEO_ALGORITHMS", x) < 0)
1940 return;
1941 Py_DECREF(x);
1942 #endif
1943 #ifdef CL_MONO
1944 x = PyInt_FromLong(CL_MONO);
1945 if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
1946 return;
1947 Py_DECREF(x);
1948 #endif
1949 #ifdef CL_MPEG1_AUDIO_AWARE
1950 x = PyInt_FromLong(CL_MPEG1_AUDIO_AWARE);
1951 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_AWARE", x) < 0)
1952 return;
1953 Py_DECREF(x);
1954 #endif
1955 #ifdef CL_MPEG1_AUDIO_LAYER
1956 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER);
1957 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER", x) < 0)
1958 return;
1959 Py_DECREF(x);
1960 #endif
1961 #ifdef CL_MPEG1_AUDIO_LAYER_I
1962 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_I);
1963 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_I", x) < 0)
1964 return;
1965 Py_DECREF(x);
1966 #endif
1967 #ifdef CL_MPEG1_AUDIO_LAYER_II
1968 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_II);
1969 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_II", x) < 0)
1970 return;
1971 Py_DECREF(x);
1972 #endif
1973 #ifdef CL_MPEG1_AUDIO_MODE
1974 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE);
1975 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE", x) < 0)
1976 return;
1977 Py_DECREF(x);
1978 #endif
1979 #ifdef CL_MPEG1_AUDIO_MODE_DUAL
1980 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_DUAL);
1981 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_DUAL", x) < 0)
1982 return;
1983 Py_DECREF(x);
1984 #endif
1985 #ifdef CL_MPEG1_AUDIO_MODE_JOINT
1986 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_JOINT);
1987 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_JOINT", x) < 0)
1988 return;
1989 Py_DECREF(x);
1990 #endif
1991 #ifdef CL_MPEG1_AUDIO_MODE_SINGLE
1992 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_SINGLE);
1993 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_SINGLE", x) < 0)
1994 return;
1995 Py_DECREF(x);
1996 #endif
1997 #ifdef CL_MPEG1_AUDIO_MODE_STEREO
1998 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_STEREO);
1999 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_STEREO", x) < 0)
2000 return;
2001 Py_DECREF(x);
2002 #endif
2003 #ifdef CL_MPEG1_AUDIO_SOFTWARE
2004 x = PyInt_FromLong(CL_MPEG1_AUDIO_SOFTWARE);
2005 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_SOFTWARE", x) < 0)
2006 return;
2007 Py_DECREF(x);
2008 #endif
2009 #ifdef CL_MPEG1_END_OF_STREAM
2010 x = PyInt_FromLong(CL_MPEG1_END_OF_STREAM);
2011 if (x == NULL || PyDict_SetItemString(d, "MPEG1_END_OF_STREAM", x) < 0)
2012 return;
2013 Py_DECREF(x);
2014 #endif
2015 #ifdef CL_MPEG1_ERROR
2016 x = PyInt_FromLong(CL_MPEG1_ERROR);
2017 if (x == NULL || PyDict_SetItemString(d, "MPEG1_ERROR", x) < 0)
2018 return;
2019 Py_DECREF(x);
2020 #endif
2021 #ifdef CL_MPEG1_NUM_PARAMS
2022 x = PyInt_FromLong(CL_MPEG1_NUM_PARAMS);
2023 if (x == NULL || PyDict_SetItemString(d, "MPEG1_NUM_PARAMS", x) < 0)
2024 return;
2025 Py_DECREF(x);
2026 #endif
2027 #ifdef CL_MPEG1_VIDEO_M
2028 x = PyInt_FromLong(CL_MPEG1_VIDEO_M);
2029 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_M", x) < 0)
2030 return;
2031 Py_DECREF(x);
2032 #endif
2033 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X
2034 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X);
2035 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X", x) < 0)
2036 return;
2037 Py_DECREF(x);
2038 #endif
2039 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y
2040 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y);
2041 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y", x) < 0)
2042 return;
2043 Py_DECREF(x);
2044 #endif
2045 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X
2046 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X);
2047 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X", x) < 0)
2048 return;
2049 Py_DECREF(x);
2050 #endif
2051 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y
2052 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y);
2053 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y", x) < 0)
2054 return;
2055 Py_DECREF(x);
2056 #endif
2057 #ifdef CL_MPEG1_VIDEO_N
2058 x = PyInt_FromLong(CL_MPEG1_VIDEO_N);
2059 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_N", x) < 0)
2060 return;
2061 Py_DECREF(x);
2062 #endif
2063 #ifdef CL_MPEG1_VIDEO_SOFTNESS
2064 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS);
2065 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS", x) < 0)
2066 return;
2067 Py_DECREF(x);
2068 #endif
2069 #ifdef CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM
2070 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM);
2071 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MAXIMUM", x) < 0)
2072 return;
2073 Py_DECREF(x);
2074 #endif
2075 #ifdef CL_MPEG1_VIDEO_SOFTNESS_MEDIUM
2076 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MEDIUM);
2077 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MEDIUM", x) < 0)
2078 return;
2079 Py_DECREF(x);
2080 #endif
2081 #ifdef CL_MPEG1_VIDEO_SOFTNESS_NONE
2082 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_NONE);
2083 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_NONE", x) < 0)
2084 return;
2085 Py_DECREF(x);
2086 #endif
2087 #ifdef CL_MPEG1_VIDEO_SOFTWARE
2088 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTWARE);
2089 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTWARE", x) < 0)
2090 return;
2091 Py_DECREF(x);
2092 #endif
2093 #ifdef CL_MPEG_VIDEO
2094 x = PyInt_FromLong(CL_MPEG_VIDEO);
2095 if (x == NULL || PyDict_SetItemString(d, "MPEG_VIDEO", x) < 0)
2096 return;
2097 Py_DECREF(x);
2098 #endif
2099 #ifdef CL_MULTIRATE_AWARE
2100 x = PyInt_FromLong(CL_MULTIRATE_AWARE);
2101 if (x == NULL || PyDict_SetItemString(d, "MULTIRATE_AWARE", x) < 0)
2102 return;
2103 Py_DECREF(x);
2104 #endif
2105 #ifdef CL_MVC1
2106 x = PyInt_FromLong(CL_MVC1);
2107 if (x == NULL || PyDict_SetItemString(d, "MVC1", x) < 0)
2108 return;
2109 Py_DECREF(x);
2110 #endif
2111 #ifdef CL_MVC1_SOFTWARE
2112 x = PyInt_FromLong(CL_MVC1_SOFTWARE);
2113 if (x == NULL || PyDict_SetItemString(d, "MVC1_SOFTWARE", x) < 0)
2114 return;
2115 Py_DECREF(x);
2116 #endif
2117 #ifdef CL_MVC2
2118 x = PyInt_FromLong(CL_MVC2);
2119 if (x == NULL || PyDict_SetItemString(d, "MVC2", x) < 0)
2120 return;
2121 Py_DECREF(x);
2122 #endif
2123 #ifdef CL_MVC2_BLENDING
2124 x = PyInt_FromLong(CL_MVC2_BLENDING);
2125 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING", x) < 0)
2126 return;
2127 Py_DECREF(x);
2128 #endif
2129 #ifdef CL_MVC2_BLENDING_OFF
2130 x = PyInt_FromLong(CL_MVC2_BLENDING_OFF);
2131 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_OFF", x) < 0)
2132 return;
2133 Py_DECREF(x);
2134 #endif
2135 #ifdef CL_MVC2_BLENDING_ON
2136 x = PyInt_FromLong(CL_MVC2_BLENDING_ON);
2137 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_ON", x) < 0)
2138 return;
2139 Py_DECREF(x);
2140 #endif
2141 #ifdef CL_MVC2_CHROMA_THRESHOLD
2142 x = PyInt_FromLong(CL_MVC2_CHROMA_THRESHOLD);
2143 if (x == NULL || PyDict_SetItemString(d, "MVC2_CHROMA_THRESHOLD", x) < 0)
2144 return;
2145 Py_DECREF(x);
2146 #endif
2147 #ifdef CL_MVC2_EDGE_THRESHOLD
2148 x = PyInt_FromLong(CL_MVC2_EDGE_THRESHOLD);
2149 if (x == NULL || PyDict_SetItemString(d, "MVC2_EDGE_THRESHOLD", x) < 0)
2150 return;
2151 Py_DECREF(x);
2152 #endif
2153 #ifdef CL_MVC2_ERROR
2154 x = PyInt_FromLong(CL_MVC2_ERROR);
2155 if (x == NULL || PyDict_SetItemString(d, "MVC2_ERROR", x) < 0)
2156 return;
2157 Py_DECREF(x);
2158 #endif
2159 #ifdef CL_MVC2_LUMA_THRESHOLD
2160 x = PyInt_FromLong(CL_MVC2_LUMA_THRESHOLD);
2161 if (x == NULL || PyDict_SetItemString(d, "MVC2_LUMA_THRESHOLD", x) < 0)
2162 return;
2163 Py_DECREF(x);
2164 #endif
2165 #ifdef CL_MVC2_SOFTWARE
2166 x = PyInt_FromLong(CL_MVC2_SOFTWARE);
2167 if (x == NULL || PyDict_SetItemString(d, "MVC2_SOFTWARE", x) < 0)
2168 return;
2169 Py_DECREF(x);
2170 #endif
2171 #ifdef CL_MVC3_QUALITY_LEVEL
2172 x = PyInt_FromLong(CL_MVC3_QUALITY_LEVEL);
2173 if (x == NULL || PyDict_SetItemString(d, "MVC3_QUALITY_LEVEL", x) < 0)
2174 return;
2175 Py_DECREF(x);
2176 #endif
2177 #ifdef CL_MVC3_SOFTWARE
2178 x = PyInt_FromLong(CL_MVC3_SOFTWARE);
2179 if (x == NULL || PyDict_SetItemString(d, "MVC3_SOFTWARE", x) < 0)
2180 return;
2181 Py_DECREF(x);
2182 #endif
2183 #ifdef CL_NEXT_NOT_AVAILABLE
2184 x = PyInt_FromLong(CL_NEXT_NOT_AVAILABLE);
2185 if (x == NULL || PyDict_SetItemString(d, "NEXT_NOT_AVAILABLE", x) < 0)
2186 return;
2187 Py_DECREF(x);
2188 #endif
2189 #ifdef CL_NOISE_MARGIN
2190 x = PyInt_FromLong(CL_NOISE_MARGIN);
2191 if (x == NULL || PyDict_SetItemString(d, "NOISE_MARGIN", x) < 0)
2192 return;
2193 Py_DECREF(x);
2194 #endif
2195 #ifdef CL_NONE
2196 x = PyInt_FromLong(CL_NONE);
2197 if (x == NULL || PyDict_SetItemString(d, "NONE", x) < 0)
2198 return;
2199 Py_DECREF(x);
2200 #endif
2201 #ifdef CL_NUMBER_OF_FORMATS
2202 x = PyInt_FromLong(CL_NUMBER_OF_FORMATS);
2203 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FORMATS", x) < 0)
2204 return;
2205 Py_DECREF(x);
2206 #endif
2207 #ifdef CL_NUMBER_OF_FRAMES
2208 x = PyInt_FromLong(CL_NUMBER_OF_FRAMES);
2209 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FRAMES", x) < 0)
2210 return;
2211 Py_DECREF(x);
2212 #endif
2213 #ifdef CL_NUMBER_OF_PARAMS
2214 x = PyInt_FromLong(CL_NUMBER_OF_PARAMS);
2215 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS", x) < 0)
2216 return;
2217 Py_DECREF(x);
2218 #endif
2219 #ifdef CL_NUMBER_OF_PARAMS_FREEZE
2220 x = PyInt_FromLong(CL_NUMBER_OF_PARAMS_FREEZE);
2221 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS_FREEZE", x) < 0)
2222 return;
2223 Py_DECREF(x);
2224 #endif
2225 #ifdef CL_NUMBER_OF_VIDEO_FORMATS
2226 x = PyInt_FromLong(CL_NUMBER_OF_VIDEO_FORMATS);
2227 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_VIDEO_FORMATS", x) < 0)
2228 return;
2229 Py_DECREF(x);
2230 #endif
2231 #ifdef CL_ORIENTATION
2232 x = PyInt_FromLong(CL_ORIENTATION);
2233 if (x == NULL || PyDict_SetItemString(d, "ORIENTATION", x) < 0)
2234 return;
2235 Py_DECREF(x);
2236 #endif
2237 #ifdef CL_ORIGINAL_FORMAT
2238 x = PyInt_FromLong(CL_ORIGINAL_FORMAT);
2239 if (x == NULL || PyDict_SetItemString(d, "ORIGINAL_FORMAT", x) < 0)
2240 return;
2241 Py_DECREF(x);
2242 #endif
2243 #ifdef CL_PARAM_OUT_OF_RANGE
2244 x = PyInt_FromLong(CL_PARAM_OUT_OF_RANGE);
2245 if (x == NULL || PyDict_SetItemString(d, "PARAM_OUT_OF_RANGE", x) < 0)
2246 return;
2247 Py_DECREF(x);
2248 #endif
2249 #ifdef CL_PIXEL_ASPECT
2250 x = PyInt_FromLong(CL_PIXEL_ASPECT);
2251 if (x == NULL || PyDict_SetItemString(d, "PIXEL_ASPECT", x) < 0)
2252 return;
2253 Py_DECREF(x);
2254 #endif
2255 #ifdef CL_PREDICTED
2256 x = PyInt_FromLong(CL_PREDICTED);
2257 if (x == NULL || PyDict_SetItemString(d, "PREDICTED", x) < 0)
2258 return;
2259 Py_DECREF(x);
2260 #endif
2261 #ifdef CL_PREROLL
2262 x = PyInt_FromLong(CL_PREROLL);
2263 if (x == NULL || PyDict_SetItemString(d, "PREROLL", x) < 0)
2264 return;
2265 Py_DECREF(x);
2266 #endif
2267 #ifdef CL_QUALITY_FACTOR
2268 x = PyInt_FromLong(CL_QUALITY_FACTOR);
2269 if (x == NULL || PyDict_SetItemString(d, "QUALITY_FACTOR", x) < 0)
2270 return;
2271 Py_DECREF(x);
2272 #endif
2273 #ifdef CL_QUALITY_LEVEL
2274 x = PyInt_FromLong(CL_QUALITY_LEVEL);
2275 if (x == NULL || PyDict_SetItemString(d, "QUALITY_LEVEL", x) < 0)
2276 return;
2277 Py_DECREF(x);
2278 #endif
2279 #ifdef CL_QUALITY_SPATIAL
2280 x = PyInt_FromLong(CL_QUALITY_SPATIAL);
2281 if (x == NULL || PyDict_SetItemString(d, "QUALITY_SPATIAL", x) < 0)
2282 return;
2283 Py_DECREF(x);
2284 #endif
2285 #ifdef CL_QUALITY_TEMPORAL
2286 x = PyInt_FromLong(CL_QUALITY_TEMPORAL);
2287 if (x == NULL || PyDict_SetItemString(d, "QUALITY_TEMPORAL", x) < 0)
2288 return;
2289 Py_DECREF(x);
2290 #endif
2291 #ifdef CL_QUANTIZATION_TABLES
2292 x = PyInt_FromLong(CL_QUANTIZATION_TABLES);
2293 if (x == NULL || PyDict_SetItemString(d, "QUANTIZATION_TABLES", x) < 0)
2294 return;
2295 Py_DECREF(x);
2296 #endif
2297 #ifdef CL_RANGE_VALUE
2298 x = PyInt_FromLong(CL_RANGE_VALUE);
2299 if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
2300 return;
2301 Py_DECREF(x);
2302 #endif
2303 #ifdef CL_RGB
2304 x = PyInt_FromLong(CL_RGB);
2305 if (x == NULL || PyDict_SetItemString(d, "RGB", x) < 0)
2306 return;
2307 Py_DECREF(x);
2308 #endif
2309 #ifdef CL_RGB332
2310 x = PyInt_FromLong(CL_RGB332);
2311 if (x == NULL || PyDict_SetItemString(d, "RGB332", x) < 0)
2312 return;
2313 Py_DECREF(x);
2314 #endif
2315 #ifdef CL_RGB8
2316 x = PyInt_FromLong(CL_RGB8);
2317 if (x == NULL || PyDict_SetItemString(d, "RGB8", x) < 0)
2318 return;
2319 Py_DECREF(x);
2320 #endif
2321 #ifdef CL_RGBA
2322 x = PyInt_FromLong(CL_RGBA);
2323 if (x == NULL || PyDict_SetItemString(d, "RGBA", x) < 0)
2324 return;
2325 Py_DECREF(x);
2326 #endif
2327 #ifdef CL_RGBX
2328 x = PyInt_FromLong(CL_RGBX);
2329 if (x == NULL || PyDict_SetItemString(d, "RGBX", x) < 0)
2330 return;
2331 Py_DECREF(x);
2332 #endif
2333 #ifdef CL_RLE
2334 x = PyInt_FromLong(CL_RLE);
2335 if (x == NULL || PyDict_SetItemString(d, "RLE", x) < 0)
2336 return;
2337 Py_DECREF(x);
2338 #endif
2339 #ifdef CL_RLE24
2340 x = PyInt_FromLong(CL_RLE24);
2341 if (x == NULL || PyDict_SetItemString(d, "RLE24", x) < 0)
2342 return;
2343 Py_DECREF(x);
2344 #endif
2345 #ifdef CL_RLE24_SOFTWARE
2346 x = PyInt_FromLong(CL_RLE24_SOFTWARE);
2347 if (x == NULL || PyDict_SetItemString(d, "RLE24_SOFTWARE", x) < 0)
2348 return;
2349 Py_DECREF(x);
2350 #endif
2351 #ifdef CL_RLE_SOFTWARE
2352 x = PyInt_FromLong(CL_RLE_SOFTWARE);
2353 if (x == NULL || PyDict_SetItemString(d, "RLE_SOFTWARE", x) < 0)
2354 return;
2355 Py_DECREF(x);
2356 #endif
2357 #ifdef CL_RTR
2358 x = PyInt_FromLong(CL_RTR);
2359 if (x == NULL || PyDict_SetItemString(d, "RTR", x) < 0)
2360 return;
2361 Py_DECREF(x);
2362 #endif
2363 #ifdef CL_RTR1
2364 x = PyInt_FromLong(CL_RTR1);
2365 if (x == NULL || PyDict_SetItemString(d, "RTR1", x) < 0)
2366 return;
2367 Py_DECREF(x);
2368 #endif
2369 #ifdef CL_RTR_QUALITY_LEVEL
2370 x = PyInt_FromLong(CL_RTR_QUALITY_LEVEL);
2371 if (x == NULL || PyDict_SetItemString(d, "RTR_QUALITY_LEVEL", x) < 0)
2372 return;
2373 Py_DECREF(x);
2374 #endif
2375 #ifdef CL_SAMPLES_PER_TILE
2376 x = PyInt_FromLong(CL_SAMPLES_PER_TILE);
2377 if (x == NULL || PyDict_SetItemString(d, "SAMPLES_PER_TILE", x) < 0)
2378 return;
2379 Py_DECREF(x);
2380 #endif
2381 #ifdef CL_SCHEME_BUSY
2382 x = PyInt_FromLong(CL_SCHEME_BUSY);
2383 if (x == NULL || PyDict_SetItemString(d, "SCHEME_BUSY", x) < 0)
2384 return;
2385 Py_DECREF(x);
2386 #endif
2387 #ifdef CL_SCHEME_NOT_AVAILABLE
2388 x = PyInt_FromLong(CL_SCHEME_NOT_AVAILABLE);
2389 if (x == NULL || PyDict_SetItemString(d, "SCHEME_NOT_AVAILABLE", x) < 0)
2390 return;
2391 Py_DECREF(x);
2392 #endif
2393 #ifdef CL_SPEED
2394 x = PyInt_FromLong(CL_SPEED);
2395 if (x == NULL || PyDict_SetItemString(d, "SPEED", x) < 0)
2396 return;
2397 Py_DECREF(x);
2398 #endif
2399 #ifdef CL_STEREO_INTERLEAVED
2400 x = PyInt_FromLong(CL_STEREO_INTERLEAVED);
2401 if (x == NULL || PyDict_SetItemString(d, "STEREO_INTERLEAVED", x) < 0)
2402 return;
2403 Py_DECREF(x);
2404 #endif
2405 #ifdef CL_STREAM_HEADERS
2406 x = PyInt_FromLong(CL_STREAM_HEADERS);
2407 if (x == NULL || PyDict_SetItemString(d, "STREAM_HEADERS", x) < 0)
2408 return;
2409 Py_DECREF(x);
2410 #endif
2411 #ifdef CL_TILE_THRESHOLD
2412 x = PyInt_FromLong(CL_TILE_THRESHOLD);
2413 if (x == NULL || PyDict_SetItemString(d, "TILE_THRESHOLD", x) < 0)
2414 return;
2415 Py_DECREF(x);
2416 #endif
2417 #ifdef CL_TOP_DOWN
2418 x = PyInt_FromLong(CL_TOP_DOWN);
2419 if (x == NULL || PyDict_SetItemString(d, "TOP_DOWN", x) < 0)
2420 return;
2421 Py_DECREF(x);
2422 #endif
2423 #ifdef CL_ULAW
2424 x = PyInt_FromLong(CL_ULAW);
2425 if (x == NULL || PyDict_SetItemString(d, "ULAW", x) < 0)
2426 return;
2427 Py_DECREF(x);
2428 #endif
2429 #ifdef CL_UNCOMPRESSED
2430 x = PyInt_FromLong(CL_UNCOMPRESSED);
2431 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED", x) < 0)
2432 return;
2433 Py_DECREF(x);
2434 #endif
2435 #ifdef CL_UNCOMPRESSED_AUDIO
2436 x = PyInt_FromLong(CL_UNCOMPRESSED_AUDIO);
2437 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_AUDIO", x) < 0)
2438 return;
2439 Py_DECREF(x);
2440 #endif
2441 #ifdef CL_UNCOMPRESSED_VIDEO
2442 x = PyInt_FromLong(CL_UNCOMPRESSED_VIDEO);
2443 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_VIDEO", x) < 0)
2444 return;
2445 Py_DECREF(x);
2446 #endif
2447 #ifdef CL_UNKNOWN_SCHEME
2448 x = PyInt_FromLong(CL_UNKNOWN_SCHEME);
2449 if (x == NULL || PyDict_SetItemString(d, "UNKNOWN_SCHEME", x) < 0)
2450 return;
2451 Py_DECREF(x);
2452 #endif
2453 #ifdef CL_VIDEO
2454 x = PyInt_FromLong(CL_VIDEO);
2455 if (x == NULL || PyDict_SetItemString(d, "VIDEO", x) < 0)
2456 return;
2457 Py_DECREF(x);
2458 #endif
2459 #ifdef CL_Y
2460 x = PyInt_FromLong(CL_Y);
2461 if (x == NULL || PyDict_SetItemString(d, "Y", x) < 0)
2462 return;
2463 Py_DECREF(x);
2464 #endif
2465 #ifdef CL_YCbCr
2466 x = PyInt_FromLong(CL_YCbCr);
2467 if (x == NULL || PyDict_SetItemString(d, "YCbCr", x) < 0)
2468 return;
2469 Py_DECREF(x);
2470 #endif
2471 #ifdef CL_YCbCr422
2472 x = PyInt_FromLong(CL_YCbCr422);
2473 if (x == NULL || PyDict_SetItemString(d, "YCbCr422", x) < 0)
2474 return;
2475 Py_DECREF(x);
2476 #endif
2477 #ifdef CL_YCbCr422DC
2478 x = PyInt_FromLong(CL_YCbCr422DC);
2479 if (x == NULL || PyDict_SetItemString(d, "YCbCr422DC", x) < 0)
2480 return;
2481 Py_DECREF(x);
2482 #endif
2483 #ifdef CL_YCbCr422HC
2484 x = PyInt_FromLong(CL_YCbCr422HC);
2485 if (x == NULL || PyDict_SetItemString(d, "YCbCr422HC", x) < 0)
2486 return;
2487 Py_DECREF(x);
2488 #endif
2489 #ifdef CL_YUV
2490 x = PyInt_FromLong(CL_YUV);
2491 if (x == NULL || PyDict_SetItemString(d, "YUV", x) < 0)
2492 return;
2493 Py_DECREF(x);
2494 #endif
2495 #ifdef CL_YUV422
2496 x = PyInt_FromLong(CL_YUV422);
2497 if (x == NULL || PyDict_SetItemString(d, "YUV422", x) < 0)
2498 return;
2499 Py_DECREF(x);
2500 #endif
2501 #ifdef CL_YUV422DC
2502 x = PyInt_FromLong(CL_YUV422DC);
2503 if (x == NULL || PyDict_SetItemString(d, "YUV422DC", x) < 0)
2504 return;
2505 Py_DECREF(x);
2506 #endif
2507 #ifdef CL_YUV422HC
2508 x = PyInt_FromLong(CL_YUV422HC);
2509 if (x == NULL || PyDict_SetItemString(d, "YUV422HC", x) < 0)
2510 return;
2511 Py_DECREF(x);
2512 #endif
2513 #ifdef AWCMP_STEREO
2514 x = PyInt_FromLong(AWCMP_STEREO);
2515 if (x == NULL || PyDict_SetItemString(d, "AWCMP_STEREO", x) < 0)
2516 return;
2517 Py_DECREF(x);
2518 #endif
2519 #ifdef AWCMP_JOINT_STEREO
2520 x = PyInt_FromLong(AWCMP_JOINT_STEREO);
2521 if (x == NULL || PyDict_SetItemString(d, "AWCMP_JOINT_STEREO", x) < 0)
2522 return;
2523 Py_DECREF(x);
2524 #endif
2525 #ifdef AWCMP_INDEPENDENT
2526 x = PyInt_FromLong(AWCMP_INDEPENDENT);
2527 if (x == NULL || PyDict_SetItemString(d, "AWCMP_INDEPENDENT", x) < 0)
2528 return;
2529 Py_DECREF(x);
2530 #endif
2531 #ifdef AWCMP_FIXED_RATE
2532 x = PyInt_FromLong(AWCMP_FIXED_RATE);
2533 if (x == NULL || PyDict_SetItemString(d, "AWCMP_FIXED_RATE", x) < 0)
2534 return;
2535 Py_DECREF(x);
2536 #endif
2537 #ifdef AWCMP_CONST_QUAL
2538 x = PyInt_FromLong(AWCMP_CONST_QUAL);
2539 if (x == NULL || PyDict_SetItemString(d, "AWCMP_CONST_QUAL", x) < 0)
2540 return;
2541 Py_DECREF(x);
2542 #endif
2543 #ifdef AWCMP_LOSSLESS
2544 x = PyInt_FromLong(AWCMP_LOSSLESS);
2545 if (x == NULL || PyDict_SetItemString(d, "AWCMP_LOSSLESS", x) < 0)
2546 return;
2547 Py_DECREF(x);
2548 #endif
2549 #ifdef AWCMP_MPEG_LAYER_I
2550 x = PyInt_FromLong(AWCMP_MPEG_LAYER_I);
2551 if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_I", x) < 0)
2552 return;
2553 Py_DECREF(x);
2554 #endif
2555 #ifdef AWCMP_MPEG_LAYER_II
2556 x = PyInt_FromLong(AWCMP_MPEG_LAYER_II);
2557 if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_II", x) < 0)
2558 return;
2559 Py_DECREF(x);
2560 #endif
2561
2562 (void) clSetErrorHandler(cl_ErrorHandler);
2563 }
python git mirror