source: python/vendor/Python-2.7.6/Modules/clmodule.c

Last change on this file was 388, checked in by dmik, 11 years ago

python: Update vendor to 2.7.6.
  • Property svn:eol-style set to native
File size: 73.7 KB
Line 
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
14typedef 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
22static PyObject *ClError; /* exception cl.error */
23
24static 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********************************************************************/
38static void
39cl_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 */
60static int
61param_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********************************************************************/
98static PyObject *
99cl_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
143static PyObject *
144cl_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
184static PyObject *
185doClose(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
207static PyObject *
208clm_CloseCompressor(PyObject *self)
209{
210 return doClose(SELF, clCloseCompressor);
211}
212
213static PyObject *
214clm_CloseDecompressor(PyObject *self)
215{
216 return doClose(SELF, clCloseDecompressor);
217}
218
219static PyObject *
220clm_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
269static PyObject *
270clm_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
306static PyObject *
307doParams(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
372static PyObject *
373clm_GetParams(PyObject *self, PyObject *args)
374{
375 return doParams(SELF, args, clGetParams, 1);
376}
377
378static PyObject *
379clm_SetParams(PyObject *self, PyObject *args)
380{
381 return doParams(SELF, args, clSetParams, 0);
382}
383
384static PyObject *
385do_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
408static PyObject *
409clm_GetParam(PyObject *self, PyObject *args)
410{
411 return do_get(SELF, args, clGetParam);
412}
413
414static PyObject *
415clm_GetDefault(PyObject *self, PyObject *args)
416{
417 return do_get(SELF, args, clGetDefault);
418}
419
420static PyObject *
421clm_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
455static PyObject *
456clm_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
477static PyObject *
478clm_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
525static PyObject *
526clm_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
547static PyObject *
548clm_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
569static PyObject *
570clm_QuerySchemeFromHandle(PyObject *self)
571{
572 CheckCompressor(SELF);
573 return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
574}
575
576static PyObject *
577clm_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
591static 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
608static 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
626static void
627cl_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
638static PyObject *
639cl_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
647static 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
665static PyObject *
666doOpen(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
694static PyObject *
695cl_OpenCompressor(PyObject *self, PyObject *args)
696{
697 return doOpen(self, args, clOpenCompressor, 1);
698}
699
700static PyObject *
701cl_OpenDecompressor(PyObject *self, PyObject *args)
702{
703 return doOpen(self, args, clOpenDecompressor, 0);
704}
705
706static PyObject *
707cl_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
725static PyObject *
726cl_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
736static PyObject *
737cl_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
786static PyObject *
787cl_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
806static PyObject *
807cl_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
824static PyObject *
825do_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
864static PyObject *
865cl_SetDefault(PyObject *self, PyObject *args)
866{
867 return do_set(self, args, clSetDefault);
868}
869
870static PyObject *
871cl_SetMin(PyObject *self, PyObject *args)
872{
873 return do_set(self, args, clSetMin);
874}
875
876static PyObject *
877cl_SetMax(PyObject *self, PyObject *args)
878{
879 return do_set(self, args, clSetMax);
880}
881
882#define func(name, handler) \
883static 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) \
891static 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
898func(BytesPerSample, Int_FromLong)
899func(BytesPerPixel, Int_FromLong)
900func(AudioFormatName, String_FromString)
901func(VideoFormatName, String_FromString)
902func(AlgorithmNumber, Int_FromLong)
903func(AlgorithmType, Int_FromLong)
904func2(Algorithm, Int_FromLong)
905func(ParamNumber, Int_FromLong)
906func(ParamType, Int_FromLong)
907func2(ParamID, Int_FromLong)
908
909#ifdef CLDEBUG
910 static PyObject *
911cvt_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
927static 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
960void
961initcl(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}
Note: See TracBrowser for help on using the repository browser.