• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
cl_ErrorHandler(CL_Handle handle,int code,const char * fmt,...)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
param_type_is_float(clobject * self,int param)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 *
cl_CompressImage(PyObject * self,PyObject * args)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 *
cl_DecompressImage(PyObject * self,PyObject * args)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 *
doClose(clobject * self,int (* close_func)(CL_Handle))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 *
clm_CloseCompressor(PyObject * self)208 clm_CloseCompressor(PyObject *self)
209 {
210     return doClose(SELF, clCloseCompressor);
211 }
212 
213 static PyObject *
clm_CloseDecompressor(PyObject * self)214 clm_CloseDecompressor(PyObject *self)
215 {
216     return doClose(SELF, clCloseDecompressor);
217 }
218 
219 static PyObject *
clm_Compress(PyObject * self,PyObject * args)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 *
clm_Decompress(PyObject * self,PyObject * args)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 *
doParams(clobject * self,PyObject * args,int (* func)(CL_Handle,int *,int),int modified)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 *
clm_GetParams(PyObject * self,PyObject * args)373 clm_GetParams(PyObject *self, PyObject *args)
374 {
375     return doParams(SELF, args, clGetParams, 1);
376 }
377 
378 static PyObject *
clm_SetParams(PyObject * self,PyObject * args)379 clm_SetParams(PyObject *self, PyObject *args)
380 {
381     return doParams(SELF, args, clSetParams, 0);
382 }
383 
384 static PyObject *
do_get(clobject * self,PyObject * args,int (* func)(CL_Handle,int))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 *
clm_GetParam(PyObject * self,PyObject * args)409 clm_GetParam(PyObject *self, PyObject *args)
410 {
411     return do_get(SELF, args, clGetParam);
412 }
413 
414 static PyObject *
clm_GetDefault(PyObject * self,PyObject * args)415 clm_GetDefault(PyObject *self, PyObject *args)
416 {
417     return do_get(SELF, args, clGetDefault);
418 }
419 
420 static PyObject *
clm_SetParam(PyObject * self,PyObject * args)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 *
clm_GetParamID(PyObject * self,PyObject * args)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 *
clm_QueryParams(PyObject * self)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 *
clm_GetMinMax(PyObject * self,PyObject * args)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 *
clm_GetName(PyObject * self,PyObject * args)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 *
clm_QuerySchemeFromHandle(PyObject * self)570 clm_QuerySchemeFromHandle(PyObject *self)
571 {
572     CheckCompressor(SELF);
573     return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
574 }
575 
576 static PyObject *
clm_ReadHeader(PyObject * self,PyObject * args)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
cl_dealloc(PyObject * self)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 *
cl_getattr(PyObject * self,char * name)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 *
doOpen(PyObject * self,PyObject * args,int (* open_func)(int,CL_Handle *),int iscompressor)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 *
cl_OpenCompressor(PyObject * self,PyObject * args)695 cl_OpenCompressor(PyObject *self, PyObject *args)
696 {
697     return doOpen(self, args, clOpenCompressor, 1);
698 }
699 
700 static PyObject *
cl_OpenDecompressor(PyObject * self,PyObject * args)701 cl_OpenDecompressor(PyObject *self, PyObject *args)
702 {
703     return doOpen(self, args, clOpenDecompressor, 0);
704 }
705 
706 static PyObject *
cl_QueryScheme(PyObject * self,PyObject * args)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 *
cl_QueryMaxHeaderSize(PyObject * self,PyObject * args)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 *
cl_QueryAlgorithms(PyObject * self,PyObject * args)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 *
cl_QuerySchemeFromName(PyObject * self,PyObject * args)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 *
cl_GetAlgorithmName(PyObject * self,PyObject * args)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 *
do_set(PyObject * self,PyObject * args,int (* func)(int,int,int))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 *
cl_SetDefault(PyObject * self,PyObject * args)865 cl_SetDefault(PyObject *self, PyObject *args)
866 {
867     return do_set(self, args, clSetDefault);
868 }
869 
870 static PyObject *
cl_SetMin(PyObject * self,PyObject * args)871 cl_SetMin(PyObject *self, PyObject *args)
872 {
873     return do_set(self, args, clSetMin);
874 }
875 
876 static PyObject *
cl_SetMax(PyObject * self,PyObject * args)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 
func(BytesPerSample,Int_FromLong)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
initcl(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 }
2564