Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

clmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago
python: Merge vendor 2.7.6 to trunk.
Property svn:eol-style set to `native`
File size: 73.7 KB

Rev	Line
[2]	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 {
[391]	15	PyObject_HEAD
	16	int ob_isCompressor; /* Compressor or Decompressor */
	17	CL_Handle ob_compressorHdl;
	18	int *ob_paramtypes;
	19	int ob_nparams;
[2]	20	} clobject;
	21
[391]	22	static PyObject ClError; / exception cl.error */
[2]	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	*/
[391]	33	#define SELF ((clobject *) self)
[2]	34
	35	/********************************************************************
[391]	36	Utility routines.
[2]	37	********************************************************************/
	38	static void
	39	cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...)
	40	{
[391]	41	va_list ap;
	42	char errbuf[BUFSIZ]; /* hopefully big enough */
	43	char *p;
[2]	44
[391]	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);
[2]	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	{
[391]	63	int bufferlength;
[2]	64
[391]	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;
[2]	70
[391]	71	self->ob_paramtypes = PyMem_NEW(int, bufferlength);
	72	if (self->ob_paramtypes == NULL)
	73	return -1;
	74	self->ob_nparams = bufferlength / 2;
[2]	75
[391]	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	}
[2]	84
[391]	85	if (param < 0 \|\| param >= self->ob_nparams)
	86	return -1;
[2]	87
[391]	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;
[2]	93	}
	94
	95	/********************************************************************
[391]	96	Single image compression/decompression.
[2]	97	********************************************************************/
	98	static PyObject *
	99	cl_CompressImage(PyObject self, PyObject args)
	100	{
[391]	101	int compressionScheme, width, height, originalFormat;
	102	float compressionRatio;
	103	int frameBufferSize, compressedBufferSize;
	104	char *frameBuffer;
	105	PyObject *compressedBuffer;
[2]	106
[391]	107	if (!PyArg_ParseTuple(args, "iiiifs#", &compressionScheme,
	108	&width, &height,
	109	&originalFormat, &compressionRatio, &frameBuffer,
	110	&frameBufferSize))
	111	return NULL;
[2]	112
	113	retry:
[391]	114	compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
	115	if (compressedBuffer == NULL)
	116	return NULL;
[2]	117
[391]	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	}
[2]	130
[391]	131	if (compressedBufferSize > frameBufferSize) {
	132	frameBufferSize = compressedBufferSize;
	133	Py_DECREF(compressedBuffer);
	134	goto retry;
	135	}
[2]	136
[391]	137	if (compressedBufferSize < frameBufferSize)
	138	_PyString_Resize(&compressedBuffer, compressedBufferSize);
[2]	139
[391]	140	return compressedBuffer;
[2]	141	}
	142
	143	static PyObject *
	144	cl_DecompressImage(PyObject self, PyObject args)
	145	{
[391]	146	int compressionScheme, width, height, originalFormat;
	147	char *compressedBuffer;
	148	int compressedBufferSize, frameBufferSize;
	149	PyObject *frameBuffer;
[2]	150
[391]	151	if (!PyArg_ParseTuple(args, "iiiis#", &compressionScheme, &width, &height,
	152	&originalFormat, &compressedBuffer,
	153	&compressedBufferSize))
	154	return NULL;
[2]	155
[391]	156	frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);
[2]	157
[391]	158	frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
	159	if (frameBuffer == NULL)
	160	return NULL;
[2]	161
[391]	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	}
[2]	172
[391]	173	return frameBuffer;
[2]	174	}
	175
	176	/********************************************************************
[391]	177	Sequential compression/decompression.
[2]	178	********************************************************************/
[391]	179	#define CheckCompressor(self) if ((self)->ob_compressorHdl == NULL) { \
	180	PyErr_SetString(PyExc_RuntimeError, "(de)compressor not active"); \
	181	return NULL; \
[2]	182	}
	183
	184	static PyObject *
	185	doClose(clobject self, int (close_func)(CL_Handle))
	186	{
[391]	187	CheckCompressor(self);
[2]	188
[391]	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	}
[2]	196
[391]	197	self->ob_compressorHdl = NULL;
[2]	198
[391]	199	if (self->ob_paramtypes)
	200	PyMem_DEL(self->ob_paramtypes);
	201	self->ob_paramtypes = NULL;
[2]	202
[391]	203	Py_INCREF(Py_None);
	204	return Py_None;
[2]	205	}
	206
	207	static PyObject *
	208	clm_CloseCompressor(PyObject *self)
	209	{
[391]	210	return doClose(SELF, clCloseCompressor);
[2]	211	}
	212
	213	static PyObject *
	214	clm_CloseDecompressor(PyObject *self)
	215	{
[391]	216	return doClose(SELF, clCloseDecompressor);
[2]	217	}
	218
	219	static PyObject *
	220	clm_Compress(PyObject self, PyObject args)
	221	{
[391]	222	int numberOfFrames;
	223	int frameBufferSize, compressedBufferSize, size;
	224	char *frameBuffer;
	225	PyObject *data;
[2]	226
[391]	227	CheckCompressor(SELF);
[2]	228
[391]	229	if (!PyArg_Parse(args, "(is#)", &numberOfFrames,
	230	&frameBuffer, &frameBufferSize))
	231	return NULL;
[2]	232
[391]	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;
[2]	238
[391]	239	data = PyString_FromStringAndSize(NULL, size);
	240	if (data == NULL)
	241	return NULL;
[2]	242
[391]	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	}
[2]	253
[391]	254	if (compressedBufferSize < size)
	255	if (_PyString_Resize(&data, compressedBufferSize))
	256	return NULL;
[2]	257
[391]	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	}
[2]	265
[391]	266	return data;
[2]	267	}
	268
	269	static PyObject *
	270	clm_Decompress(PyObject self, PyObject args)
	271	{
[391]	272	PyObject *data;
	273	int numberOfFrames;
	274	char *compressedData;
	275	int compressedDataSize, dataSize;
[2]	276
[391]	277	CheckCompressor(SELF);
[2]	278
[391]	279	if (!PyArg_Parse(args, "(is#)", &numberOfFrames, &compressedData,
	280	&compressedDataSize))
	281	return NULL;
[2]	282
[391]	283	error_handler_called = 0;
	284	dataSize = clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE);
	285	if (error_handler_called)
	286	return NULL;
[2]	287
[391]	288	data = PyString_FromStringAndSize(NULL, dataSize);
	289	if (data == NULL)
	290	return NULL;
[2]	291
[391]	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	}
[2]	302
[391]	303	return data;
[2]	304	}
	305
	306	static PyObject *
	307	doParams(clobject self, PyObject args, int (func)(CL_Handle, int , int),
[391]	308	int modified)
[2]	309	{
[391]	310	PyObject list, v;
	311	int *PVbuffer;
	312	int length;
	313	int i;
	314	float number;
[2]	315
[391]	316	CheckCompressor(self);
[2]	317
[391]	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	}
[2]	346
[391]	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	}
[2]	353
[391]	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	}
[2]	365
[391]	366	PyMem_DEL(PVbuffer);
	367
	368	Py_INCREF(Py_None);
	369	return Py_None;
[2]	370	}
	371
	372	static PyObject *
	373	clm_GetParams(PyObject self, PyObject args)
	374	{
[391]	375	return doParams(SELF, args, clGetParams, 1);
[2]	376	}
	377
	378	static PyObject *
	379	clm_SetParams(PyObject self, PyObject args)
	380	{
[391]	381	return doParams(SELF, args, clSetParams, 0);
[2]	382	}
	383
	384	static PyObject *
	385	do_get(clobject self, PyObject args, int (*func)(CL_Handle, int))
	386	{
[391]	387	int paramID, value;
	388	float fvalue;
[2]	389
[391]	390	CheckCompressor(self);
[2]	391
[391]	392	if (!PyArg_Parse(args, "i", &paramID))
	393	return NULL;
[2]	394
[391]	395	error_handler_called = 0;
	396	value = (*func)(self->ob_compressorHdl, paramID);
	397	if (error_handler_called)
	398	return NULL;
[2]	399
[391]	400	if (param_type_is_float(self, paramID) > 0) {
	401	fvalue = CL_TypeIsFloat(value);
	402	return PyFloat_FromDouble(fvalue);
	403	}
[2]	404
[391]	405	return PyInt_FromLong(value);
[2]	406	}
	407
	408	static PyObject *
	409	clm_GetParam(PyObject self, PyObject args)
	410	{
[391]	411	return do_get(SELF, args, clGetParam);
[2]	412	}
	413
	414	static PyObject *
	415	clm_GetDefault(PyObject self, PyObject args)
	416	{
[391]	417	return do_get(SELF, args, clGetDefault);
[2]	418	}
	419
	420	static PyObject *
	421	clm_SetParam(PyObject self, PyObject args)
	422	{
[391]	423	int paramID, value;
	424	float fvalue;
[2]	425
[391]	426	CheckCompressor(SELF);
[2]	427
[391]	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	}
[2]	443
[391]	444	error_handler_called = 0;
	445	value = clSetParam(SELF->ob_compressorHdl, paramID, value);
	446	if (error_handler_called)
	447	return NULL;
[2]	448
[391]	449	if (param_type_is_float(SELF, paramID) > 0)
	450	return PyFloat_FromDouble(CL_TypeIsFloat(value));
	451	else
	452	return PyInt_FromLong(value);
[2]	453	}
	454
	455	static PyObject *
	456	clm_GetParamID(PyObject self, PyObject args)
	457	{
[391]	458	char *name;
	459	int value;
[2]	460
[391]	461	CheckCompressor(SELF);
[2]	462
[391]	463	if (!PyArg_Parse(args, "s", &name))
	464	return NULL;
[2]	465
[391]	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	}
[2]	473
[391]	474	return PyInt_FromLong(value);
[2]	475	}
	476
	477	static PyObject *
	478	clm_QueryParams(PyObject *self)
	479	{
[391]	480	int bufferlength;
	481	int *PVbuffer;
	482	PyObject *list;
	483	int i;
[2]	484
[391]	485	CheckCompressor(SELF);
[2]	486
[391]	487	error_handler_called = 0;
	488	bufferlength = clQueryParams(SELF->ob_compressorHdl, 0, 0);
	489	if (error_handler_called)
	490	return NULL;
[2]	491
[391]	492	PVbuffer = PyMem_NEW(int, bufferlength);
	493	if (PVbuffer == NULL)
	494	return PyErr_NoMemory();
[2]	495
[391]	496	bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer,
	497	bufferlength);
	498	if (error_handler_called) {
	499	PyMem_DEL(PVbuffer);
	500	return NULL;
	501	}
[2]	502
[391]	503	list = PyList_New(bufferlength);
	504	if (list == NULL) {
	505	PyMem_DEL(PVbuffer);
	506	return NULL;
	507	}
[2]	508
[391]	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	}
[2]	519
[391]	520	PyMem_DEL(PVbuffer);
[2]	521
[391]	522	return list;
[2]	523	}
	524
	525	static PyObject *
	526	clm_GetMinMax(PyObject self, PyObject args)
	527	{
[391]	528	int param, min, max;
	529	float fmin, fmax;
[2]	530
[391]	531	CheckCompressor(SELF);
[2]	532
[391]	533	if (!PyArg_Parse(args, "i", &param))
	534	return NULL;
[2]	535
[391]	536	clGetMinMax(SELF->ob_compressorHdl, param, &min, &max);
[2]	537
[391]	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	}
[2]	543
[391]	544	return Py_BuildValue("(ii)", min, max);
[2]	545	}
	546
	547	static PyObject *
	548	clm_GetName(PyObject self, PyObject args)
	549	{
[391]	550	int param;
	551	char *name;
[2]	552
[391]	553	CheckCompressor(SELF);
[2]	554
[391]	555	if (!PyArg_Parse(args, "i", &param))
	556	return NULL;
[2]	557
[391]	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	}
[2]	565
[391]	566	return PyString_FromString(name);
[2]	567	}
	568
	569	static PyObject *
	570	clm_QuerySchemeFromHandle(PyObject *self)
	571	{
[391]	572	CheckCompressor(SELF);
	573	return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
[2]	574	}
	575
	576	static PyObject *
	577	clm_ReadHeader(PyObject self, PyObject args)
	578	{
[391]	579	char *header;
	580	int headerSize;
[2]	581
[391]	582	CheckCompressor(SELF);
[2]	583
[391]	584	if (!PyArg_Parse(args, "s#", &header, &headerSize))
	585	return NULL;
[2]	586
[391]	587	return PyInt_FromLong(clReadHeader(SELF->ob_compressorHdl,
	588	headerSize, header));
[2]	589	}
	590
	591	static PyMethodDef compressor_methods[] = {
[391]	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 */
[2]	606	};
	607
	608	static PyMethodDef decompressor_methods[] = {
[391]	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 */
[2]	624	};
	625
	626	static void
	627	cl_dealloc(PyObject *self)
	628	{
[391]	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);
[2]	636	}
	637
	638	static PyObject *
	639	cl_getattr(PyObject self, char name)
	640	{
[391]	641	if (SELF->ob_isCompressor)
	642	return Py_FindMethod(compressor_methods, self, name);
	643	else
	644	return Py_FindMethod(decompressor_methods, self, name);
[2]	645	}
	646
	647	static PyTypeObject Cltype = {
[391]	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/
[2]	663	};
	664
	665	static PyObject *
	666	doOpen(PyObject self, PyObject args, int (open_func)(int, CL_Handle ),
	667	int iscompressor)
	668	{
[391]	669	int scheme;
	670	clobject *new;
[2]	671
[391]	672	if (!PyArg_ParseTuple(args, "i", &scheme))
	673	return NULL;
[2]	674
[391]	675	new = PyObject_New(clobject, &Cltype);
	676	if (new == NULL)
	677	return NULL;
[2]	678
[391]	679	new->ob_compressorHdl = NULL;
	680	new->ob_isCompressor = iscompressor;
	681	new->ob_paramtypes = NULL;
[2]	682
[391]	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;
[2]	692	}
	693
	694	static PyObject *
	695	cl_OpenCompressor(PyObject self, PyObject args)
	696	{
[391]	697	return doOpen(self, args, clOpenCompressor, 1);
[2]	698	}
	699
	700	static PyObject *
	701	cl_OpenDecompressor(PyObject self, PyObject args)
	702	{
[391]	703	return doOpen(self, args, clOpenDecompressor, 0);
[2]	704	}
	705
	706	static PyObject *
	707	cl_QueryScheme(PyObject self, PyObject args)
	708	{
[391]	709	char *header;
	710	int headerlen;
	711	int scheme;
[2]	712
[391]	713	if (!PyArg_ParseTuple(args, "s#", &header, &headerlen))
	714	return NULL;
[2]	715
[391]	716	scheme = clQueryScheme(header);
	717	if (scheme < 0) {
	718	PyErr_SetString(ClError, "unknown compression scheme");
	719	return NULL;
	720	}
[2]	721
[391]	722	return PyInt_FromLong(scheme);
[2]	723	}
	724
	725	static PyObject *
	726	cl_QueryMaxHeaderSize(PyObject self, PyObject args)
	727	{
[391]	728	int scheme;
[2]	729
[391]	730	if (!PyArg_ParseTuple(args, "i", &scheme))
	731	return NULL;
[2]	732
[391]	733	return PyInt_FromLong(clQueryMaxHeaderSize(scheme));
[2]	734	}
	735
	736	static PyObject *
	737	cl_QueryAlgorithms(PyObject self, PyObject args)
	738	{
[391]	739	int algorithmMediaType;
	740	int bufferlength;
	741	int *PVbuffer;
	742	PyObject *list;
	743	int i;
[2]	744
[391]	745	if (!PyArg_ParseTuple(args, "i", &algorithmMediaType))
	746	return NULL;
[2]	747
[391]	748	error_handler_called = 0;
	749	bufferlength = clQueryAlgorithms(algorithmMediaType, 0, 0);
	750	if (error_handler_called)
	751	return NULL;
[2]	752
[391]	753	PVbuffer = PyMem_NEW(int, bufferlength);
	754	if (PVbuffer == NULL)
	755	return PyErr_NoMemory();
[2]	756
[391]	757	bufferlength = clQueryAlgorithms(algorithmMediaType, PVbuffer,
	758	bufferlength);
	759	if (error_handler_called) {
	760	PyMem_DEL(PVbuffer);
	761	return NULL;
	762	}
[2]	763
[391]	764	list = PyList_New(bufferlength);
	765	if (list == NULL) {
	766	PyMem_DEL(PVbuffer);
	767	return NULL;
	768	}
[2]	769
[391]	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	}
[2]	780
[391]	781	PyMem_DEL(PVbuffer);
[2]	782
[391]	783	return list;
[2]	784	}
	785
	786	static PyObject *
	787	cl_QuerySchemeFromName(PyObject self, PyObject args)
	788	{
[391]	789	int algorithmMediaType;
	790	char *name;
	791	int scheme;
[2]	792
[391]	793	if (!PyArg_ParseTuple(args, "is", &algorithmMediaType, &name))
	794	return NULL;
[2]	795
[391]	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	}
[2]	802
[391]	803	return PyInt_FromLong(scheme);
[2]	804	}
	805
	806	static PyObject *
	807	cl_GetAlgorithmName(PyObject self, PyObject args)
	808	{
[391]	809	int scheme;
	810	char *name;
[2]	811
[391]	812	if (!PyArg_ParseTuple(args, "i", &scheme))
	813	return NULL;
[2]	814
[391]	815	name = clGetAlgorithmName(scheme);
	816	if (name == 0) {
	817	PyErr_SetString(ClError, "unknown compression scheme");
	818	return NULL;
	819	}
[2]	820
[391]	821	return PyString_FromString(name);
[2]	822	}
	823
	824	static PyObject *
	825	do_set(PyObject self, PyObject args, int (*func)(int, int, int))
	826	{
[391]	827	int scheme, paramID, value;
	828	float fvalue;
	829	int is_float = 0;
[2]	830
[391]	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	}
[2]	852
[391]	853	error_handler_called = 0;
	854	value = (*func)(scheme, paramID, value);
	855	if (error_handler_called)
	856	return NULL;
[2]	857
[391]	858	if (is_float)
	859	return PyFloat_FromDouble(CL_TypeIsFloat(value));
	860	else
	861	return PyInt_FromLong(value);
[2]	862	}
	863
	864	static PyObject *
	865	cl_SetDefault(PyObject self, PyObject args)
	866	{
[391]	867	return do_set(self, args, clSetDefault);
[2]	868	}
	869
	870	static PyObject *
	871	cl_SetMin(PyObject self, PyObject args)
	872	{
[391]	873	return do_set(self, args, clSetMin);
[2]	874	}
	875
	876	static PyObject *
	877	cl_SetMax(PyObject self, PyObject args)
	878	{
[391]	879	return do_set(self, args, clSetMax);
[2]	880	}
	881
[391]	882	#define func(name, handler) \
[2]	883	static PyObject cl_##name(PyObject self, PyObject *args) \
	884	{ \
[391]	885	int x; \
	886	if (!PyArg_ParseTuple(args, "i", &x)) return NULL; \
	887	return Py##handler(CL_##name(x)); \
[2]	888	}
	889
[391]	890	#define func2(name, handler) \
[2]	891	static PyObject cl_##name(PyObject self, PyObject *args) \
	892	{ \
[391]	893	int a1, a2; \
	894	if (!PyArg_ParseTuple(args, "ii", &a1, &a2)) return NULL; \
	895	return Py##handler(CL_##name(a1, a2)); \
[2]	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
[391]	910	static PyObject *
[2]	911	cvt_type(PyObject self, PyObject args)
	912	{
[391]	913	int number;
	914	float fnumber;
[2]	915
[391]	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	}
[2]	924	}
	925	#endif
	926
	927	static PyMethodDef cl_methods[] = {
[391]	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},
[2]	950	#ifdef CLDEBUG
[391]	951	{"cvt_type", cvt_type, METH_VARARGS},
[2]	952	#endif
[391]	953	{NULL, NULL} /* Sentinel */
[2]	954	};
	955
	956	#ifdef CL_JPEG_SOFTWARE
	957	#define IRIX_5_3_LIBRARY
	958	#endif
	959
	960	void
	961	initcl(void)
	962	{
[391]	963	PyObject m, d, *x;
	964
[2]	965	if (PyErr_WarnPy3k("the cl module has been removed in "
	966	"Python 3.0", 2) < 0)
[391]	967	return;
	968
	969	m = Py_InitModule("cl", cl_methods);
	970	if (m == NULL)
[2]	971	return;
[391]	972	d = PyModule_GetDict(m);
[2]	973
[391]	974	ClError = PyErr_NewException("cl.error", NULL, NULL);
	975	(void) PyDict_SetItemString(d, "error", ClError);
[2]	976
	977	#ifdef CL_ADDED_ALGORITHM_ERROR
[391]	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);
[2]	982	#endif
	983	#ifdef CL_ALAW
[391]	984	x = PyInt_FromLong(CL_ALAW);
	985	if (x == NULL \|\| PyDict_SetItemString(d, "ALAW", x) < 0)
	986	return;
	987	Py_DECREF(x);
[2]	988	#endif
	989	#ifdef CL_ALGORITHM_ID
[391]	990	x = PyInt_FromLong(CL_ALGORITHM_ID);
	991	if (x == NULL \|\| PyDict_SetItemString(d, "ALGORITHM_ID", x) < 0)
	992	return;
	993	Py_DECREF(x);
[2]	994	#endif
	995	#ifdef CL_ALGORITHM_TABLE_FULL
[391]	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);
[2]	1000	#endif
	1001	#ifdef CL_ALGORITHM_VERSION
[391]	1002	x = PyInt_FromLong(CL_ALGORITHM_VERSION);
	1003	if (x == NULL \|\| PyDict_SetItemString(d, "ALGORITHM_VERSION", x) < 0)
	1004	return;
	1005	Py_DECREF(x);
[2]	1006	#endif
	1007	#ifdef CL_ALG_AUDIO
[391]	1008	x = PyInt_FromLong(CL_ALG_AUDIO);
	1009	if (x == NULL \|\| PyDict_SetItemString(d, "ALG_AUDIO", x) < 0)
	1010	return;
	1011	Py_DECREF(x);
[2]	1012	#endif
	1013	#ifdef CL_ALG_VIDEO
[391]	1014	x = PyInt_FromLong(CL_ALG_VIDEO);
	1015	if (x == NULL \|\| PyDict_SetItemString(d, "ALG_VIDEO", x) < 0)
	1016	return;
	1017	Py_DECREF(x);
[2]	1018	#endif
	1019	#ifdef CL_AUDIO
[391]	1020	x = PyInt_FromLong(CL_AUDIO);
	1021	if (x == NULL \|\| PyDict_SetItemString(d, "AUDIO", x) < 0)
	1022	return;
	1023	Py_DECREF(x);
[2]	1024	#endif
	1025	#ifdef CL_AWARE_BITRATE_POLICY
[391]	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);
[2]	1030	#endif
	1031	#ifdef CL_AWARE_BITRATE_TARGET
[391]	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);
[2]	1036	#endif
	1037	#ifdef CL_AWARE_CHANNEL_POLICY
[391]	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);
[2]	1042	#endif
	1043	#ifdef CL_AWARE_CONST_QUAL
[391]	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);
[2]	1048	#endif
	1049	#ifdef CL_AWARE_ERROR
[391]	1050	x = PyInt_FromLong(CL_AWARE_ERROR);
	1051	if (x == NULL \|\| PyDict_SetItemString(d, "AWARE_ERROR", x) < 0)
	1052	return;
	1053	Py_DECREF(x);
[2]	1054	#endif
	1055	#ifdef CL_AWARE_FIXED_RATE
[391]	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);
[2]	1060	#endif
	1061	#ifdef CL_AWARE_INDEPENDENT
[391]	1062	x = PyInt_FromLong(CL_AWARE_INDEPENDENT);
	1063	if (x == NULL \|\| PyDict_SetItemString(d, "AWARE_INDEPENDENT", x) < 0)
	1064	return;
	1065	Py_DECREF(x);
[2]	1066	#endif
	1067	#ifdef CL_AWARE_JOINT_STEREO
[391]	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);
[2]	1072	#endif
	1073	#ifdef CL_AWARE_LAYER
[391]	1074	x = PyInt_FromLong(CL_AWARE_LAYER);
	1075	if (x == NULL \|\| PyDict_SetItemString(d, "AWARE_LAYER", x) < 0)
	1076	return;
	1077	Py_DECREF(x);
[2]	1078	#endif
	1079	#ifdef CL_AWARE_LOSSLESS
[391]	1080	x = PyInt_FromLong(CL_AWARE_LOSSLESS);
	1081	if (x == NULL \|\| PyDict_SetItemString(d, "AWARE_LOSSLESS", x) < 0)
	1082	return;
	1083	Py_DECREF(x);
[2]	1084	#endif
	1085	#ifdef CL_AWARE_MPEG_AUDIO
[391]	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);
[2]	1090	#endif
	1091	#ifdef CL_AWARE_MPEG_LAYER_I
[391]	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);
[2]	1096	#endif
	1097	#ifdef CL_AWARE_MPEG_LAYER_II
[391]	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);
[2]	1102	#endif
	1103	#ifdef CL_AWARE_MULTIRATE
[391]	1104	x = PyInt_FromLong(CL_AWARE_MULTIRATE);
	1105	if (x == NULL \|\| PyDict_SetItemString(d, "AWARE_MULTIRATE", x) < 0)
	1106	return;
	1107	Py_DECREF(x);
[2]	1108	#endif
	1109	#ifdef CL_AWARE_NOISE_MARGIN
[391]	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);
[2]	1114	#endif
	1115	#ifdef CL_AWARE_STEREO
[391]	1116	x = PyInt_FromLong(CL_AWARE_STEREO);
	1117	if (x == NULL \|\| PyDict_SetItemString(d, "AWARE_STEREO", x) < 0)
	1118	return;
	1119	Py_DECREF(x);
[2]	1120	#endif
	1121	#ifdef CL_BAD_ALGORITHM_NAME
[391]	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);
[2]	1126	#endif
	1127	#ifdef CL_BAD_ALGORITHM_TYPE
[391]	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);
[2]	1132	#endif
	1133	#ifdef CL_BAD_BLOCK_SIZE
[391]	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);
[2]	1138	#endif
	1139	#ifdef CL_BAD_BOARD
[391]	1140	x = PyInt_FromLong(CL_BAD_BOARD);
	1141	if (x == NULL \|\| PyDict_SetItemString(d, "BAD_BOARD", x) < 0)
	1142	return;
	1143	Py_DECREF(x);
[2]	1144	#endif
	1145	#ifdef CL_BAD_BUFFERING
[391]	1146	x = PyInt_FromLong(CL_BAD_BUFFERING);
	1147	if (x == NULL \|\| PyDict_SetItemString(d, "BAD_BUFFERING", x) < 0)
	1148	return;
	1149	Py_DECREF(x);
[2]	1150	#endif
	1151	#ifdef CL_BAD_BUFFERLENGTH_NEG
[391]	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);
[2]	1156	#endif
	1157	#ifdef CL_BAD_BUFFERLENGTH_ODD
[391]	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);
[2]	1162	#endif
	1163	#ifdef CL_BAD_BUFFER_EXISTS
[391]	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);
[2]	1168	#endif
	1169	#ifdef CL_BAD_BUFFER_HANDLE
[391]	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);
[2]	1174	#endif
	1175	#ifdef CL_BAD_BUFFER_POINTER
[391]	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);
[2]	1180	#endif
	1181	#ifdef CL_BAD_BUFFER_QUERY_SIZE
[391]	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);
[2]	1186	#endif
	1187	#ifdef CL_BAD_BUFFER_SIZE
[391]	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);
[2]	1192	#endif
	1193	#ifdef CL_BAD_BUFFER_SIZE_POINTER
[391]	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);
[2]	1198	#endif
	1199	#ifdef CL_BAD_BUFFER_TYPE
[391]	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);
[2]	1204	#endif
	1205	#ifdef CL_BAD_COMPRESSION_SCHEME
[391]	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);
[2]	1210	#endif
	1211	#ifdef CL_BAD_COMPRESSOR_HANDLE
[391]	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);
[2]	1216	#endif
	1217	#ifdef CL_BAD_COMPRESSOR_HANDLE_POINTER
[391]	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);
[2]	1222	#endif
	1223	#ifdef CL_BAD_FRAME_SIZE
[391]	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);
[2]	1228	#endif
	1229	#ifdef CL_BAD_FUNCTIONALITY
[391]	1230	x = PyInt_FromLong(CL_BAD_FUNCTIONALITY);
	1231	if (x == NULL \|\| PyDict_SetItemString(d, "BAD_FUNCTIONALITY", x) < 0)
	1232	return;
	1233	Py_DECREF(x);
[2]	1234	#endif
	1235	#ifdef CL_BAD_FUNCTION_POINTER
[391]	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);
[2]	1240	#endif
	1241	#ifdef CL_BAD_HEADER_SIZE
[391]	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);
[2]	1246	#endif
	1247	#ifdef CL_BAD_INITIAL_VALUE
[391]	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);
[2]	1252	#endif
	1253	#ifdef CL_BAD_INTERNAL_FORMAT
[391]	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);
[2]	1258	#endif
	1259	#ifdef CL_BAD_LICENSE
[391]	1260	x = PyInt_FromLong(CL_BAD_LICENSE);
	1261	if (x == NULL \|\| PyDict_SetItemString(d, "BAD_LICENSE", x) < 0)
	1262	return;
	1263	Py_DECREF(x);
[2]	1264	#endif
	1265	#ifdef CL_BAD_MIN_GT_MAX
[391]	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);
[2]	1270	#endif
	1271	#ifdef CL_BAD_NO_BUFFERSPACE
[391]	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);
[2]	1276	#endif
	1277	#ifdef CL_BAD_NUMBER_OF_BLOCKS
[391]	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);
[2]	1282	#endif
	1283	#ifdef CL_BAD_PARAM
[391]	1284	x = PyInt_FromLong(CL_BAD_PARAM);
	1285	if (x == NULL \|\| PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
	1286	return;
	1287	Py_DECREF(x);
[2]	1288	#endif
	1289	#ifdef CL_BAD_PARAM_ID_POINTER
[391]	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);
[2]	1294	#endif
	1295	#ifdef CL_BAD_PARAM_TYPE
[391]	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);
[2]	1300	#endif
	1301	#ifdef CL_BAD_POINTER
[391]	1302	x = PyInt_FromLong(CL_BAD_POINTER);
	1303	if (x == NULL \|\| PyDict_SetItemString(d, "BAD_POINTER", x) < 0)
	1304	return;
	1305	Py_DECREF(x);
[2]	1306	#endif
	1307	#ifdef CL_BAD_PVBUFFER
[391]	1308	x = PyInt_FromLong(CL_BAD_PVBUFFER);
	1309	if (x == NULL \|\| PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
	1310	return;
	1311	Py_DECREF(x);
[2]	1312	#endif
	1313	#ifdef CL_BAD_SCHEME_POINTER
[391]	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);
[2]	1318	#endif
	1319	#ifdef CL_BAD_STREAM_HEADER
[391]	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);
[2]	1324	#endif
	1325	#ifdef CL_BAD_STRING_POINTER
[391]	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);
[2]	1330	#endif
	1331	#ifdef CL_BAD_TEXT_STRING_PTR
[391]	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);
[2]	1336	#endif
	1337	#ifdef CL_BEST_FIT
[391]	1338	x = PyInt_FromLong(CL_BEST_FIT);
	1339	if (x == NULL \|\| PyDict_SetItemString(d, "BEST_FIT", x) < 0)
	1340	return;
	1341	Py_DECREF(x);
[2]	1342	#endif
	1343	#ifdef CL_BIDIRECTIONAL
[391]	1344	x = PyInt_FromLong(CL_BIDIRECTIONAL);
	1345	if (x == NULL \|\| PyDict_SetItemString(d, "BIDIRECTIONAL", x) < 0)
	1346	return;
	1347	Py_DECREF(x);
[2]	1348	#endif
	1349	#ifdef CL_BITRATE
[391]	1350	x = PyInt_FromLong(CL_BITRATE);
	1351	if (x == NULL \|\| PyDict_SetItemString(d, "BITRATE", x) < 0)
	1352	return;
	1353	Py_DECREF(x);
[2]	1354	#endif
	1355	#ifdef CL_BITRATE_POLICY
[391]	1356	x = PyInt_FromLong(CL_BITRATE_POLICY);
	1357	if (x == NULL \|\| PyDict_SetItemString(d, "BITRATE_POLICY", x) < 0)
	1358	return;
	1359	Py_DECREF(x);
[2]	1360	#endif
	1361	#ifdef CL_BITRATE_TARGET
[391]	1362	x = PyInt_FromLong(CL_BITRATE_TARGET);
	1363	if (x == NULL \|\| PyDict_SetItemString(d, "BITRATE_TARGET", x) < 0)
	1364	return;
	1365	Py_DECREF(x);
[2]	1366	#endif
	1367	#ifdef CL_BITS_PER_COMPONENT
[391]	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);
[2]	1372	#endif
	1373	#ifdef CL_BLENDING
[391]	1374	x = PyInt_FromLong(CL_BLENDING);
	1375	if (x == NULL \|\| PyDict_SetItemString(d, "BLENDING", x) < 0)
	1376	return;
	1377	Py_DECREF(x);
[2]	1378	#endif
	1379	#ifdef CL_BLOCK_SIZE
[391]	1380	x = PyInt_FromLong(CL_BLOCK_SIZE);
	1381	if (x == NULL \|\| PyDict_SetItemString(d, "BLOCK_SIZE", x) < 0)
	1382	return;
	1383	Py_DECREF(x);
[2]	1384	#endif
	1385	#ifdef CL_BOTTOM_UP
[391]	1386	x = PyInt_FromLong(CL_BOTTOM_UP);
	1387	if (x == NULL \|\| PyDict_SetItemString(d, "BOTTOM_UP", x) < 0)
	1388	return;
	1389	Py_DECREF(x);
[2]	1390	#endif
	1391	#ifdef CL_BUFFER_NOT_CREATED
[391]	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);
[2]	1396	#endif
	1397	#ifdef CL_BUF_COMPRESSED
[391]	1398	x = PyInt_FromLong(CL_BUF_COMPRESSED);
	1399	if (x == NULL \|\| PyDict_SetItemString(d, "BUF_COMPRESSED", x) < 0)
	1400	return;
	1401	Py_DECREF(x);
[2]	1402	#endif
	1403	#ifdef CL_BUF_DATA
[391]	1404	x = PyInt_FromLong(CL_BUF_DATA);
	1405	if (x == NULL \|\| PyDict_SetItemString(d, "BUF_DATA", x) < 0)
	1406	return;
	1407	Py_DECREF(x);
[2]	1408	#endif
	1409	#ifdef CL_BUF_FRAME
[391]	1410	x = PyInt_FromLong(CL_BUF_FRAME);
	1411	if (x == NULL \|\| PyDict_SetItemString(d, "BUF_FRAME", x) < 0)
	1412	return;
	1413	Py_DECREF(x);
[2]	1414	#endif
	1415	#ifdef CL_CHANNEL_POLICY
[391]	1416	x = PyInt_FromLong(CL_CHANNEL_POLICY);
	1417	if (x == NULL \|\| PyDict_SetItemString(d, "CHANNEL_POLICY", x) < 0)
	1418	return;
	1419	Py_DECREF(x);
[2]	1420	#endif
	1421	#ifdef CL_CHROMA_THRESHOLD
[391]	1422	x = PyInt_FromLong(CL_CHROMA_THRESHOLD);
	1423	if (x == NULL \|\| PyDict_SetItemString(d, "CHROMA_THRESHOLD", x) < 0)
	1424	return;
	1425	Py_DECREF(x);
[2]	1426	#endif
	1427	#ifdef CL_CODEC
[391]	1428	x = PyInt_FromLong(CL_CODEC);
	1429	if (x == NULL \|\| PyDict_SetItemString(d, "CODEC", x) < 0)
	1430	return;
	1431	Py_DECREF(x);
[2]	1432	#endif
	1433	#ifdef CL_COMPONENTS
[391]	1434	x = PyInt_FromLong(CL_COMPONENTS);
	1435	if (x == NULL \|\| PyDict_SetItemString(d, "COMPONENTS", x) < 0)
	1436	return;
	1437	Py_DECREF(x);
[2]	1438	#endif
	1439	#ifdef CL_COMPRESSED_BUFFER_SIZE
[391]	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);
[2]	1444	#endif
	1445	#ifdef CL_COMPRESSION_RATIO
[391]	1446	x = PyInt_FromLong(CL_COMPRESSION_RATIO);
	1447	if (x == NULL \|\| PyDict_SetItemString(d, "COMPRESSION_RATIO", x) < 0)
	1448	return;
	1449	Py_DECREF(x);
[2]	1450	#endif
	1451	#ifdef CL_COMPRESSOR
[391]	1452	x = PyInt_FromLong(CL_COMPRESSOR);
	1453	if (x == NULL \|\| PyDict_SetItemString(d, "COMPRESSOR", x) < 0)
	1454	return;
	1455	Py_DECREF(x);
[2]	1456	#endif
	1457	#ifdef CL_CONTINUOUS_BLOCK
[391]	1458	x = PyInt_FromLong(CL_CONTINUOUS_BLOCK);
	1459	if (x == NULL \|\| PyDict_SetItemString(d, "CONTINUOUS_BLOCK", x) < 0)
	1460	return;
	1461	Py_DECREF(x);
[2]	1462	#endif
	1463	#ifdef CL_CONTINUOUS_NONBLOCK
[391]	1464	x = PyInt_FromLong(CL_CONTINUOUS_NONBLOCK);
	1465	if (x == NULL \|\| PyDict_SetItemString(d, "CONTINUOUS_NONBLOCK", x) < 0)
	1466	return;
	1467	Py_DECREF(x);
[2]	1468	#endif
	1469	#ifdef CL_COSMO_CODEC_CONTROL
[391]	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);
[2]	1474	#endif
	1475	#ifdef CL_COSMO_NUM_PARAMS
[391]	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);
[2]	1480	#endif
	1481	#ifdef CL_COSMO_VALUE_BASE
[391]	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);
[2]	1486	#endif
	1487	#ifdef CL_COSMO_VIDEO_MANUAL_CONTROL
[391]	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);
[2]	1492	#endif
	1493	#ifdef CL_COSMO_VIDEO_TRANSFER_MODE
[391]	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);
[2]	1498	#endif
	1499	#ifdef CL_DATA
[391]	1500	x = PyInt_FromLong(CL_DATA);
	1501	if (x == NULL \|\| PyDict_SetItemString(d, "DATA", x) < 0)
	1502	return;
	1503	Py_DECREF(x);
[2]	1504	#endif
	1505	#ifdef CL_DECOMPRESSOR
[391]	1506	x = PyInt_FromLong(CL_DECOMPRESSOR);
	1507	if (x == NULL \|\| PyDict_SetItemString(d, "DECOMPRESSOR", x) < 0)
	1508	return;
	1509	Py_DECREF(x);
[2]	1510	#endif
	1511	#ifdef CL_DSO_ERROR
[391]	1512	x = PyInt_FromLong(CL_DSO_ERROR);
	1513	if (x == NULL \|\| PyDict_SetItemString(d, "DSO_ERROR", x) < 0)
	1514	return;
	1515	Py_DECREF(x);
[2]	1516	#endif
	1517	#ifdef CL_EDGE_THRESHOLD
[391]	1518	x = PyInt_FromLong(CL_EDGE_THRESHOLD);
	1519	if (x == NULL \|\| PyDict_SetItemString(d, "EDGE_THRESHOLD", x) < 0)
	1520	return;
	1521	Py_DECREF(x);
[2]	1522	#endif
	1523	#ifdef CL_ENABLE_IMAGEINFO
[391]	1524	x = PyInt_FromLong(CL_ENABLE_IMAGEINFO);
	1525	if (x == NULL \|\| PyDict_SetItemString(d, "ENABLE_IMAGEINFO", x) < 0)
	1526	return;
	1527	Py_DECREF(x);
[2]	1528	#endif
	1529	#ifdef CL_END_OF_SEQUENCE
[391]	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);
[2]	1534	#endif
	1535	#ifdef CL_ENUM_VALUE
[391]	1536	x = PyInt_FromLong(CL_ENUM_VALUE);
	1537	if (x == NULL \|\| PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
	1538	return;
	1539	Py_DECREF(x);
[2]	1540	#endif
	1541	#ifdef CL_EXACT_COMPRESSION_RATIO
[391]	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);
[2]	1546	#endif
	1547	#ifdef CL_EXTERNAL_DEVICE
[391]	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);
[2]	1552	#endif
	1553	#ifdef CL_FLOATING_ENUM_VALUE
[391]	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);
[2]	1558	#endif
	1559	#ifdef CL_FLOATING_RANGE_VALUE
[391]	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);
[2]	1564	#endif
	1565	#ifdef CL_FORMAT
[391]	1566	x = PyInt_FromLong(CL_FORMAT);
	1567	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT", x) < 0)
	1568	return;
	1569	Py_DECREF(x);
[2]	1570	#endif
	1571	#ifdef CL_FORMAT_ABGR
[391]	1572	x = PyInt_FromLong(CL_FORMAT_ABGR);
	1573	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_ABGR", x) < 0)
	1574	return;
	1575	Py_DECREF(x);
[2]	1576	#endif
	1577	#ifdef CL_FORMAT_BGR
[391]	1578	x = PyInt_FromLong(CL_FORMAT_BGR);
	1579	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_BGR", x) < 0)
	1580	return;
	1581	Py_DECREF(x);
[2]	1582	#endif
	1583	#ifdef CL_FORMAT_BGR233
[391]	1584	x = PyInt_FromLong(CL_FORMAT_BGR233);
	1585	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_BGR233", x) < 0)
	1586	return;
	1587	Py_DECREF(x);
[2]	1588	#endif
	1589	#ifdef CL_FORMAT_GRAYSCALE
[391]	1590	x = PyInt_FromLong(CL_FORMAT_GRAYSCALE);
	1591	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_GRAYSCALE", x) < 0)
	1592	return;
	1593	Py_DECREF(x);
[2]	1594	#endif
	1595	#ifdef CL_FORMAT_MONO
[391]	1596	x = PyInt_FromLong(CL_FORMAT_MONO);
	1597	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_MONO", x) < 0)
	1598	return;
	1599	Py_DECREF(x);
[2]	1600	#endif
	1601	#ifdef CL_FORMAT_RBG323
[391]	1602	x = PyInt_FromLong(CL_FORMAT_RBG323);
	1603	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_RBG323", x) < 0)
	1604	return;
	1605	Py_DECREF(x);
[2]	1606	#endif
	1607	#ifdef CL_FORMAT_STEREO_INTERLEAVED
[391]	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);
[2]	1612	#endif
	1613	#ifdef CL_FORMAT_XBGR
[391]	1614	x = PyInt_FromLong(CL_FORMAT_XBGR);
	1615	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_XBGR", x) < 0)
	1616	return;
	1617	Py_DECREF(x);
[2]	1618	#endif
	1619	#ifdef CL_FORMAT_YCbCr
[391]	1620	x = PyInt_FromLong(CL_FORMAT_YCbCr);
	1621	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_YCbCr", x) < 0)
	1622	return;
	1623	Py_DECREF(x);
[2]	1624	#endif
	1625	#ifdef CL_FORMAT_YCbCr422
[391]	1626	x = PyInt_FromLong(CL_FORMAT_YCbCr422);
	1627	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_YCbCr422", x) < 0)
	1628	return;
	1629	Py_DECREF(x);
[2]	1630	#endif
	1631	#ifdef CL_FORMAT_YCbCr422DC
[391]	1632	x = PyInt_FromLong(CL_FORMAT_YCbCr422DC);
	1633	if (x == NULL \|\| PyDict_SetItemString(d, "FORMAT_YCbCr422DC", x) < 0)
	1634	return;
	1635	Py_DECREF(x);
[2]	1636	#endif
	1637	#ifdef CL_FRAME
[391]	1638	x = PyInt_FromLong(CL_FRAME);
	1639	if (x == NULL \|\| PyDict_SetItemString(d, "FRAME", x) < 0)
	1640	return;
	1641	Py_DECREF(x);
[2]	1642	#endif
	1643	#ifdef CL_FRAMES_PER_CHUNK
[391]	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);
[2]	1648	#endif
	1649	#ifdef CL_FRAME_BUFFER_SIZE
[391]	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);
[2]	1654	#endif
	1655	#ifdef CL_FRAME_BUFFER_SIZE_ZERO
[391]	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);
[2]	1660	#endif
	1661	#ifdef CL_FRAME_INDEX
[391]	1662	x = PyInt_FromLong(CL_FRAME_INDEX);
	1663	if (x == NULL \|\| PyDict_SetItemString(d, "FRAME_INDEX", x) < 0)
	1664	return;
	1665	Py_DECREF(x);
[2]	1666	#endif
	1667	#ifdef CL_FRAME_RATE
[391]	1668	x = PyInt_FromLong(CL_FRAME_RATE);
	1669	if (x == NULL \|\| PyDict_SetItemString(d, "FRAME_RATE", x) < 0)
	1670	return;
	1671	Py_DECREF(x);
[2]	1672	#endif
	1673	#ifdef CL_FRAME_SIZE
[391]	1674	x = PyInt_FromLong(CL_FRAME_SIZE);
	1675	if (x == NULL \|\| PyDict_SetItemString(d, "FRAME_SIZE", x) < 0)
	1676	return;
	1677	Py_DECREF(x);
[2]	1678	#endif
	1679	#ifdef CL_FRAME_TYPE
[391]	1680	x = PyInt_FromLong(CL_FRAME_TYPE);
	1681	if (x == NULL \|\| PyDict_SetItemString(d, "FRAME_TYPE", x) < 0)
	1682	return;
	1683	Py_DECREF(x);
[2]	1684	#endif
	1685	#ifdef CL_G711_ALAW
[391]	1686	x = PyInt_FromLong(CL_G711_ALAW);
	1687	if (x == NULL \|\| PyDict_SetItemString(d, "G711_ALAW", x) < 0)
	1688	return;
	1689	Py_DECREF(x);
[2]	1690	#endif
	1691	#ifdef CL_G711_ALAW_SOFTWARE
[391]	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);
[2]	1696	#endif
	1697	#ifdef CL_G711_ULAW
[391]	1698	x = PyInt_FromLong(CL_G711_ULAW);
	1699	if (x == NULL \|\| PyDict_SetItemString(d, "G711_ULAW", x) < 0)
	1700	return;
	1701	Py_DECREF(x);
[2]	1702	#endif
	1703	#ifdef CL_G711_ULAW_SOFTWARE
[391]	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);
[2]	1708	#endif
	1709	#ifdef CL_GRAYSCALE
[391]	1710	x = PyInt_FromLong(CL_GRAYSCALE);
	1711	if (x == NULL \|\| PyDict_SetItemString(d, "GRAYSCALE", x) < 0)
	1712	return;
	1713	Py_DECREF(x);
[2]	1714	#endif
	1715	#ifdef CL_HDCC
[391]	1716	x = PyInt_FromLong(CL_HDCC);
	1717	if (x == NULL \|\| PyDict_SetItemString(d, "HDCC", x) < 0)
	1718	return;
	1719	Py_DECREF(x);
[2]	1720	#endif
	1721	#ifdef CL_HDCC_SAMPLES_PER_TILE
[391]	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);
[2]	1726	#endif
	1727	#ifdef CL_HDCC_SOFTWARE
[391]	1728	x = PyInt_FromLong(CL_HDCC_SOFTWARE);
	1729	if (x == NULL \|\| PyDict_SetItemString(d, "HDCC_SOFTWARE", x) < 0)
	1730	return;
	1731	Py_DECREF(x);
[2]	1732	#endif
	1733	#ifdef CL_HDCC_TILE_THRESHOLD
[391]	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);
[2]	1738	#endif
	1739	#ifdef CL_HEADER_START_CODE
[391]	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);
[2]	1744	#endif
	1745	#ifdef CL_IMAGEINFO_FIELDMASK
[391]	1746	x = PyInt_FromLong(CL_IMAGEINFO_FIELDMASK);
	1747	if (x == NULL \|\| PyDict_SetItemString(d, "IMAGEINFO_FIELDMASK", x) < 0)
	1748	return;
	1749	Py_DECREF(x);
[2]	1750	#endif
	1751	#ifdef CL_IMAGE_CROP_BOTTOM
[391]	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);
[2]	1756	#endif
	1757	#ifdef CL_IMAGE_CROP_LEFT
[391]	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);
[2]	1762	#endif
	1763	#ifdef CL_IMAGE_CROP_RIGHT
[391]	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);
[2]	1768	#endif
	1769	#ifdef CL_IMAGE_CROP_TOP
[391]	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);
[2]	1774	#endif
	1775	#ifdef CL_IMAGE_HEIGHT
[391]	1776	x = PyInt_FromLong(CL_IMAGE_HEIGHT);
	1777	if (x == NULL \|\| PyDict_SetItemString(d, "IMAGE_HEIGHT", x) < 0)
	1778	return;
	1779	Py_DECREF(x);
[2]	1780	#endif
	1781	#ifdef CL_IMAGE_WIDTH
[391]	1782	x = PyInt_FromLong(CL_IMAGE_WIDTH);
	1783	if (x == NULL \|\| PyDict_SetItemString(d, "IMAGE_WIDTH", x) < 0)
	1784	return;
	1785	Py_DECREF(x);
[2]	1786	#endif
	1787	#ifdef CL_IMPACT_CODEC_CONTROL
[391]	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);
[2]	1792	#endif
	1793	#ifdef CL_IMPACT_FRAME_INTERLEAVE
[391]	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);
[2]	1798	#endif
	1799	#ifdef CL_IMPACT_NUM_PARAMS
[391]	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);
[2]	1804	#endif
	1805	#ifdef CL_INTERNAL_FORMAT
[391]	1806	x = PyInt_FromLong(CL_INTERNAL_FORMAT);
	1807	if (x == NULL \|\| PyDict_SetItemString(d, "INTERNAL_FORMAT", x) < 0)
	1808	return;
	1809	Py_DECREF(x);
[2]	1810	#endif
	1811	#ifdef CL_INTERNAL_IMAGE_HEIGHT
[391]	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);
[2]	1816	#endif
	1817	#ifdef CL_INTERNAL_IMAGE_WIDTH
[391]	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);
[2]	1822	#endif
	1823	#ifdef CL_INTRA
[391]	1824	x = PyInt_FromLong(CL_INTRA);
	1825	if (x == NULL \|\| PyDict_SetItemString(d, "INTRA", x) < 0)
	1826	return;
	1827	Py_DECREF(x);
[2]	1828	#endif
	1829	#ifdef CL_JPEG
[391]	1830	x = PyInt_FromLong(CL_JPEG);
	1831	if (x == NULL \|\| PyDict_SetItemString(d, "JPEG", x) < 0)
	1832	return;
	1833	Py_DECREF(x);
[2]	1834	#endif
	1835	#ifdef CL_JPEG_COSMO
[391]	1836	x = PyInt_FromLong(CL_JPEG_COSMO);
	1837	if (x == NULL \|\| PyDict_SetItemString(d, "JPEG_COSMO", x) < 0)
	1838	return;
	1839	Py_DECREF(x);
[2]	1840	#endif
	1841	#ifdef CL_JPEG_ERROR
[391]	1842	x = PyInt_FromLong(CL_JPEG_ERROR);
	1843	if (x == NULL \|\| PyDict_SetItemString(d, "JPEG_ERROR", x) < 0)
	1844	return;
	1845	Py_DECREF(x);
[2]	1846	#endif
	1847	#ifdef CL_JPEG_IMPACT
[391]	1848	x = PyInt_FromLong(CL_JPEG_IMPACT);
	1849	if (x == NULL \|\| PyDict_SetItemString(d, "JPEG_IMPACT", x) < 0)
	1850	return;
	1851	Py_DECREF(x);
[2]	1852	#endif
	1853	#ifdef CL_JPEG_NUM_PARAMS
[391]	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);
[2]	1858	#endif
	1859	#ifdef CL_JPEG_QUALITY_FACTOR
[391]	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);
[2]	1864	#endif
	1865	#ifdef CL_JPEG_QUANTIZATION_TABLES
[391]	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);
[2]	1870	#endif
	1871	#ifdef CL_JPEG_SOFTWARE
[391]	1872	x = PyInt_FromLong(CL_JPEG_SOFTWARE);
	1873	if (x == NULL \|\| PyDict_SetItemString(d, "JPEG_SOFTWARE", x) < 0)
	1874	return;
	1875	Py_DECREF(x);
[2]	1876	#endif
	1877	#ifdef CL_JPEG_STREAM_HEADERS
[391]	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);
[2]	1882	#endif
	1883	#ifdef CL_KEYFRAME
[391]	1884	x = PyInt_FromLong(CL_KEYFRAME);
	1885	if (x == NULL \|\| PyDict_SetItemString(d, "KEYFRAME", x) < 0)
	1886	return;
	1887	Py_DECREF(x);
[2]	1888	#endif
	1889	#ifdef CL_KEYFRAME_DISTANCE
[391]	1890	x = PyInt_FromLong(CL_KEYFRAME_DISTANCE);
	1891	if (x == NULL \|\| PyDict_SetItemString(d, "KEYFRAME_DISTANCE", x) < 0)
	1892	return;
	1893	Py_DECREF(x);
[2]	1894	#endif
	1895	#ifdef CL_LAST_FRAME_INDEX
[391]	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);
[2]	1900	#endif
	1901	#ifdef CL_LAYER
[391]	1902	x = PyInt_FromLong(CL_LAYER);
	1903	if (x == NULL \|\| PyDict_SetItemString(d, "LAYER", x) < 0)
	1904	return;
	1905	Py_DECREF(x);
[2]	1906	#endif
	1907	#ifdef CL_LUMA_THRESHOLD
[391]	1908	x = PyInt_FromLong(CL_LUMA_THRESHOLD);
	1909	if (x == NULL \|\| PyDict_SetItemString(d, "LUMA_THRESHOLD", x) < 0)
	1910	return;
	1911	Py_DECREF(x);
[2]	1912	#endif
	1913	#ifdef CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS
[391]	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);
[2]	1918	#endif
	1919	#ifdef CL_MAX_NUMBER_OF_FORMATS
[391]	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);
[2]	1924	#endif
	1925	#ifdef CL_MAX_NUMBER_OF_ORIGINAL_FORMATS
[391]	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);
[2]	1930	#endif
	1931	#ifdef CL_MAX_NUMBER_OF_PARAMS
[391]	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);
[2]	1936	#endif
	1937	#ifdef CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS
[391]	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);
[2]	1942	#endif
	1943	#ifdef CL_MONO
[391]	1944	x = PyInt_FromLong(CL_MONO);
	1945	if (x == NULL \|\| PyDict_SetItemString(d, "MONO", x) < 0)
	1946	return;
	1947	Py_DECREF(x);
[2]	1948	#endif
	1949	#ifdef CL_MPEG1_AUDIO_AWARE
[391]	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);
[2]	1954	#endif
	1955	#ifdef CL_MPEG1_AUDIO_LAYER
[391]	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);
[2]	1960	#endif
	1961	#ifdef CL_MPEG1_AUDIO_LAYER_I
[391]	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);
[2]	1966	#endif
	1967	#ifdef CL_MPEG1_AUDIO_LAYER_II
[391]	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);
[2]	1972	#endif
	1973	#ifdef CL_MPEG1_AUDIO_MODE
[391]	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);
[2]	1978	#endif
	1979	#ifdef CL_MPEG1_AUDIO_MODE_DUAL
[391]	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);
[2]	1984	#endif
	1985	#ifdef CL_MPEG1_AUDIO_MODE_JOINT
[391]	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);
[2]	1990	#endif
	1991	#ifdef CL_MPEG1_AUDIO_MODE_SINGLE
[391]	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);
[2]	1996	#endif
	1997	#ifdef CL_MPEG1_AUDIO_MODE_STEREO
[391]	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);
[2]	2002	#endif
	2003	#ifdef CL_MPEG1_AUDIO_SOFTWARE
[391]	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);
[2]	2008	#endif
	2009	#ifdef CL_MPEG1_END_OF_STREAM
[391]	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);
[2]	2014	#endif
	2015	#ifdef CL_MPEG1_ERROR
[391]	2016	x = PyInt_FromLong(CL_MPEG1_ERROR);
	2017	if (x == NULL \|\| PyDict_SetItemString(d, "MPEG1_ERROR", x) < 0)
	2018	return;
	2019	Py_DECREF(x);
[2]	2020	#endif
	2021	#ifdef CL_MPEG1_NUM_PARAMS
[391]	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);
[2]	2026	#endif
	2027	#ifdef CL_MPEG1_VIDEO_M
[391]	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);
[2]	2032	#endif
	2033	#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X
[391]	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);
[2]	2038	#endif
	2039	#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y
[391]	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);
[2]	2044	#endif
	2045	#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X
[391]	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);
[2]	2050	#endif
	2051	#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y
[391]	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);
[2]	2056	#endif
	2057	#ifdef CL_MPEG1_VIDEO_N
[391]	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);
[2]	2062	#endif
	2063	#ifdef CL_MPEG1_VIDEO_SOFTNESS
[391]	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);
[2]	2068	#endif
	2069	#ifdef CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM
[391]	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);
[2]	2074	#endif
	2075	#ifdef CL_MPEG1_VIDEO_SOFTNESS_MEDIUM
[391]	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);
[2]	2080	#endif
	2081	#ifdef CL_MPEG1_VIDEO_SOFTNESS_NONE
[391]	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);
[2]	2086	#endif
	2087	#ifdef CL_MPEG1_VIDEO_SOFTWARE
[391]	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);
[2]	2092	#endif
	2093	#ifdef CL_MPEG_VIDEO
[391]	2094	x = PyInt_FromLong(CL_MPEG_VIDEO);
	2095	if (x == NULL \|\| PyDict_SetItemString(d, "MPEG_VIDEO", x) < 0)
	2096	return;
	2097	Py_DECREF(x);
[2]	2098	#endif
	2099	#ifdef CL_MULTIRATE_AWARE
[391]	2100	x = PyInt_FromLong(CL_MULTIRATE_AWARE);
	2101	if (x == NULL \|\| PyDict_SetItemString(d, "MULTIRATE_AWARE", x) < 0)
	2102	return;
	2103	Py_DECREF(x);
[2]	2104	#endif
	2105	#ifdef CL_MVC1
[391]	2106	x = PyInt_FromLong(CL_MVC1);
	2107	if (x == NULL \|\| PyDict_SetItemString(d, "MVC1", x) < 0)
	2108	return;
	2109	Py_DECREF(x);
[2]	2110	#endif
	2111	#ifdef CL_MVC1_SOFTWARE
[391]	2112	x = PyInt_FromLong(CL_MVC1_SOFTWARE);
	2113	if (x == NULL \|\| PyDict_SetItemString(d, "MVC1_SOFTWARE", x) < 0)
	2114	return;
	2115	Py_DECREF(x);
[2]	2116	#endif
	2117	#ifdef CL_MVC2
[391]	2118	x = PyInt_FromLong(CL_MVC2);
	2119	if (x == NULL \|\| PyDict_SetItemString(d, "MVC2", x) < 0)
	2120	return;
	2121	Py_DECREF(x);
[2]	2122	#endif
	2123	#ifdef CL_MVC2_BLENDING
[391]	2124	x = PyInt_FromLong(CL_MVC2_BLENDING);
	2125	if (x == NULL \|\| PyDict_SetItemString(d, "MVC2_BLENDING", x) < 0)
	2126	return;
	2127	Py_DECREF(x);
[2]	2128	#endif
	2129	#ifdef CL_MVC2_BLENDING_OFF
[391]	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);
[2]	2134	#endif
	2135	#ifdef CL_MVC2_BLENDING_ON
[391]	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);
[2]	2140	#endif
	2141	#ifdef CL_MVC2_CHROMA_THRESHOLD
[391]	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);
[2]	2146	#endif
	2147	#ifdef CL_MVC2_EDGE_THRESHOLD
[391]	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);
[2]	2152	#endif
	2153	#ifdef CL_MVC2_ERROR
[391]	2154	x = PyInt_FromLong(CL_MVC2_ERROR);
	2155	if (x == NULL \|\| PyDict_SetItemString(d, "MVC2_ERROR", x) < 0)
	2156	return;
	2157	Py_DECREF(x);
[2]	2158	#endif
	2159	#ifdef CL_MVC2_LUMA_THRESHOLD
[391]	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);
[2]	2164	#endif
	2165	#ifdef CL_MVC2_SOFTWARE
[391]	2166	x = PyInt_FromLong(CL_MVC2_SOFTWARE);
	2167	if (x == NULL \|\| PyDict_SetItemString(d, "MVC2_SOFTWARE", x) < 0)
	2168	return;
	2169	Py_DECREF(x);
[2]	2170	#endif
	2171	#ifdef CL_MVC3_QUALITY_LEVEL
[391]	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);
[2]	2176	#endif
	2177	#ifdef CL_MVC3_SOFTWARE
[391]	2178	x = PyInt_FromLong(CL_MVC3_SOFTWARE);
	2179	if (x == NULL \|\| PyDict_SetItemString(d, "MVC3_SOFTWARE", x) < 0)
	2180	return;
	2181	Py_DECREF(x);
[2]	2182	#endif
	2183	#ifdef CL_NEXT_NOT_AVAILABLE
[391]	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);
[2]	2188	#endif
	2189	#ifdef CL_NOISE_MARGIN
[391]	2190	x = PyInt_FromLong(CL_NOISE_MARGIN);
	2191	if (x == NULL \|\| PyDict_SetItemString(d, "NOISE_MARGIN", x) < 0)
	2192	return;
	2193	Py_DECREF(x);
[2]	2194	#endif
	2195	#ifdef CL_NONE
[391]	2196	x = PyInt_FromLong(CL_NONE);
	2197	if (x == NULL \|\| PyDict_SetItemString(d, "NONE", x) < 0)
	2198	return;
	2199	Py_DECREF(x);
[2]	2200	#endif
	2201	#ifdef CL_NUMBER_OF_FORMATS
[391]	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);
[2]	2206	#endif
	2207	#ifdef CL_NUMBER_OF_FRAMES
[391]	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);
[2]	2212	#endif
	2213	#ifdef CL_NUMBER_OF_PARAMS
[391]	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);
[2]	2218	#endif
	2219	#ifdef CL_NUMBER_OF_PARAMS_FREEZE
[391]	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);
[2]	2224	#endif
	2225	#ifdef CL_NUMBER_OF_VIDEO_FORMATS
[391]	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);
[2]	2230	#endif
	2231	#ifdef CL_ORIENTATION
[391]	2232	x = PyInt_FromLong(CL_ORIENTATION);
	2233	if (x == NULL \|\| PyDict_SetItemString(d, "ORIENTATION", x) < 0)
	2234	return;
	2235	Py_DECREF(x);
[2]	2236	#endif
	2237	#ifdef CL_ORIGINAL_FORMAT
[391]	2238	x = PyInt_FromLong(CL_ORIGINAL_FORMAT);
	2239	if (x == NULL \|\| PyDict_SetItemString(d, "ORIGINAL_FORMAT", x) < 0)
	2240	return;
	2241	Py_DECREF(x);
[2]	2242	#endif
	2243	#ifdef CL_PARAM_OUT_OF_RANGE
[391]	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);
[2]	2248	#endif
	2249	#ifdef CL_PIXEL_ASPECT
[391]	2250	x = PyInt_FromLong(CL_PIXEL_ASPECT);
	2251	if (x == NULL \|\| PyDict_SetItemString(d, "PIXEL_ASPECT", x) < 0)
	2252	return;
	2253	Py_DECREF(x);
[2]	2254	#endif
	2255	#ifdef CL_PREDICTED
[391]	2256	x = PyInt_FromLong(CL_PREDICTED);
	2257	if (x == NULL \|\| PyDict_SetItemString(d, "PREDICTED", x) < 0)
	2258	return;
	2259	Py_DECREF(x);
[2]	2260	#endif
	2261	#ifdef CL_PREROLL
[391]	2262	x = PyInt_FromLong(CL_PREROLL);
	2263	if (x == NULL \|\| PyDict_SetItemString(d, "PREROLL", x) < 0)
	2264	return;
	2265	Py_DECREF(x);
[2]	2266	#endif
	2267	#ifdef CL_QUALITY_FACTOR
[391]	2268	x = PyInt_FromLong(CL_QUALITY_FACTOR);
	2269	if (x == NULL \|\| PyDict_SetItemString(d, "QUALITY_FACTOR", x) < 0)
	2270	return;
	2271	Py_DECREF(x);
[2]	2272	#endif
	2273	#ifdef CL_QUALITY_LEVEL
[391]	2274	x = PyInt_FromLong(CL_QUALITY_LEVEL);
	2275	if (x == NULL \|\| PyDict_SetItemString(d, "QUALITY_LEVEL", x) < 0)
	2276	return;
	2277	Py_DECREF(x);
[2]	2278	#endif
	2279	#ifdef CL_QUALITY_SPATIAL
[391]	2280	x = PyInt_FromLong(CL_QUALITY_SPATIAL);
	2281	if (x == NULL \|\| PyDict_SetItemString(d, "QUALITY_SPATIAL", x) < 0)
	2282	return;
	2283	Py_DECREF(x);
[2]	2284	#endif
	2285	#ifdef CL_QUALITY_TEMPORAL
[391]	2286	x = PyInt_FromLong(CL_QUALITY_TEMPORAL);
	2287	if (x == NULL \|\| PyDict_SetItemString(d, "QUALITY_TEMPORAL", x) < 0)
	2288	return;
	2289	Py_DECREF(x);
[2]	2290	#endif
	2291	#ifdef CL_QUANTIZATION_TABLES
[391]	2292	x = PyInt_FromLong(CL_QUANTIZATION_TABLES);
	2293	if (x == NULL \|\| PyDict_SetItemString(d, "QUANTIZATION_TABLES", x) < 0)
	2294	return;
	2295	Py_DECREF(x);
[2]	2296	#endif
	2297	#ifdef CL_RANGE_VALUE
[391]	2298	x = PyInt_FromLong(CL_RANGE_VALUE);
	2299	if (x == NULL \|\| PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
	2300	return;
	2301	Py_DECREF(x);
[2]	2302	#endif
	2303	#ifdef CL_RGB
[391]	2304	x = PyInt_FromLong(CL_RGB);
	2305	if (x == NULL \|\| PyDict_SetItemString(d, "RGB", x) < 0)
	2306	return;
	2307	Py_DECREF(x);
[2]	2308	#endif
	2309	#ifdef CL_RGB332
[391]	2310	x = PyInt_FromLong(CL_RGB332);
	2311	if (x == NULL \|\| PyDict_SetItemString(d, "RGB332", x) < 0)
	2312	return;
	2313	Py_DECREF(x);
[2]	2314	#endif
	2315	#ifdef CL_RGB8
[391]	2316	x = PyInt_FromLong(CL_RGB8);
	2317	if (x == NULL \|\| PyDict_SetItemString(d, "RGB8", x) < 0)
	2318	return;
	2319	Py_DECREF(x);
[2]	2320	#endif
	2321	#ifdef CL_RGBA
[391]	2322	x = PyInt_FromLong(CL_RGBA);
	2323	if (x == NULL \|\| PyDict_SetItemString(d, "RGBA", x) < 0)
	2324	return;
	2325	Py_DECREF(x);
[2]	2326	#endif
	2327	#ifdef CL_RGBX
[391]	2328	x = PyInt_FromLong(CL_RGBX);
	2329	if (x == NULL \|\| PyDict_SetItemString(d, "RGBX", x) < 0)
	2330	return;
	2331	Py_DECREF(x);
[2]	2332	#endif
	2333	#ifdef CL_RLE
[391]	2334	x = PyInt_FromLong(CL_RLE);
	2335	if (x == NULL \|\| PyDict_SetItemString(d, "RLE", x) < 0)
	2336	return;
	2337	Py_DECREF(x);
[2]	2338	#endif
	2339	#ifdef CL_RLE24
[391]	2340	x = PyInt_FromLong(CL_RLE24);
	2341	if (x == NULL \|\| PyDict_SetItemString(d, "RLE24", x) < 0)
	2342	return;
	2343	Py_DECREF(x);
[2]	2344	#endif
	2345	#ifdef CL_RLE24_SOFTWARE
[391]	2346	x = PyInt_FromLong(CL_RLE24_SOFTWARE);
	2347	if (x == NULL \|\| PyDict_SetItemString(d, "RLE24_SOFTWARE", x) < 0)
	2348	return;
	2349	Py_DECREF(x);
[2]	2350	#endif
	2351	#ifdef CL_RLE_SOFTWARE
[391]	2352	x = PyInt_FromLong(CL_RLE_SOFTWARE);
	2353	if (x == NULL \|\| PyDict_SetItemString(d, "RLE_SOFTWARE", x) < 0)
	2354	return;
	2355	Py_DECREF(x);
[2]	2356	#endif
	2357	#ifdef CL_RTR
[391]	2358	x = PyInt_FromLong(CL_RTR);
	2359	if (x == NULL \|\| PyDict_SetItemString(d, "RTR", x) < 0)
	2360	return;
	2361	Py_DECREF(x);
[2]	2362	#endif
	2363	#ifdef CL_RTR1
[391]	2364	x = PyInt_FromLong(CL_RTR1);
	2365	if (x == NULL \|\| PyDict_SetItemString(d, "RTR1", x) < 0)
	2366	return;
	2367	Py_DECREF(x);
[2]	2368	#endif
	2369	#ifdef CL_RTR_QUALITY_LEVEL
[391]	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);
[2]	2374	#endif
	2375	#ifdef CL_SAMPLES_PER_TILE
[391]	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);
[2]	2380	#endif
	2381	#ifdef CL_SCHEME_BUSY
[391]	2382	x = PyInt_FromLong(CL_SCHEME_BUSY);
	2383	if (x == NULL \|\| PyDict_SetItemString(d, "SCHEME_BUSY", x) < 0)
	2384	return;
	2385	Py_DECREF(x);
[2]	2386	#endif
	2387	#ifdef CL_SCHEME_NOT_AVAILABLE
[391]	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);
[2]	2392	#endif
	2393	#ifdef CL_SPEED
[391]	2394	x = PyInt_FromLong(CL_SPEED);
	2395	if (x == NULL \|\| PyDict_SetItemString(d, "SPEED", x) < 0)
	2396	return;
	2397	Py_DECREF(x);
[2]	2398	#endif
	2399	#ifdef CL_STEREO_INTERLEAVED
[391]	2400	x = PyInt_FromLong(CL_STEREO_INTERLEAVED);
	2401	if (x == NULL \|\| PyDict_SetItemString(d, "STEREO_INTERLEAVED", x) < 0)
	2402	return;
	2403	Py_DECREF(x);
[2]	2404	#endif
	2405	#ifdef CL_STREAM_HEADERS
[391]	2406	x = PyInt_FromLong(CL_STREAM_HEADERS);
	2407	if (x == NULL \|\| PyDict_SetItemString(d, "STREAM_HEADERS", x) < 0)
	2408	return;
	2409	Py_DECREF(x);
[2]	2410	#endif
	2411	#ifdef CL_TILE_THRESHOLD
[391]	2412	x = PyInt_FromLong(CL_TILE_THRESHOLD);
	2413	if (x == NULL \|\| PyDict_SetItemString(d, "TILE_THRESHOLD", x) < 0)
	2414	return;
	2415	Py_DECREF(x);
[2]	2416	#endif
	2417	#ifdef CL_TOP_DOWN
[391]	2418	x = PyInt_FromLong(CL_TOP_DOWN);
	2419	if (x == NULL \|\| PyDict_SetItemString(d, "TOP_DOWN", x) < 0)
	2420	return;
	2421	Py_DECREF(x);
[2]	2422	#endif
	2423	#ifdef CL_ULAW
[391]	2424	x = PyInt_FromLong(CL_ULAW);
	2425	if (x == NULL \|\| PyDict_SetItemString(d, "ULAW", x) < 0)
	2426	return;
	2427	Py_DECREF(x);
[2]	2428	#endif
	2429	#ifdef CL_UNCOMPRESSED
[391]	2430	x = PyInt_FromLong(CL_UNCOMPRESSED);
	2431	if (x == NULL \|\| PyDict_SetItemString(d, "UNCOMPRESSED", x) < 0)
	2432	return;
	2433	Py_DECREF(x);
[2]	2434	#endif
	2435	#ifdef CL_UNCOMPRESSED_AUDIO
[391]	2436	x = PyInt_FromLong(CL_UNCOMPRESSED_AUDIO);
	2437	if (x == NULL \|\| PyDict_SetItemString(d, "UNCOMPRESSED_AUDIO", x) < 0)
	2438	return;
	2439	Py_DECREF(x);
[2]	2440	#endif
	2441	#ifdef CL_UNCOMPRESSED_VIDEO
[391]	2442	x = PyInt_FromLong(CL_UNCOMPRESSED_VIDEO);
	2443	if (x == NULL \|\| PyDict_SetItemString(d, "UNCOMPRESSED_VIDEO", x) < 0)
	2444	return;
	2445	Py_DECREF(x);
[2]	2446	#endif
	2447	#ifdef CL_UNKNOWN_SCHEME
[391]	2448	x = PyInt_FromLong(CL_UNKNOWN_SCHEME);
	2449	if (x == NULL \|\| PyDict_SetItemString(d, "UNKNOWN_SCHEME", x) < 0)
	2450	return;
	2451	Py_DECREF(x);
[2]	2452	#endif
	2453	#ifdef CL_VIDEO
[391]	2454	x = PyInt_FromLong(CL_VIDEO);
	2455	if (x == NULL \|\| PyDict_SetItemString(d, "VIDEO", x) < 0)
	2456	return;
	2457	Py_DECREF(x);
[2]	2458	#endif
	2459	#ifdef CL_Y
[391]	2460	x = PyInt_FromLong(CL_Y);
	2461	if (x == NULL \|\| PyDict_SetItemString(d, "Y", x) < 0)
	2462	return;
	2463	Py_DECREF(x);
[2]	2464	#endif
	2465	#ifdef CL_YCbCr
[391]	2466	x = PyInt_FromLong(CL_YCbCr);
	2467	if (x == NULL \|\| PyDict_SetItemString(d, "YCbCr", x) < 0)
	2468	return;
	2469	Py_DECREF(x);
[2]	2470	#endif
	2471	#ifdef CL_YCbCr422
[391]	2472	x = PyInt_FromLong(CL_YCbCr422);
	2473	if (x == NULL \|\| PyDict_SetItemString(d, "YCbCr422", x) < 0)
	2474	return;
	2475	Py_DECREF(x);
[2]	2476	#endif
	2477	#ifdef CL_YCbCr422DC
[391]	2478	x = PyInt_FromLong(CL_YCbCr422DC);
	2479	if (x == NULL \|\| PyDict_SetItemString(d, "YCbCr422DC", x) < 0)
	2480	return;
	2481	Py_DECREF(x);
[2]	2482	#endif
	2483	#ifdef CL_YCbCr422HC
[391]	2484	x = PyInt_FromLong(CL_YCbCr422HC);
	2485	if (x == NULL \|\| PyDict_SetItemString(d, "YCbCr422HC", x) < 0)
	2486	return;
	2487	Py_DECREF(x);
[2]	2488	#endif
	2489	#ifdef CL_YUV
[391]	2490	x = PyInt_FromLong(CL_YUV);
	2491	if (x == NULL \|\| PyDict_SetItemString(d, "YUV", x) < 0)
	2492	return;
	2493	Py_DECREF(x);
[2]	2494	#endif
	2495	#ifdef CL_YUV422
[391]	2496	x = PyInt_FromLong(CL_YUV422);
	2497	if (x == NULL \|\| PyDict_SetItemString(d, "YUV422", x) < 0)
	2498	return;
	2499	Py_DECREF(x);
[2]	2500	#endif
	2501	#ifdef CL_YUV422DC
[391]	2502	x = PyInt_FromLong(CL_YUV422DC);
	2503	if (x == NULL \|\| PyDict_SetItemString(d, "YUV422DC", x) < 0)
	2504	return;
	2505	Py_DECREF(x);
[2]	2506	#endif
	2507	#ifdef CL_YUV422HC
[391]	2508	x = PyInt_FromLong(CL_YUV422HC);
	2509	if (x == NULL \|\| PyDict_SetItemString(d, "YUV422HC", x) < 0)
	2510	return;
	2511	Py_DECREF(x);
[2]	2512	#endif
	2513	#ifdef AWCMP_STEREO
[391]	2514	x = PyInt_FromLong(AWCMP_STEREO);
	2515	if (x == NULL \|\| PyDict_SetItemString(d, "AWCMP_STEREO", x) < 0)
	2516	return;
	2517	Py_DECREF(x);
[2]	2518	#endif
	2519	#ifdef AWCMP_JOINT_STEREO
[391]	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);
[2]	2524	#endif
	2525	#ifdef AWCMP_INDEPENDENT
[391]	2526	x = PyInt_FromLong(AWCMP_INDEPENDENT);
	2527	if (x == NULL \|\| PyDict_SetItemString(d, "AWCMP_INDEPENDENT", x) < 0)
	2528	return;
	2529	Py_DECREF(x);
[2]	2530	#endif
	2531	#ifdef AWCMP_FIXED_RATE
[391]	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);
[2]	2536	#endif
	2537	#ifdef AWCMP_CONST_QUAL
[391]	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);
[2]	2542	#endif
	2543	#ifdef AWCMP_LOSSLESS
[391]	2544	x = PyInt_FromLong(AWCMP_LOSSLESS);
	2545	if (x == NULL \|\| PyDict_SetItemString(d, "AWCMP_LOSSLESS", x) < 0)
	2546	return;
	2547	Py_DECREF(x);
[2]	2548	#endif
	2549	#ifdef AWCMP_MPEG_LAYER_I
[391]	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);
[2]	2554	#endif
	2555	#ifdef AWCMP_MPEG_LAYER_II
[391]	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);
[2]	2560	#endif
	2561
[391]	2562	(void) clSetErrorHandler(cl_ErrorHandler);
[2]	2563	}

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

Context Navigation

source: python/trunk/Modules/clmodule.c

Download in other formats: