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