cpython/Modules/clmodule.c
1997-10-08 15:26:28 +00:00

2599 lines
67 KiB
C

/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
/* Cl objects */
#define CLDEBUG
#include <stdarg.h>
#include <cl.h>
#if defined(CL_JPEG_SOFTWARE) && !defined(CL_JPEG_COSMO)
#include <dmedia/cl_cosmo.h>
#endif
#include "Python.h"
typedef struct {
PyObject_HEAD
int ob_isCompressor; /* Compressor or Decompressor */
CL_Handle ob_compressorHdl;
int *ob_paramtypes;
int ob_nparams;
} clobject;
static PyObject *ClError; /* exception cl.error */
static int error_handler_called = 0;
/*
* We want to use the function prototypes that are available in the C
* compiler on the SGI. Because of that, we need to declare the first
* argument of the compressor and decompressor methods as "object *",
* even though they are really "clobject *". Therefore we cast the
* argument to the proper type using this macro.
*/
#define SELF ((clobject *) self)
/********************************************************************
Utility routines.
********************************************************************/
static void
cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...)
{
va_list ap;
char errbuf[BUFSIZ]; /* hopefully big enough */
char *p;
if (PyErr_Occurred()) /* don't change existing error */
return;
error_handler_called = 1;
va_start(ap, fmt);
vsprintf(errbuf, fmt, ap);
va_end(ap);
p = &errbuf[strlen(errbuf) - 1]; /* swat the line feed */
if (*p == '\n')
*p = 0;
PyErr_SetString(ClError, errbuf);
}
/*
* This assumes that params are always in the range 0 to some maximum.
*/
static int
param_type_is_float(clobject *self, int param)
{
int bufferlength;
if (self->ob_paramtypes == NULL) {
error_handler_called = 0;
bufferlength = clQueryParams(self->ob_compressorHdl, 0, 0);
if (error_handler_called)
return -1;
self->ob_paramtypes = PyMem_NEW(int, bufferlength);
if (self->ob_paramtypes == NULL)
return -1;
self->ob_nparams = bufferlength / 2;
(void) clQueryParams(self->ob_compressorHdl,
self->ob_paramtypes, bufferlength);
if (error_handler_called) {
PyMem_DEL(self->ob_paramtypes);
self->ob_paramtypes = NULL;
return -1;
}
}
if (param < 0 || param >= self->ob_nparams)
return -1;
if (self->ob_paramtypes[param*2 + 1] == CL_FLOATING_ENUM_VALUE ||
self->ob_paramtypes[param*2 + 1] == CL_FLOATING_RANGE_VALUE)
return 1;
else
return 0;
}
/********************************************************************
Single image compression/decompression.
********************************************************************/
static PyObject *
cl_CompressImage(PyObject *self, PyObject *args)
{
int compressionScheme, width, height, originalFormat;
float compressionRatio;
int frameBufferSize, compressedBufferSize;
char *frameBuffer;
PyObject *compressedBuffer;
if (!PyArg_Parse(args, "(iiiifs#)", &compressionScheme,
&width, &height,
&originalFormat, &compressionRatio, &frameBuffer,
&frameBufferSize))
return NULL;
retry:
compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
if (compressedBuffer == NULL)
return NULL;
compressedBufferSize = frameBufferSize;
error_handler_called = 0;
if (clCompressImage(compressionScheme, width, height, originalFormat,
compressionRatio, (void *) frameBuffer,
&compressedBufferSize,
(void *) PyString_AsString(compressedBuffer))
== FAILURE || error_handler_called) {
Py_DECREF(compressedBuffer);
if (!error_handler_called)
PyErr_SetString(ClError, "clCompressImage failed");
return NULL;
}
if (compressedBufferSize > frameBufferSize) {
frameBufferSize = compressedBufferSize;
Py_DECREF(compressedBuffer);
goto retry;
}
if (compressedBufferSize < frameBufferSize)
if (_PyString_Resize(&compressedBuffer, compressedBufferSize))
return NULL;
return compressedBuffer;
}
static PyObject *
cl_DecompressImage(PyObject *self, PyObject *args)
{
int compressionScheme, width, height, originalFormat;
char *compressedBuffer;
int compressedBufferSize, frameBufferSize;
PyObject *frameBuffer;
if (!PyArg_Parse(args, "(iiiis#)", &compressionScheme, &width, &height,
&originalFormat, &compressedBuffer,
&compressedBufferSize))
return NULL;
frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);
frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
if (frameBuffer == NULL)
return NULL;
error_handler_called = 0;
if (clDecompressImage(compressionScheme, width, height, originalFormat,
compressedBufferSize, compressedBuffer,
(void *) PyString_AsString(frameBuffer))
== FAILURE || error_handler_called) {
Py_DECREF(frameBuffer);
if (!error_handler_called)
PyErr_SetString(ClError, "clDecompressImage failed");
return NULL;
}
return frameBuffer;
}
/********************************************************************
Sequential compression/decompression.
********************************************************************/
#define CheckCompressor(self) if ((self)->ob_compressorHdl == NULL) { \
PyErr_SetString(PyExc_RuntimeError, "(de)compressor not active"); \
return NULL; \
}
static PyObject *
doClose(clobject *self, PyObject *args, int (*close_func)(CL_Handle))
{
CheckCompressor(self);
if (!PyArg_NoArgs(args))
return NULL;
error_handler_called = 0;
if ((*close_func)(self->ob_compressorHdl) == FAILURE ||
error_handler_called) {
if (!error_handler_called)
PyErr_SetString(ClError, "close failed");
return NULL;
}
self->ob_compressorHdl = NULL;
if (self->ob_paramtypes)
PyMem_DEL(self->ob_paramtypes);
self->ob_paramtypes = NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
clm_CloseCompressor(PyObject *self, PyObject *args)
{
return doClose(SELF, args, clCloseCompressor);
}
static PyObject *
clm_CloseDecompressor(PyObject *self, PyObject *args)
{
return doClose(SELF, args, clCloseDecompressor);
}
static PyObject *
clm_Compress(PyObject *self, PyObject *args)
{
int numberOfFrames;
int frameBufferSize, compressedBufferSize, size;
char *frameBuffer;
PyObject *data;
CheckCompressor(SELF);
if (!PyArg_Parse(args, "(is#)", &numberOfFrames,
&frameBuffer, &frameBufferSize))
return NULL;
error_handler_called = 0;
size = clGetParam(SELF->ob_compressorHdl, CL_COMPRESSED_BUFFER_SIZE);
compressedBufferSize = size;
if (error_handler_called)
return NULL;
data = PyString_FromStringAndSize(NULL, size);
if (data == NULL)
return NULL;
error_handler_called = 0;
if (clCompress(SELF->ob_compressorHdl, numberOfFrames,
(void *) frameBuffer, &compressedBufferSize,
(void *) PyString_AsString(data)) == FAILURE ||
error_handler_called) {
Py_DECREF(data);
if (!error_handler_called)
PyErr_SetString(ClError, "compress failed");
return NULL;
}
if (compressedBufferSize < size)
if (_PyString_Resize(&data, compressedBufferSize))
return NULL;
if (compressedBufferSize > size) {
/* we didn't get all "compressed" data */
Py_DECREF(data);
PyErr_SetString(ClError,
"compressed data is more than fitted");
return NULL;
}
return data;
}
static PyObject *
clm_Decompress(PyObject *self, PyObject *args)
{
PyObject *data;
int numberOfFrames;
char *compressedData;
int compressedDataSize, dataSize;
CheckCompressor(SELF);
if (!PyArg_Parse(args, "(is#)", &numberOfFrames, &compressedData,
&compressedDataSize))
return NULL;
error_handler_called = 0;
dataSize = clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE);
if (error_handler_called)
return NULL;
data = PyString_FromStringAndSize(NULL, dataSize);
if (data == NULL)
return NULL;
error_handler_called = 0;
if (clDecompress(SELF->ob_compressorHdl, numberOfFrames,
compressedDataSize, (void *) compressedData,
(void *) PyString_AsString(data)) == FAILURE ||
error_handler_called) {
Py_DECREF(data);
if (!error_handler_called)
PyErr_SetString(ClError, "decompress failed");
return NULL;
}
return data;
}
static PyObject *
doParams(clobject *self, PyObject *args, int (*func)(CL_Handle, int *, int),
int modified)
{
PyObject *list, *v;
int *PVbuffer;
int length;
int i;
float number;
CheckCompressor(self);
if (!PyArg_Parse(args, "O", &list))
return NULL;
if (!PyList_Check(list)) {
PyErr_BadArgument();
return NULL;
}
length = PyList_Size(list);
PVbuffer = PyMem_NEW(int, length);
if (PVbuffer == NULL)
return PyErr_NoMemory();
for (i = 0; i < length; i++) {
v = PyList_GetItem(list, i);
if (PyFloat_Check(v)) {
number = PyFloat_AsDouble(v);
PVbuffer[i] = CL_TypeIsInt(number);
} else if (PyInt_Check(v)) {
PVbuffer[i] = PyInt_AsLong(v);
if ((i & 1) &&
param_type_is_float(self, PVbuffer[i-1]) > 0) {
number = PVbuffer[i];
PVbuffer[i] = CL_TypeIsInt(number);
}
} else {
PyMem_DEL(PVbuffer);
PyErr_BadArgument();
return NULL;
}
}
error_handler_called = 0;
(*func)(self->ob_compressorHdl, PVbuffer, length);
if (error_handler_called) {
PyMem_DEL(PVbuffer);
return NULL;
}
if (modified) {
for (i = 0; i < length; i++) {
if ((i & 1) &&
param_type_is_float(self, PVbuffer[i-1]) > 0) {
number = CL_TypeIsFloat(PVbuffer[i]);
v = PyFloat_FromDouble(number);
} else
v = PyInt_FromLong(PVbuffer[i]);
PyList_SetItem(list, i, v);
}
}
PyMem_DEL(PVbuffer);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
clm_GetParams(PyObject *self, PyObject *args)
{
return doParams(SELF, args, clGetParams, 1);
}
static PyObject *
clm_SetParams(PyObject *self, PyObject *args)
{
return doParams(SELF, args, clSetParams, 0);
}
static PyObject *
do_get(clobject *self, PyObject *args, int (*func)(CL_Handle, int))
{
int paramID, value;
float fvalue;
CheckCompressor(self);
if (!PyArg_Parse(args, "i", &paramID))
return NULL;
error_handler_called = 0;
value = (*func)(self->ob_compressorHdl, paramID);
if (error_handler_called)
return NULL;
if (param_type_is_float(self, paramID) > 0) {
fvalue = CL_TypeIsFloat(value);
return PyFloat_FromDouble(fvalue);
}
return PyInt_FromLong(value);
}
static PyObject *
clm_GetParam(PyObject *self, PyObject *args)
{
return do_get(SELF, args, clGetParam);
}
static PyObject *
clm_GetDefault(PyObject *self, PyObject *args)
{
return do_get(SELF, args, clGetDefault);
}
static PyObject *
clm_SetParam(PyObject *self, PyObject *args)
{
int paramID, value;
float fvalue;
CheckCompressor(SELF);
if (!PyArg_Parse(args, "(ii)", &paramID, &value)) {
PyErr_Clear();
if (!PyArg_Parse(args, "(if)", &paramID, &fvalue)) {
PyErr_Clear();
PyErr_SetString(PyExc_TypeError,
"bad argument list (format '(ii)' or '(if)')");
return NULL;
}
value = CL_TypeIsInt(fvalue);
} else {
if (param_type_is_float(SELF, paramID) > 0) {
fvalue = value;
value = CL_TypeIsInt(fvalue);
}
}
error_handler_called = 0;
value = clSetParam(SELF->ob_compressorHdl, paramID, value);
if (error_handler_called)
return NULL;
if (param_type_is_float(SELF, paramID) > 0)
return PyFloat_FromDouble(CL_TypeIsFloat(value));
else
return PyInt_FromLong(value);
}
static PyObject *
clm_GetParamID(PyObject *self, PyObject *args)
{
char *name;
int value;
CheckCompressor(SELF);
if (!PyArg_Parse(args, "s", &name))
return NULL;
error_handler_called = 0;
value = clGetParamID(SELF->ob_compressorHdl, name);
if (value == FAILURE || error_handler_called) {
if (!error_handler_called)
PyErr_SetString(ClError, "getparamid failed");
return NULL;
}
return PyInt_FromLong(value);
}
static PyObject *
clm_QueryParams(PyObject *self, PyObject *args)
{
int bufferlength;
int *PVbuffer;
PyObject *list;
int i;
CheckCompressor(SELF);
if (!PyArg_NoArgs(args))
return NULL;
error_handler_called = 0;
bufferlength = clQueryParams(SELF->ob_compressorHdl, 0, 0);
if (error_handler_called)
return NULL;
PVbuffer = PyMem_NEW(int, bufferlength);
if (PVbuffer == NULL)
return PyErr_NoMemory();
bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer,
bufferlength);
if (error_handler_called) {
PyMem_DEL(PVbuffer);
return NULL;
}
list = PyList_New(bufferlength);
if (list == NULL) {
PyMem_DEL(PVbuffer);
return NULL;
}
for (i = 0; i < bufferlength; i++) {
if (i & 1)
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
else if (PVbuffer[i] == 0) {
Py_INCREF(Py_None);
PyList_SetItem(list, i, Py_None);
} else
PyList_SetItem(list, i,
PyString_FromString((char *) PVbuffer[i]));
}
PyMem_DEL(PVbuffer);
return list;
}
static PyObject *
clm_GetMinMax(PyObject *self, PyObject *args)
{
int param, min, max;
float fmin, fmax;
CheckCompressor(SELF);
if (!PyArg_Parse(args, "i", &param))
return NULL;
clGetMinMax(SELF->ob_compressorHdl, param, &min, &max);
if (param_type_is_float(SELF, param) > 0) {
fmin = CL_TypeIsFloat(min);
fmax = CL_TypeIsFloat(max);
return Py_BuildValue("(ff)", fmin, fmax);
}
return Py_BuildValue("(ii)", min, max);
}
static PyObject *
clm_GetName(PyObject *self, PyObject *args)
{
int param;
char *name;
CheckCompressor(SELF);
if (!PyArg_Parse(args, "i", &param))
return NULL;
error_handler_called = 0;
name = clGetName(SELF->ob_compressorHdl, param);
if (name == NULL || error_handler_called) {
if (!error_handler_called)
PyErr_SetString(ClError, "getname failed");
return NULL;
}
return PyString_FromString(name);
}
static PyObject *
clm_QuerySchemeFromHandle(PyObject *self, PyObject *args)
{
CheckCompressor(SELF);
if (!PyArg_NoArgs(args))
return NULL;
return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
}
static PyObject *
clm_ReadHeader(PyObject *self, PyObject *args)
{
char *header;
int headerSize;
CheckCompressor(SELF);
if (!PyArg_Parse(args, "s#", &header, &headerSize))
return NULL;
return PyInt_FromLong(clReadHeader(SELF->ob_compressorHdl,
headerSize, header));
}
static PyMethodDef compressor_methods[] = {
{"close", clm_CloseCompressor}, /* alias */
{"CloseCompressor", clm_CloseCompressor},
{"Compress", clm_Compress},
{"GetDefault", clm_GetDefault},
{"GetMinMax", clm_GetMinMax},
{"GetName", clm_GetName},
{"GetParam", clm_GetParam},
{"GetParamID", clm_GetParamID},
{"GetParams", clm_GetParams},
{"QueryParams", clm_QueryParams},
{"QuerySchemeFromHandle",clm_QuerySchemeFromHandle},
{"SetParam", clm_SetParam},
{"SetParams", clm_SetParams},
{NULL, NULL} /* sentinel */
};
static PyMethodDef decompressor_methods[] = {
{"close", clm_CloseDecompressor}, /* alias */
{"CloseDecompressor", clm_CloseDecompressor},
{"Decompress", clm_Decompress},
{"GetDefault", clm_GetDefault},
{"GetMinMax", clm_GetMinMax},
{"GetName", clm_GetName},
{"GetParam", clm_GetParam},
{"GetParamID", clm_GetParamID},
{"GetParams", clm_GetParams},
{"ReadHeader", clm_ReadHeader},
{"QueryParams", clm_QueryParams},
{"QuerySchemeFromHandle",clm_QuerySchemeFromHandle},
{"SetParam", clm_SetParam},
{"SetParams", clm_SetParams},
{NULL, NULL} /* sentinel */
};
static void
cl_dealloc(PyObject *self)
{
if (SELF->ob_compressorHdl) {
if (SELF->ob_isCompressor)
clCloseCompressor(SELF->ob_compressorHdl);
else
clCloseDecompressor(SELF->ob_compressorHdl);
}
PyMem_DEL(self);
}
static PyObject *
cl_getattr(PyObject *self, char *name)
{
if (SELF->ob_isCompressor)
return Py_FindMethod(compressor_methods, self, name);
else
return Py_FindMethod(decompressor_methods, self, name);
}
static PyTypeObject Cltype = {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"cl", /*tp_name*/
sizeof(clobject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
(destructor)cl_dealloc, /*tp_dealloc*/
0, /*tp_print*/
(getattrfunc)cl_getattr, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
};
static PyObject *
doOpen(PyObject *self, PyObject *args, int (*open_func)(int, CL_Handle *),
int iscompressor)
{
int scheme;
clobject *new;
if (!PyArg_Parse(args, "i", &scheme))
return NULL;
new = PyObject_NEW(clobject, &Cltype);
if (new == NULL)
return NULL;
new->ob_compressorHdl = NULL;
new->ob_isCompressor = iscompressor;
new->ob_paramtypes = NULL;
error_handler_called = 0;
if ((*open_func)(scheme, &new->ob_compressorHdl) == FAILURE ||
error_handler_called) {
Py_DECREF(new);
if (!error_handler_called)
PyErr_SetString(ClError, "Open(De)Compressor failed");
return NULL;
}
return (PyObject *)new;
}
static PyObject *
cl_OpenCompressor(PyObject *self, PyObject *args)
{
return doOpen(self, args, clOpenCompressor, 1);
}
static PyObject *
cl_OpenDecompressor(PyObject *self, PyObject *args)
{
return doOpen(self, args, clOpenDecompressor, 0);
}
static PyObject *
cl_QueryScheme(PyObject *self, PyObject *args)
{
char *header;
int headerlen;
int scheme;
if (!PyArg_Parse(args, "s#", &header, &headerlen))
return NULL;
scheme = clQueryScheme(header);
if (scheme < 0) {
PyErr_SetString(ClError, "unknown compression scheme");
return NULL;
}
return PyInt_FromLong(scheme);
}
static PyObject *
cl_QueryMaxHeaderSize(PyObject *self, PyObject *args)
{
int scheme;
if (!PyArg_Parse(args, "i", &scheme))
return NULL;
return PyInt_FromLong(clQueryMaxHeaderSize(scheme));
}
static PyObject *
cl_QueryAlgorithms(PyObject *self, PyObject *args)
{
int algorithmMediaType;
int bufferlength;
int *PVbuffer;
PyObject *list;
int i;
if (!PyArg_Parse(args, "i", &algorithmMediaType))
return NULL;
error_handler_called = 0;
bufferlength = clQueryAlgorithms(algorithmMediaType, 0, 0);
if (error_handler_called)
return NULL;
PVbuffer = PyMem_NEW(int, bufferlength);
if (PVbuffer == NULL)
return PyErr_NoMemory();
bufferlength = clQueryAlgorithms(algorithmMediaType, PVbuffer,
bufferlength);
if (error_handler_called) {
PyMem_DEL(PVbuffer);
return NULL;
}
list = PyList_New(bufferlength);
if (list == NULL) {
PyMem_DEL(PVbuffer);
return NULL;
}
for (i = 0; i < bufferlength; i++) {
if (i & 1)
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
else if (PVbuffer[i] == 0) {
Py_INCREF(Py_None);
PyList_SetItem(list, i, Py_None);
} else
PyList_SetItem(list, i,
PyString_FromString((char *) PVbuffer[i]));
}
PyMem_DEL(PVbuffer);
return list;
}
static PyObject *
cl_QuerySchemeFromName(PyObject *self, PyObject *args)
{
int algorithmMediaType;
char *name;
int scheme;
if (!PyArg_Parse(args, "(is)", &algorithmMediaType, &name))
return NULL;
error_handler_called = 0;
scheme = clQuerySchemeFromName(algorithmMediaType, name);
if (error_handler_called) {
PyErr_SetString(ClError, "unknown compression scheme");
return NULL;
}
return PyInt_FromLong(scheme);
}
static PyObject *
cl_GetAlgorithmName(PyObject *self, PyObject *args)
{
int scheme;
char *name;
if (!PyArg_Parse(args, "i", &scheme))
return NULL;
name = clGetAlgorithmName(scheme);
if (name == 0) {
PyErr_SetString(ClError, "unknown compression scheme");
return NULL;
}
return PyString_FromString(name);
}
static PyObject *
do_set(PyObject *self, PyObject *args, int (*func)(int, int, int))
{
int scheme, paramID, value;
float fvalue;
int is_float = 0;
if (!PyArg_Parse(args, "(iii)", &scheme, &paramID, &value)) {
PyErr_Clear();
if (!PyArg_Parse(args, "(iif)", &scheme, &paramID, &fvalue)) {
PyErr_Clear();
PyErr_SetString(PyExc_TypeError,
"bad argument list (format '(iii)' or '(iif)')");
return NULL;
}
value = CL_TypeIsInt(fvalue);
is_float = 1;
} else {
/* check some parameters which we know to be floats */
switch (scheme) {
case CL_COMPRESSION_RATIO:
case CL_SPEED:
fvalue = value;
value = CL_TypeIsInt(fvalue);
is_float = 1;
break;
}
}
error_handler_called = 0;
value = (*func)(scheme, paramID, value);
if (error_handler_called)
return NULL;
if (is_float)
return PyFloat_FromDouble(CL_TypeIsFloat(value));
else
return PyInt_FromLong(value);
}
static PyObject *
cl_SetDefault(PyObject *self, PyObject *args)
{
return do_set(self, args, clSetDefault);
}
static PyObject *
cl_SetMin(PyObject *self, PyObject *args)
{
return do_set(self, args, clSetMin);
}
static PyObject *
cl_SetMax(PyObject *self, PyObject *args)
{
return do_set(self, args, clSetMax);
}
#define func(name, handler) \
static PyObject *cl_##name(PyObject *self, PyObject *args) \
{ \
int x; \
if (!PyArg_Parse(args, "i", &x)) return NULL; \
return Py##handler(CL_##name(x)); \
}
#define func2(name, handler) \
static PyObject *cl_##name(PyObject *self, PyObject *args) \
{ \
int a1, a2; \
if (!PyArg_Parse(args, "(ii)", &a1, &a2)) return NULL; \
return Py##handler(CL_##name(a1, a2)); \
}
func(BytesPerSample, Int_FromLong)
func(BytesPerPixel, Int_FromLong)
func(AudioFormatName, String_FromString)
func(VideoFormatName, String_FromString)
func(AlgorithmNumber, Int_FromLong)
func(AlgorithmType, Int_FromLong)
func2(Algorithm, Int_FromLong)
func(ParamNumber, Int_FromLong)
func(ParamType, Int_FromLong)
func2(ParamID, Int_FromLong)
#ifdef CLDEBUG
static PyObject *
cvt_type(PyObject *self, PyObject *args)
{
int number;
float fnumber;
if (PyArg_Parse(args, "i", &number))
return PyFloat_FromDouble(CL_TypeIsFloat(number));
else {
PyErr_Clear();
if (PyArg_Parse(args, "f", &fnumber))
return PyInt_FromLong(CL_TypeIsInt(fnumber));
return NULL;
}
}
#endif
static PyMethodDef cl_methods[] = {
{"CompressImage", cl_CompressImage},
{"DecompressImage", cl_DecompressImage},
{"GetAlgorithmName", cl_GetAlgorithmName},
{"OpenCompressor", cl_OpenCompressor},
{"OpenDecompressor", cl_OpenDecompressor},
{"QueryAlgorithms", cl_QueryAlgorithms},
{"QueryMaxHeaderSize", cl_QueryMaxHeaderSize},
{"QueryScheme", cl_QueryScheme},
{"QuerySchemeFromName", cl_QuerySchemeFromName},
{"SetDefault", cl_SetDefault},
{"SetMax", cl_SetMax},
{"SetMin", cl_SetMin},
{"BytesPerSample", cl_BytesPerSample},
{"BytesPerPixel", cl_BytesPerPixel},
{"AudioFormatName", cl_AudioFormatName},
{"VideoFormatName", cl_VideoFormatName},
{"AlgorithmNumber", cl_AlgorithmNumber},
{"AlgorithmType", cl_AlgorithmType},
{"Algorithm", cl_Algorithm},
{"ParamNumber", cl_ParamNumber},
{"ParamType", cl_ParamType},
{"ParamID", cl_ParamID},
#ifdef CLDEBUG
{"cvt_type", cvt_type},
#endif
{NULL, NULL} /* Sentinel */
};
#ifdef CL_JPEG_SOFTWARE
#define IRIX_5_3_LIBRARY
#endif
void
initcl()
{
PyObject *m, *d, *x;
m = Py_InitModule("cl", cl_methods);
d = PyModule_GetDict(m);
ClError = PyErr_NewException("cl.error", NULL, NULL);
(void) PyDict_SetItemString(d, "error", ClError);
#ifdef CL_ADDED_ALGORITHM_ERROR
x = PyInt_FromLong(CL_ADDED_ALGORITHM_ERROR);
if (x == NULL || PyDict_SetItemString(d, "ADDED_ALGORITHM_ERROR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ALAW
x = PyInt_FromLong(CL_ALAW);
if (x == NULL || PyDict_SetItemString(d, "ALAW", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ALGORITHM_ID
x = PyInt_FromLong(CL_ALGORITHM_ID);
if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_ID", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ALGORITHM_TABLE_FULL
x = PyInt_FromLong(CL_ALGORITHM_TABLE_FULL);
if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_TABLE_FULL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ALGORITHM_VERSION
x = PyInt_FromLong(CL_ALGORITHM_VERSION);
if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_VERSION", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ALG_AUDIO
x = PyInt_FromLong(CL_ALG_AUDIO);
if (x == NULL || PyDict_SetItemString(d, "ALG_AUDIO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ALG_VIDEO
x = PyInt_FromLong(CL_ALG_VIDEO);
if (x == NULL || PyDict_SetItemString(d, "ALG_VIDEO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AUDIO
x = PyInt_FromLong(CL_AUDIO);
if (x == NULL || PyDict_SetItemString(d, "AUDIO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_BITRATE_POLICY
x = PyInt_FromLong(CL_AWARE_BITRATE_POLICY);
if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_POLICY", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_BITRATE_TARGET
x = PyInt_FromLong(CL_AWARE_BITRATE_TARGET);
if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_TARGET", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_CHANNEL_POLICY
x = PyInt_FromLong(CL_AWARE_CHANNEL_POLICY);
if (x == NULL || PyDict_SetItemString(d, "AWARE_CHANNEL_POLICY", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_CONST_QUAL
x = PyInt_FromLong(CL_AWARE_CONST_QUAL);
if (x == NULL || PyDict_SetItemString(d, "AWARE_CONST_QUAL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_ERROR
x = PyInt_FromLong(CL_AWARE_ERROR);
if (x == NULL || PyDict_SetItemString(d, "AWARE_ERROR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_FIXED_RATE
x = PyInt_FromLong(CL_AWARE_FIXED_RATE);
if (x == NULL || PyDict_SetItemString(d, "AWARE_FIXED_RATE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_INDEPENDENT
x = PyInt_FromLong(CL_AWARE_INDEPENDENT);
if (x == NULL || PyDict_SetItemString(d, "AWARE_INDEPENDENT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_JOINT_STEREO
x = PyInt_FromLong(CL_AWARE_JOINT_STEREO);
if (x == NULL || PyDict_SetItemString(d, "AWARE_JOINT_STEREO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_LAYER
x = PyInt_FromLong(CL_AWARE_LAYER);
if (x == NULL || PyDict_SetItemString(d, "AWARE_LAYER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_LOSSLESS
x = PyInt_FromLong(CL_AWARE_LOSSLESS);
if (x == NULL || PyDict_SetItemString(d, "AWARE_LOSSLESS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_MPEG_AUDIO
x = PyInt_FromLong(CL_AWARE_MPEG_AUDIO);
if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_AUDIO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_MPEG_LAYER_I
x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_I);
if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_I", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_MPEG_LAYER_II
x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_II);
if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_II", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_MULTIRATE
x = PyInt_FromLong(CL_AWARE_MULTIRATE);
if (x == NULL || PyDict_SetItemString(d, "AWARE_MULTIRATE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_NOISE_MARGIN
x = PyInt_FromLong(CL_AWARE_NOISE_MARGIN);
if (x == NULL || PyDict_SetItemString(d, "AWARE_NOISE_MARGIN", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_AWARE_STEREO
x = PyInt_FromLong(CL_AWARE_STEREO);
if (x == NULL || PyDict_SetItemString(d, "AWARE_STEREO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_ALGORITHM_NAME
x = PyInt_FromLong(CL_BAD_ALGORITHM_NAME);
if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_NAME", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_ALGORITHM_TYPE
x = PyInt_FromLong(CL_BAD_ALGORITHM_TYPE);
if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_TYPE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BLOCK_SIZE
x = PyInt_FromLong(CL_BAD_BLOCK_SIZE);
if (x == NULL || PyDict_SetItemString(d, "BAD_BLOCK_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BOARD
x = PyInt_FromLong(CL_BAD_BOARD);
if (x == NULL || PyDict_SetItemString(d, "BAD_BOARD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFERING
x = PyInt_FromLong(CL_BAD_BUFFERING);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERING", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFERLENGTH_NEG
x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_NEG);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFERLENGTH_ODD
x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_ODD);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFER_EXISTS
x = PyInt_FromLong(CL_BAD_BUFFER_EXISTS);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_EXISTS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFER_HANDLE
x = PyInt_FromLong(CL_BAD_BUFFER_HANDLE);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_HANDLE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFER_POINTER
x = PyInt_FromLong(CL_BAD_BUFFER_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFER_QUERY_SIZE
x = PyInt_FromLong(CL_BAD_BUFFER_QUERY_SIZE);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_QUERY_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFER_SIZE
x = PyInt_FromLong(CL_BAD_BUFFER_SIZE);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFER_SIZE_POINTER
x = PyInt_FromLong(CL_BAD_BUFFER_SIZE_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_BUFFER_TYPE
x = PyInt_FromLong(CL_BAD_BUFFER_TYPE);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_TYPE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_COMPRESSION_SCHEME
x = PyInt_FromLong(CL_BAD_COMPRESSION_SCHEME);
if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSION_SCHEME", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_COMPRESSOR_HANDLE
x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE);
if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_COMPRESSOR_HANDLE_POINTER
x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_FRAME_SIZE
x = PyInt_FromLong(CL_BAD_FRAME_SIZE);
if (x == NULL || PyDict_SetItemString(d, "BAD_FRAME_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_FUNCTIONALITY
x = PyInt_FromLong(CL_BAD_FUNCTIONALITY);
if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTIONALITY", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_FUNCTION_POINTER
x = PyInt_FromLong(CL_BAD_FUNCTION_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTION_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_HEADER_SIZE
x = PyInt_FromLong(CL_BAD_HEADER_SIZE);
if (x == NULL || PyDict_SetItemString(d, "BAD_HEADER_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_INITIAL_VALUE
x = PyInt_FromLong(CL_BAD_INITIAL_VALUE);
if (x == NULL || PyDict_SetItemString(d, "BAD_INITIAL_VALUE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_INTERNAL_FORMAT
x = PyInt_FromLong(CL_BAD_INTERNAL_FORMAT);
if (x == NULL || PyDict_SetItemString(d, "BAD_INTERNAL_FORMAT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_LICENSE
x = PyInt_FromLong(CL_BAD_LICENSE);
if (x == NULL || PyDict_SetItemString(d, "BAD_LICENSE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_MIN_GT_MAX
x = PyInt_FromLong(CL_BAD_MIN_GT_MAX);
if (x == NULL || PyDict_SetItemString(d, "BAD_MIN_GT_MAX", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_NO_BUFFERSPACE
x = PyInt_FromLong(CL_BAD_NO_BUFFERSPACE);
if (x == NULL || PyDict_SetItemString(d, "BAD_NO_BUFFERSPACE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_NUMBER_OF_BLOCKS
x = PyInt_FromLong(CL_BAD_NUMBER_OF_BLOCKS);
if (x == NULL || PyDict_SetItemString(d, "BAD_NUMBER_OF_BLOCKS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_PARAM
x = PyInt_FromLong(CL_BAD_PARAM);
if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_PARAM_ID_POINTER
x = PyInt_FromLong(CL_BAD_PARAM_ID_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_ID_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_PARAM_TYPE
x = PyInt_FromLong(CL_BAD_PARAM_TYPE);
if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_TYPE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_POINTER
x = PyInt_FromLong(CL_BAD_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_PVBUFFER
x = PyInt_FromLong(CL_BAD_PVBUFFER);
if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_SCHEME_POINTER
x = PyInt_FromLong(CL_BAD_SCHEME_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_SCHEME_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_STREAM_HEADER
x = PyInt_FromLong(CL_BAD_STREAM_HEADER);
if (x == NULL || PyDict_SetItemString(d, "BAD_STREAM_HEADER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_STRING_POINTER
x = PyInt_FromLong(CL_BAD_STRING_POINTER);
if (x == NULL || PyDict_SetItemString(d, "BAD_STRING_POINTER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BAD_TEXT_STRING_PTR
x = PyInt_FromLong(CL_BAD_TEXT_STRING_PTR);
if (x == NULL || PyDict_SetItemString(d, "BAD_TEXT_STRING_PTR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BEST_FIT
x = PyInt_FromLong(CL_BEST_FIT);
if (x == NULL || PyDict_SetItemString(d, "BEST_FIT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BIDIRECTIONAL
x = PyInt_FromLong(CL_BIDIRECTIONAL);
if (x == NULL || PyDict_SetItemString(d, "BIDIRECTIONAL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BITRATE
x = PyInt_FromLong(CL_BITRATE);
if (x == NULL || PyDict_SetItemString(d, "BITRATE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BITRATE_POLICY
x = PyInt_FromLong(CL_BITRATE_POLICY);
if (x == NULL || PyDict_SetItemString(d, "BITRATE_POLICY", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BITRATE_TARGET
x = PyInt_FromLong(CL_BITRATE_TARGET);
if (x == NULL || PyDict_SetItemString(d, "BITRATE_TARGET", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BITS_PER_COMPONENT
x = PyInt_FromLong(CL_BITS_PER_COMPONENT);
if (x == NULL || PyDict_SetItemString(d, "BITS_PER_COMPONENT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BLENDING
x = PyInt_FromLong(CL_BLENDING);
if (x == NULL || PyDict_SetItemString(d, "BLENDING", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BLOCK_SIZE
x = PyInt_FromLong(CL_BLOCK_SIZE);
if (x == NULL || PyDict_SetItemString(d, "BLOCK_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BOTTOM_UP
x = PyInt_FromLong(CL_BOTTOM_UP);
if (x == NULL || PyDict_SetItemString(d, "BOTTOM_UP", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BUFFER_NOT_CREATED
x = PyInt_FromLong(CL_BUFFER_NOT_CREATED);
if (x == NULL || PyDict_SetItemString(d, "BUFFER_NOT_CREATED", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BUF_COMPRESSED
x = PyInt_FromLong(CL_BUF_COMPRESSED);
if (x == NULL || PyDict_SetItemString(d, "BUF_COMPRESSED", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BUF_DATA
x = PyInt_FromLong(CL_BUF_DATA);
if (x == NULL || PyDict_SetItemString(d, "BUF_DATA", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_BUF_FRAME
x = PyInt_FromLong(CL_BUF_FRAME);
if (x == NULL || PyDict_SetItemString(d, "BUF_FRAME", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_CHANNEL_POLICY
x = PyInt_FromLong(CL_CHANNEL_POLICY);
if (x == NULL || PyDict_SetItemString(d, "CHANNEL_POLICY", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_CHROMA_THRESHOLD
x = PyInt_FromLong(CL_CHROMA_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "CHROMA_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_CODEC
x = PyInt_FromLong(CL_CODEC);
if (x == NULL || PyDict_SetItemString(d, "CODEC", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COMPONENTS
x = PyInt_FromLong(CL_COMPONENTS);
if (x == NULL || PyDict_SetItemString(d, "COMPONENTS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COMPRESSED_BUFFER_SIZE
x = PyInt_FromLong(CL_COMPRESSED_BUFFER_SIZE);
if (x == NULL || PyDict_SetItemString(d, "COMPRESSED_BUFFER_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COMPRESSION_RATIO
x = PyInt_FromLong(CL_COMPRESSION_RATIO);
if (x == NULL || PyDict_SetItemString(d, "COMPRESSION_RATIO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COMPRESSOR
x = PyInt_FromLong(CL_COMPRESSOR);
if (x == NULL || PyDict_SetItemString(d, "COMPRESSOR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_CONTINUOUS_BLOCK
x = PyInt_FromLong(CL_CONTINUOUS_BLOCK);
if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_BLOCK", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_CONTINUOUS_NONBLOCK
x = PyInt_FromLong(CL_CONTINUOUS_NONBLOCK);
if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_NONBLOCK", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COSMO_CODEC_CONTROL
x = PyInt_FromLong(CL_COSMO_CODEC_CONTROL);
if (x == NULL || PyDict_SetItemString(d, "COSMO_CODEC_CONTROL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COSMO_NUM_PARAMS
x = PyInt_FromLong(CL_COSMO_NUM_PARAMS);
if (x == NULL || PyDict_SetItemString(d, "COSMO_NUM_PARAMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COSMO_VALUE_BASE
x = PyInt_FromLong(CL_COSMO_VALUE_BASE);
if (x == NULL || PyDict_SetItemString(d, "COSMO_VALUE_BASE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COSMO_VIDEO_MANUAL_CONTROL
x = PyInt_FromLong(CL_COSMO_VIDEO_MANUAL_CONTROL);
if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_MANUAL_CONTROL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_COSMO_VIDEO_TRANSFER_MODE
x = PyInt_FromLong(CL_COSMO_VIDEO_TRANSFER_MODE);
if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_TRANSFER_MODE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_DATA
x = PyInt_FromLong(CL_DATA);
if (x == NULL || PyDict_SetItemString(d, "DATA", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_DECOMPRESSOR
x = PyInt_FromLong(CL_DECOMPRESSOR);
if (x == NULL || PyDict_SetItemString(d, "DECOMPRESSOR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_DSO_ERROR
x = PyInt_FromLong(CL_DSO_ERROR);
if (x == NULL || PyDict_SetItemString(d, "DSO_ERROR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_EDGE_THRESHOLD
x = PyInt_FromLong(CL_EDGE_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "EDGE_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ENABLE_IMAGEINFO
x = PyInt_FromLong(CL_ENABLE_IMAGEINFO);
if (x == NULL || PyDict_SetItemString(d, "ENABLE_IMAGEINFO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_END_OF_SEQUENCE
x = PyInt_FromLong(CL_END_OF_SEQUENCE);
if (x == NULL || PyDict_SetItemString(d, "END_OF_SEQUENCE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ENUM_VALUE
x = PyInt_FromLong(CL_ENUM_VALUE);
if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_EXACT_COMPRESSION_RATIO
x = PyInt_FromLong(CL_EXACT_COMPRESSION_RATIO);
if (x == NULL || PyDict_SetItemString(d, "EXACT_COMPRESSION_RATIO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_EXTERNAL_DEVICE
x = PyInt_FromLong((long) CL_EXTERNAL_DEVICE);
if (x == NULL || PyDict_SetItemString(d, "EXTERNAL_DEVICE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FLOATING_ENUM_VALUE
x = PyInt_FromLong(CL_FLOATING_ENUM_VALUE);
if (x == NULL || PyDict_SetItemString(d, "FLOATING_ENUM_VALUE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FLOATING_RANGE_VALUE
x = PyInt_FromLong(CL_FLOATING_RANGE_VALUE);
if (x == NULL || PyDict_SetItemString(d, "FLOATING_RANGE_VALUE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT
x = PyInt_FromLong(CL_FORMAT);
if (x == NULL || PyDict_SetItemString(d, "FORMAT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_ABGR
x = PyInt_FromLong(CL_FORMAT_ABGR);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_ABGR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_BGR
x = PyInt_FromLong(CL_FORMAT_BGR);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_BGR233
x = PyInt_FromLong(CL_FORMAT_BGR233);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR233", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_GRAYSCALE
x = PyInt_FromLong(CL_FORMAT_GRAYSCALE);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_GRAYSCALE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_MONO
x = PyInt_FromLong(CL_FORMAT_MONO);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_MONO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_RBG323
x = PyInt_FromLong(CL_FORMAT_RBG323);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_RBG323", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_STEREO_INTERLEAVED
x = PyInt_FromLong(CL_FORMAT_STEREO_INTERLEAVED);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_STEREO_INTERLEAVED", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_XBGR
x = PyInt_FromLong(CL_FORMAT_XBGR);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_XBGR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_YCbCr
x = PyInt_FromLong(CL_FORMAT_YCbCr);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_YCbCr422
x = PyInt_FromLong(CL_FORMAT_YCbCr422);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FORMAT_YCbCr422DC
x = PyInt_FromLong(CL_FORMAT_YCbCr422DC);
if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422DC", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAME
x = PyInt_FromLong(CL_FRAME);
if (x == NULL || PyDict_SetItemString(d, "FRAME", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAMES_PER_CHUNK
x = PyInt_FromLong(CL_FRAMES_PER_CHUNK);
if (x == NULL || PyDict_SetItemString(d, "FRAMES_PER_CHUNK", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAME_BUFFER_SIZE
x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE);
if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAME_BUFFER_SIZE_ZERO
x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE_ZERO);
if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE_ZERO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAME_INDEX
x = PyInt_FromLong(CL_FRAME_INDEX);
if (x == NULL || PyDict_SetItemString(d, "FRAME_INDEX", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAME_RATE
x = PyInt_FromLong(CL_FRAME_RATE);
if (x == NULL || PyDict_SetItemString(d, "FRAME_RATE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAME_SIZE
x = PyInt_FromLong(CL_FRAME_SIZE);
if (x == NULL || PyDict_SetItemString(d, "FRAME_SIZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_FRAME_TYPE
x = PyInt_FromLong(CL_FRAME_TYPE);
if (x == NULL || PyDict_SetItemString(d, "FRAME_TYPE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_G711_ALAW
x = PyInt_FromLong(CL_G711_ALAW);
if (x == NULL || PyDict_SetItemString(d, "G711_ALAW", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_G711_ALAW_SOFTWARE
x = PyInt_FromLong(CL_G711_ALAW_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "G711_ALAW_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_G711_ULAW
x = PyInt_FromLong(CL_G711_ULAW);
if (x == NULL || PyDict_SetItemString(d, "G711_ULAW", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_G711_ULAW_SOFTWARE
x = PyInt_FromLong(CL_G711_ULAW_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "G711_ULAW_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_GRAYSCALE
x = PyInt_FromLong(CL_GRAYSCALE);
if (x == NULL || PyDict_SetItemString(d, "GRAYSCALE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_HDCC
x = PyInt_FromLong(CL_HDCC);
if (x == NULL || PyDict_SetItemString(d, "HDCC", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_HDCC_SAMPLES_PER_TILE
x = PyInt_FromLong(CL_HDCC_SAMPLES_PER_TILE);
if (x == NULL || PyDict_SetItemString(d, "HDCC_SAMPLES_PER_TILE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_HDCC_SOFTWARE
x = PyInt_FromLong(CL_HDCC_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "HDCC_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_HDCC_TILE_THRESHOLD
x = PyInt_FromLong(CL_HDCC_TILE_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "HDCC_TILE_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_HEADER_START_CODE
x = PyInt_FromLong(CL_HEADER_START_CODE);
if (x == NULL || PyDict_SetItemString(d, "HEADER_START_CODE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMAGEINFO_FIELDMASK
x = PyInt_FromLong(CL_IMAGEINFO_FIELDMASK);
if (x == NULL || PyDict_SetItemString(d, "IMAGEINFO_FIELDMASK", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMAGE_CROP_BOTTOM
x = PyInt_FromLong(CL_IMAGE_CROP_BOTTOM);
if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_BOTTOM", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMAGE_CROP_LEFT
x = PyInt_FromLong(CL_IMAGE_CROP_LEFT);
if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_LEFT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMAGE_CROP_RIGHT
x = PyInt_FromLong(CL_IMAGE_CROP_RIGHT);
if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_RIGHT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMAGE_CROP_TOP
x = PyInt_FromLong(CL_IMAGE_CROP_TOP);
if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_TOP", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMAGE_HEIGHT
x = PyInt_FromLong(CL_IMAGE_HEIGHT);
if (x == NULL || PyDict_SetItemString(d, "IMAGE_HEIGHT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMAGE_WIDTH
x = PyInt_FromLong(CL_IMAGE_WIDTH);
if (x == NULL || PyDict_SetItemString(d, "IMAGE_WIDTH", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMPACT_CODEC_CONTROL
x = PyInt_FromLong(CL_IMPACT_CODEC_CONTROL);
if (x == NULL || PyDict_SetItemString(d, "IMPACT_CODEC_CONTROL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMPACT_FRAME_INTERLEAVE
x = PyInt_FromLong(CL_IMPACT_FRAME_INTERLEAVE);
if (x == NULL || PyDict_SetItemString(d, "IMPACT_FRAME_INTERLEAVE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_IMPACT_NUM_PARAMS
x = PyInt_FromLong(CL_IMPACT_NUM_PARAMS);
if (x == NULL || PyDict_SetItemString(d, "IMPACT_NUM_PARAMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_INTERNAL_FORMAT
x = PyInt_FromLong(CL_INTERNAL_FORMAT);
if (x == NULL || PyDict_SetItemString(d, "INTERNAL_FORMAT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_INTERNAL_IMAGE_HEIGHT
x = PyInt_FromLong(CL_INTERNAL_IMAGE_HEIGHT);
if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_HEIGHT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_INTERNAL_IMAGE_WIDTH
x = PyInt_FromLong(CL_INTERNAL_IMAGE_WIDTH);
if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_WIDTH", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_INTRA
x = PyInt_FromLong(CL_INTRA);
if (x == NULL || PyDict_SetItemString(d, "INTRA", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG
x = PyInt_FromLong(CL_JPEG);
if (x == NULL || PyDict_SetItemString(d, "JPEG", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_COSMO
x = PyInt_FromLong(CL_JPEG_COSMO);
if (x == NULL || PyDict_SetItemString(d, "JPEG_COSMO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_ERROR
x = PyInt_FromLong(CL_JPEG_ERROR);
if (x == NULL || PyDict_SetItemString(d, "JPEG_ERROR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_IMPACT
x = PyInt_FromLong(CL_JPEG_IMPACT);
if (x == NULL || PyDict_SetItemString(d, "JPEG_IMPACT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_NUM_PARAMS
x = PyInt_FromLong(CL_JPEG_NUM_PARAMS);
if (x == NULL || PyDict_SetItemString(d, "JPEG_NUM_PARAMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_QUALITY_FACTOR
x = PyInt_FromLong(CL_JPEG_QUALITY_FACTOR);
if (x == NULL || PyDict_SetItemString(d, "JPEG_QUALITY_FACTOR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_QUANTIZATION_TABLES
x = PyInt_FromLong(CL_JPEG_QUANTIZATION_TABLES);
if (x == NULL || PyDict_SetItemString(d, "JPEG_QUANTIZATION_TABLES", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_SOFTWARE
x = PyInt_FromLong(CL_JPEG_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "JPEG_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_JPEG_STREAM_HEADERS
x = PyInt_FromLong(CL_JPEG_STREAM_HEADERS);
if (x == NULL || PyDict_SetItemString(d, "JPEG_STREAM_HEADERS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_KEYFRAME
x = PyInt_FromLong(CL_KEYFRAME);
if (x == NULL || PyDict_SetItemString(d, "KEYFRAME", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_KEYFRAME_DISTANCE
x = PyInt_FromLong(CL_KEYFRAME_DISTANCE);
if (x == NULL || PyDict_SetItemString(d, "KEYFRAME_DISTANCE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_LAST_FRAME_INDEX
x = PyInt_FromLong(CL_LAST_FRAME_INDEX);
if (x == NULL || PyDict_SetItemString(d, "LAST_FRAME_INDEX", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_LAYER
x = PyInt_FromLong(CL_LAYER);
if (x == NULL || PyDict_SetItemString(d, "LAYER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_LUMA_THRESHOLD
x = PyInt_FromLong(CL_LUMA_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "LUMA_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS
x = PyInt_FromLong(CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS);
if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_AUDIO_ALGORITHMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MAX_NUMBER_OF_FORMATS
x = PyInt_FromLong(CL_MAX_NUMBER_OF_FORMATS);
if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_FORMATS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MAX_NUMBER_OF_ORIGINAL_FORMATS
x = PyInt_FromLong(CL_MAX_NUMBER_OF_ORIGINAL_FORMATS);
if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_ORIGINAL_FORMATS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MAX_NUMBER_OF_PARAMS
x = PyInt_FromLong(CL_MAX_NUMBER_OF_PARAMS);
if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_PARAMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS
x = PyInt_FromLong(CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS);
if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_VIDEO_ALGORITHMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MONO
x = PyInt_FromLong(CL_MONO);
if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_AWARE
x = PyInt_FromLong(CL_MPEG1_AUDIO_AWARE);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_AWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_LAYER
x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_LAYER_I
x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_I);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_I", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_LAYER_II
x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_II);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_II", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_MODE
x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_MODE_DUAL
x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_DUAL);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_DUAL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_MODE_JOINT
x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_JOINT);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_JOINT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_MODE_SINGLE
x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_SINGLE);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_SINGLE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_MODE_STEREO
x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_STEREO);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_STEREO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_AUDIO_SOFTWARE
x = PyInt_FromLong(CL_MPEG1_AUDIO_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_END_OF_STREAM
x = PyInt_FromLong(CL_MPEG1_END_OF_STREAM);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_END_OF_STREAM", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_ERROR
x = PyInt_FromLong(CL_MPEG1_ERROR);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_ERROR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_NUM_PARAMS
x = PyInt_FromLong(CL_MPEG1_NUM_PARAMS);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_NUM_PARAMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_M
x = PyInt_FromLong(CL_MPEG1_VIDEO_M);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_M", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X
x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y
x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X
x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y
x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_N
x = PyInt_FromLong(CL_MPEG1_VIDEO_N);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_N", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_SOFTNESS
x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM
x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MAXIMUM", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_SOFTNESS_MEDIUM
x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MEDIUM);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MEDIUM", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_SOFTNESS_NONE
x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_NONE);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_NONE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG1_VIDEO_SOFTWARE
x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MPEG_VIDEO
x = PyInt_FromLong(CL_MPEG_VIDEO);
if (x == NULL || PyDict_SetItemString(d, "MPEG_VIDEO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MULTIRATE_AWARE
x = PyInt_FromLong(CL_MULTIRATE_AWARE);
if (x == NULL || PyDict_SetItemString(d, "MULTIRATE_AWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC1
x = PyInt_FromLong(CL_MVC1);
if (x == NULL || PyDict_SetItemString(d, "MVC1", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC1_SOFTWARE
x = PyInt_FromLong(CL_MVC1_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "MVC1_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2
x = PyInt_FromLong(CL_MVC2);
if (x == NULL || PyDict_SetItemString(d, "MVC2", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_BLENDING
x = PyInt_FromLong(CL_MVC2_BLENDING);
if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_BLENDING_OFF
x = PyInt_FromLong(CL_MVC2_BLENDING_OFF);
if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_OFF", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_BLENDING_ON
x = PyInt_FromLong(CL_MVC2_BLENDING_ON);
if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_ON", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_CHROMA_THRESHOLD
x = PyInt_FromLong(CL_MVC2_CHROMA_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "MVC2_CHROMA_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_EDGE_THRESHOLD
x = PyInt_FromLong(CL_MVC2_EDGE_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "MVC2_EDGE_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_ERROR
x = PyInt_FromLong(CL_MVC2_ERROR);
if (x == NULL || PyDict_SetItemString(d, "MVC2_ERROR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_LUMA_THRESHOLD
x = PyInt_FromLong(CL_MVC2_LUMA_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "MVC2_LUMA_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC2_SOFTWARE
x = PyInt_FromLong(CL_MVC2_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "MVC2_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC3_QUALITY_LEVEL
x = PyInt_FromLong(CL_MVC3_QUALITY_LEVEL);
if (x == NULL || PyDict_SetItemString(d, "MVC3_QUALITY_LEVEL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_MVC3_SOFTWARE
x = PyInt_FromLong(CL_MVC3_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "MVC3_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NEXT_NOT_AVAILABLE
x = PyInt_FromLong(CL_NEXT_NOT_AVAILABLE);
if (x == NULL || PyDict_SetItemString(d, "NEXT_NOT_AVAILABLE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NOISE_MARGIN
x = PyInt_FromLong(CL_NOISE_MARGIN);
if (x == NULL || PyDict_SetItemString(d, "NOISE_MARGIN", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NONE
x = PyInt_FromLong(CL_NONE);
if (x == NULL || PyDict_SetItemString(d, "NONE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NUMBER_OF_FORMATS
x = PyInt_FromLong(CL_NUMBER_OF_FORMATS);
if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FORMATS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NUMBER_OF_FRAMES
x = PyInt_FromLong(CL_NUMBER_OF_FRAMES);
if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FRAMES", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NUMBER_OF_PARAMS
x = PyInt_FromLong(CL_NUMBER_OF_PARAMS);
if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NUMBER_OF_PARAMS_FREEZE
x = PyInt_FromLong(CL_NUMBER_OF_PARAMS_FREEZE);
if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS_FREEZE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_NUMBER_OF_VIDEO_FORMATS
x = PyInt_FromLong(CL_NUMBER_OF_VIDEO_FORMATS);
if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_VIDEO_FORMATS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ORIENTATION
x = PyInt_FromLong(CL_ORIENTATION);
if (x == NULL || PyDict_SetItemString(d, "ORIENTATION", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ORIGINAL_FORMAT
x = PyInt_FromLong(CL_ORIGINAL_FORMAT);
if (x == NULL || PyDict_SetItemString(d, "ORIGINAL_FORMAT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_PARAM_OUT_OF_RANGE
x = PyInt_FromLong(CL_PARAM_OUT_OF_RANGE);
if (x == NULL || PyDict_SetItemString(d, "PARAM_OUT_OF_RANGE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_PIXEL_ASPECT
x = PyInt_FromLong(CL_PIXEL_ASPECT);
if (x == NULL || PyDict_SetItemString(d, "PIXEL_ASPECT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_PREDICTED
x = PyInt_FromLong(CL_PREDICTED);
if (x == NULL || PyDict_SetItemString(d, "PREDICTED", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_PREROLL
x = PyInt_FromLong(CL_PREROLL);
if (x == NULL || PyDict_SetItemString(d, "PREROLL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_QUALITY_FACTOR
x = PyInt_FromLong(CL_QUALITY_FACTOR);
if (x == NULL || PyDict_SetItemString(d, "QUALITY_FACTOR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_QUALITY_LEVEL
x = PyInt_FromLong(CL_QUALITY_LEVEL);
if (x == NULL || PyDict_SetItemString(d, "QUALITY_LEVEL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_QUALITY_SPATIAL
x = PyInt_FromLong(CL_QUALITY_SPATIAL);
if (x == NULL || PyDict_SetItemString(d, "QUALITY_SPATIAL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_QUALITY_TEMPORAL
x = PyInt_FromLong(CL_QUALITY_TEMPORAL);
if (x == NULL || PyDict_SetItemString(d, "QUALITY_TEMPORAL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_QUANTIZATION_TABLES
x = PyInt_FromLong(CL_QUANTIZATION_TABLES);
if (x == NULL || PyDict_SetItemString(d, "QUANTIZATION_TABLES", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RANGE_VALUE
x = PyInt_FromLong(CL_RANGE_VALUE);
if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RGB
x = PyInt_FromLong(CL_RGB);
if (x == NULL || PyDict_SetItemString(d, "RGB", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RGB332
x = PyInt_FromLong(CL_RGB332);
if (x == NULL || PyDict_SetItemString(d, "RGB332", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RGB8
x = PyInt_FromLong(CL_RGB8);
if (x == NULL || PyDict_SetItemString(d, "RGB8", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RGBA
x = PyInt_FromLong(CL_RGBA);
if (x == NULL || PyDict_SetItemString(d, "RGBA", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RGBX
x = PyInt_FromLong(CL_RGBX);
if (x == NULL || PyDict_SetItemString(d, "RGBX", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RLE
x = PyInt_FromLong(CL_RLE);
if (x == NULL || PyDict_SetItemString(d, "RLE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RLE24
x = PyInt_FromLong(CL_RLE24);
if (x == NULL || PyDict_SetItemString(d, "RLE24", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RLE24_SOFTWARE
x = PyInt_FromLong(CL_RLE24_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "RLE24_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RLE_SOFTWARE
x = PyInt_FromLong(CL_RLE_SOFTWARE);
if (x == NULL || PyDict_SetItemString(d, "RLE_SOFTWARE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RTR
x = PyInt_FromLong(CL_RTR);
if (x == NULL || PyDict_SetItemString(d, "RTR", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RTR1
x = PyInt_FromLong(CL_RTR1);
if (x == NULL || PyDict_SetItemString(d, "RTR1", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_RTR_QUALITY_LEVEL
x = PyInt_FromLong(CL_RTR_QUALITY_LEVEL);
if (x == NULL || PyDict_SetItemString(d, "RTR_QUALITY_LEVEL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_SAMPLES_PER_TILE
x = PyInt_FromLong(CL_SAMPLES_PER_TILE);
if (x == NULL || PyDict_SetItemString(d, "SAMPLES_PER_TILE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_SCHEME_BUSY
x = PyInt_FromLong(CL_SCHEME_BUSY);
if (x == NULL || PyDict_SetItemString(d, "SCHEME_BUSY", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_SCHEME_NOT_AVAILABLE
x = PyInt_FromLong(CL_SCHEME_NOT_AVAILABLE);
if (x == NULL || PyDict_SetItemString(d, "SCHEME_NOT_AVAILABLE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_SPEED
x = PyInt_FromLong(CL_SPEED);
if (x == NULL || PyDict_SetItemString(d, "SPEED", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_STEREO_INTERLEAVED
x = PyInt_FromLong(CL_STEREO_INTERLEAVED);
if (x == NULL || PyDict_SetItemString(d, "STEREO_INTERLEAVED", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_STREAM_HEADERS
x = PyInt_FromLong(CL_STREAM_HEADERS);
if (x == NULL || PyDict_SetItemString(d, "STREAM_HEADERS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_TILE_THRESHOLD
x = PyInt_FromLong(CL_TILE_THRESHOLD);
if (x == NULL || PyDict_SetItemString(d, "TILE_THRESHOLD", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_TOP_DOWN
x = PyInt_FromLong(CL_TOP_DOWN);
if (x == NULL || PyDict_SetItemString(d, "TOP_DOWN", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_ULAW
x = PyInt_FromLong(CL_ULAW);
if (x == NULL || PyDict_SetItemString(d, "ULAW", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_UNCOMPRESSED
x = PyInt_FromLong(CL_UNCOMPRESSED);
if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_UNCOMPRESSED_AUDIO
x = PyInt_FromLong(CL_UNCOMPRESSED_AUDIO);
if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_AUDIO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_UNCOMPRESSED_VIDEO
x = PyInt_FromLong(CL_UNCOMPRESSED_VIDEO);
if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_VIDEO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_UNKNOWN_SCHEME
x = PyInt_FromLong(CL_UNKNOWN_SCHEME);
if (x == NULL || PyDict_SetItemString(d, "UNKNOWN_SCHEME", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_VIDEO
x = PyInt_FromLong(CL_VIDEO);
if (x == NULL || PyDict_SetItemString(d, "VIDEO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_Y
x = PyInt_FromLong(CL_Y);
if (x == NULL || PyDict_SetItemString(d, "Y", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YCbCr
x = PyInt_FromLong(CL_YCbCr);
if (x == NULL || PyDict_SetItemString(d, "YCbCr", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YCbCr422
x = PyInt_FromLong(CL_YCbCr422);
if (x == NULL || PyDict_SetItemString(d, "YCbCr422", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YCbCr422DC
x = PyInt_FromLong(CL_YCbCr422DC);
if (x == NULL || PyDict_SetItemString(d, "YCbCr422DC", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YCbCr422HC
x = PyInt_FromLong(CL_YCbCr422HC);
if (x == NULL || PyDict_SetItemString(d, "YCbCr422HC", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YUV
x = PyInt_FromLong(CL_YUV);
if (x == NULL || PyDict_SetItemString(d, "YUV", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YUV422
x = PyInt_FromLong(CL_YUV422);
if (x == NULL || PyDict_SetItemString(d, "YUV422", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YUV422DC
x = PyInt_FromLong(CL_YUV422DC);
if (x == NULL || PyDict_SetItemString(d, "YUV422DC", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef CL_YUV422HC
x = PyInt_FromLong(CL_YUV422HC);
if (x == NULL || PyDict_SetItemString(d, "YUV422HC", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_STEREO
x = PyInt_FromLong(AWCMP_STEREO);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_STEREO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_JOINT_STEREO
x = PyInt_FromLong(AWCMP_JOINT_STEREO);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_JOINT_STEREO", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_INDEPENDENT
x = PyInt_FromLong(AWCMP_INDEPENDENT);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_INDEPENDENT", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_FIXED_RATE
x = PyInt_FromLong(AWCMP_FIXED_RATE);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_FIXED_RATE", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_CONST_QUAL
x = PyInt_FromLong(AWCMP_CONST_QUAL);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_CONST_QUAL", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_LOSSLESS
x = PyInt_FromLong(AWCMP_LOSSLESS);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_LOSSLESS", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_MPEG_LAYER_I
x = PyInt_FromLong(AWCMP_MPEG_LAYER_I);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_I", x) < 0)
return;
Py_DECREF(x);
#endif
#ifdef AWCMP_MPEG_LAYER_II
x = PyInt_FromLong(AWCMP_MPEG_LAYER_II);
if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_II", x) < 0)
return;
Py_DECREF(x);
#endif
(void) clSetErrorHandler(cl_ErrorHandler);
}