Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

clmodule.c@ 281

Last change on this file since 281 was 2, checked in by Yuri Dario, 15 years ago
Initial import for vendor code.
Property svn:eol-style set to `native`
File size: 66.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: python/trunk/Modules/clmodule.c@ 281

Download in other formats: