clmodule.c

/* Cl objects */

#defineCLDEBUG

#include<stdarg.h>
#include<cl.h>
#if defined(CL_JPEG_SOFTWARE) && !defined(CL_JPEG_COSMO)
#include<dmedia/cl_cosmo.h>
#endif
#include"Python.h"

typedefstruct {
PyObject_HEAD
intob_isCompressor; /* Compressor or Decompressor */
CL_Handleob_compressorHdl;
int*ob_paramtypes;
intob_nparams;
} clobject;

staticPyObject*ClError; /* exception cl.error */

staticinterror_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.
 */
#defineSELF ((clobject *) self)

/********************************************************************
 Utility routines.
********************************************************************/
staticvoid
cl_ErrorHandler(CL_Handlehandle, intcode, constchar*fmt, ...)
{
va_listap;
charerrbuf[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.
 */
staticint
param_type_is_float(clobject*self, intparam)
{
intbufferlength;

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)
return1;
else
return0;
}

/********************************************************************
 Single image compression/decompression.
********************************************************************/
staticPyObject*
cl_CompressImage(PyObject*self, PyObject*args)
{
intcompressionScheme, width, height, originalFormat;
floatcompressionRatio;
intframeBufferSize, compressedBufferSize;
char*frameBuffer;
PyObject*compressedBuffer;

if (!PyArg_ParseTuple(args, "iiiifs#", &compressionScheme,
&width, &height,
&originalFormat, &compressionRatio, &frameBuffer,
&frameBufferSize))
returnNULL;

retry:
compressedBuffer=PyString_FromStringAndSize(NULL, frameBufferSize);
if (compressedBuffer==NULL)
returnNULL;

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");
returnNULL;
 }

if (compressedBufferSize>frameBufferSize) {
frameBufferSize=compressedBufferSize;
Py_DECREF(compressedBuffer);
 goto retry;
 }

if (compressedBufferSize<frameBufferSize)
_PyString_Resize(&compressedBuffer, compressedBufferSize);

returncompressedBuffer;
}

staticPyObject*
cl_DecompressImage(PyObject*self, PyObject*args)
{
intcompressionScheme, width, height, originalFormat;
char*compressedBuffer;
intcompressedBufferSize, frameBufferSize;
PyObject*frameBuffer;

if (!PyArg_ParseTuple(args, "iiiis#", &compressionScheme, &width, &height,
&originalFormat, &compressedBuffer,
&compressedBufferSize))
returnNULL;

frameBufferSize=width*height*CL_BytesPerPixel(originalFormat);

frameBuffer=PyString_FromStringAndSize(NULL, frameBufferSize);
if (frameBuffer==NULL)
returnNULL;

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");
returnNULL;
 }

returnframeBuffer;
}

/********************************************************************
 Sequential compression/decompression.
********************************************************************/
#defineCheckCompressor(self) if ((self)->ob_compressorHdl == NULL) { \
 PyErr_SetString(PyExc_RuntimeError, "(de)compressor not active"); \
 return NULL; \
}

staticPyObject*
doClose(clobject*self, int (*close_func)(CL_Handle))
{
CheckCompressor(self);

error_handler_called=0;
if ((*close_func)(self->ob_compressorHdl) ==FAILURE||
error_handler_called) {
if (!error_handler_called)
PyErr_SetString(ClError, "close failed");
returnNULL;
 }

self->ob_compressorHdl=NULL;

if (self->ob_paramtypes)
PyMem_DEL(self->ob_paramtypes);
self->ob_paramtypes=NULL;

Py_INCREF(Py_None);
returnPy_None;
}

staticPyObject*
clm_CloseCompressor(PyObject*self)
{
returndoClose(SELF, clCloseCompressor);
}

staticPyObject*
clm_CloseDecompressor(PyObject*self)
{
returndoClose(SELF, clCloseDecompressor);
}

staticPyObject*
clm_Compress(PyObject*self, PyObject*args)
{
intnumberOfFrames;
intframeBufferSize, compressedBufferSize, size;
char*frameBuffer;
PyObject*data;

CheckCompressor(SELF);

if (!PyArg_Parse(args, "(is#)", &numberOfFrames,
&frameBuffer, &frameBufferSize))
returnNULL;

error_handler_called=0;
size=clGetParam(SELF->ob_compressorHdl, CL_COMPRESSED_BUFFER_SIZE);
compressedBufferSize=size;
if (error_handler_called)
returnNULL;

data=PyString_FromStringAndSize(NULL, size);
if (data==NULL)
returnNULL;

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");
returnNULL;
 }

if (compressedBufferSize<size)
if (_PyString_Resize(&data, compressedBufferSize))
returnNULL;

if (compressedBufferSize>size) {
/* we didn't get all "compressed" data */
Py_DECREF(data);
PyErr_SetString(ClError,
"compressed data is more than fitted");
returnNULL;
 }

returndata;
}

staticPyObject*
clm_Decompress(PyObject*self, PyObject*args)
{
PyObject*data;
intnumberOfFrames;
char*compressedData;
intcompressedDataSize, dataSize;

CheckCompressor(SELF);

if (!PyArg_Parse(args, "(is#)", &numberOfFrames, &compressedData,
&compressedDataSize))
returnNULL;

error_handler_called=0;
dataSize=clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE);
if (error_handler_called)
returnNULL;

data=PyString_FromStringAndSize(NULL, dataSize);
if (data==NULL)
returnNULL;

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");
returnNULL;
 }

returndata;
}

staticPyObject*
doParams(clobject*self, PyObject*args, int (*func)(CL_Handle, int*, int),
intmodified)
{
PyObject*list, *v;
int*PVbuffer;
intlength;
inti;
floatnumber;

CheckCompressor(self);

if (!PyArg_Parse(args, "O", &list))
returnNULL;
if (!PyList_Check(list)) {
PyErr_BadArgument();
returnNULL;
 }
length=PyList_Size(list);
PVbuffer=PyMem_NEW(int, length);
if (PVbuffer==NULL)
returnPyErr_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);
 } elseif (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();
returnNULL;
 }
 }

error_handler_called=0;
 (*func)(self->ob_compressorHdl, PVbuffer, length);
if (error_handler_called) {
PyMem_DEL(PVbuffer);
returnNULL;
 }

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);
returnPy_None;
}

staticPyObject*
clm_GetParams(PyObject*self, PyObject*args)
{
returndoParams(SELF, args, clGetParams, 1);
}

staticPyObject*
clm_SetParams(PyObject*self, PyObject*args)
{
returndoParams(SELF, args, clSetParams, 0);
}

staticPyObject*
do_get(clobject*self, PyObject*args, int (*func)(CL_Handle, int))
{
intparamID, value;
floatfvalue;

CheckCompressor(self);

if (!PyArg_Parse(args, "i", &paramID))
returnNULL;

error_handler_called=0;
value= (*func)(self->ob_compressorHdl, paramID);
if (error_handler_called)
returnNULL;

if (param_type_is_float(self, paramID) >0) {
fvalue=CL_TypeIsFloat(value);
returnPyFloat_FromDouble(fvalue);
 }

returnPyInt_FromLong(value);
}

staticPyObject*
clm_GetParam(PyObject*self, PyObject*args)
{
returndo_get(SELF, args, clGetParam);
}

staticPyObject*
clm_GetDefault(PyObject*self, PyObject*args)
{
returndo_get(SELF, args, clGetDefault);
}

staticPyObject*
clm_SetParam(PyObject*self, PyObject*args)
{
intparamID, value;
floatfvalue;

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)')");
returnNULL;
 }
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)
returnNULL;

if (param_type_is_float(SELF, paramID) >0)
returnPyFloat_FromDouble(CL_TypeIsFloat(value));
else
returnPyInt_FromLong(value);
}

staticPyObject*
clm_GetParamID(PyObject*self, PyObject*args)
{
char*name;
intvalue;

CheckCompressor(SELF);

if (!PyArg_Parse(args, "s", &name))
returnNULL;

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");
returnNULL;
 }

returnPyInt_FromLong(value);
}

staticPyObject*
clm_QueryParams(PyObject*self)
{
intbufferlength;
int*PVbuffer;
PyObject*list;
inti;

CheckCompressor(SELF);

error_handler_called=0;
bufferlength=clQueryParams(SELF->ob_compressorHdl, 0, 0);
if (error_handler_called)
returnNULL;

PVbuffer=PyMem_NEW(int, bufferlength);
if (PVbuffer==NULL)
returnPyErr_NoMemory();

bufferlength=clQueryParams(SELF->ob_compressorHdl, PVbuffer,
bufferlength);
if (error_handler_called) {
PyMem_DEL(PVbuffer);
returnNULL;
 }

list=PyList_New(bufferlength);
if (list==NULL) {
PyMem_DEL(PVbuffer);
returnNULL;
 }

for (i=0; i<bufferlength; i++) {
if (i&1)
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
elseif (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);

returnlist;
}

staticPyObject*
clm_GetMinMax(PyObject*self, PyObject*args)
{
intparam, min, max;
floatfmin, fmax;

CheckCompressor(SELF);

if (!PyArg_Parse(args, "i", &param))
returnNULL;

clGetMinMax(SELF->ob_compressorHdl, param, &min, &max);

if (param_type_is_float(SELF, param) >0) {
fmin=CL_TypeIsFloat(min);
fmax=CL_TypeIsFloat(max);
returnPy_BuildValue("(ff)", fmin, fmax);
 }

returnPy_BuildValue("(ii)", min, max);
}

staticPyObject*
clm_GetName(PyObject*self, PyObject*args)
{
intparam;
char*name;

CheckCompressor(SELF);

if (!PyArg_Parse(args, "i", &param))
returnNULL;

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");
returnNULL;
 }

returnPyString_FromString(name);
}

staticPyObject*
clm_QuerySchemeFromHandle(PyObject*self)
{
CheckCompressor(SELF);
returnPyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
}

staticPyObject*
clm_ReadHeader(PyObject*self, PyObject*args)
{
char*header;
intheaderSize;

CheckCompressor(SELF);

if (!PyArg_Parse(args, "s#", &header, &headerSize))
returnNULL;

returnPyInt_FromLong(clReadHeader(SELF->ob_compressorHdl,
headerSize, header));
}

staticPyMethodDefcompressor_methods[] = {
 {"close", clm_CloseCompressor, METH_NOARGS}, /* alias */
 {"CloseCompressor", clm_CloseCompressor, METH_NOARGS},
 {"Compress", clm_Compress, METH_OLDARGS},
 {"GetDefault", clm_GetDefault, METH_OLDARGS},
 {"GetMinMax", clm_GetMinMax, METH_OLDARGS},
 {"GetName", clm_GetName, METH_OLDARGS},
 {"GetParam", clm_GetParam, METH_OLDARGS},
 {"GetParamID", clm_GetParamID, METH_OLDARGS},
 {"GetParams", clm_GetParams, METH_OLDARGS},
 {"QueryParams", clm_QueryParams, METH_NOARGS},
 {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS},
 {"SetParam", clm_SetParam, METH_OLDARGS},
 {"SetParams", clm_SetParams, METH_OLDARGS},
 {NULL, NULL} /* sentinel */
};

staticPyMethodDefdecompressor_methods[] = {
 {"close", clm_CloseDecompressor, METH_NOARGS}, /* alias */
 {"CloseDecompressor", clm_CloseDecompressor, METH_NOARGS},
 {"Decompress", clm_Decompress, METH_OLDARGS},
 {"GetDefault", clm_GetDefault, METH_OLDARGS},
 {"GetMinMax", clm_GetMinMax, METH_OLDARGS},
 {"GetName", clm_GetName, METH_OLDARGS},
 {"GetParam", clm_GetParam, METH_OLDARGS},
 {"GetParamID", clm_GetParamID, METH_OLDARGS},
 {"GetParams", clm_GetParams, METH_OLDARGS},
 {"ReadHeader", clm_ReadHeader, METH_OLDARGS},
 {"QueryParams", clm_QueryParams, METH_NOARGS},
 {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS},
 {"SetParam", clm_SetParam, METH_OLDARGS},
 {"SetParams", clm_SetParams, METH_OLDARGS},
 {NULL, NULL} /* sentinel */
};

staticvoid
cl_dealloc(PyObject*self)
{
if (SELF->ob_compressorHdl) {
if (SELF->ob_isCompressor)
clCloseCompressor(SELF->ob_compressorHdl);
else
clCloseDecompressor(SELF->ob_compressorHdl);
 }
PyObject_Del(self);
}

staticPyObject*
cl_getattr(PyObject*self, char*name)
{
if (SELF->ob_isCompressor)
returnPy_FindMethod(compressor_methods, self, name);
else
returnPy_FindMethod(decompressor_methods, self, name);
}

staticPyTypeObjectCltype= {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"cl.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*/
};

staticPyObject*
doOpen(PyObject*self, PyObject*args, int (*open_func)(int, CL_Handle*),
intiscompressor)
{
intscheme;
clobject*new;

if (!PyArg_ParseTuple(args, "i", &scheme))
returnNULL;

new=PyObject_New(clobject, &Cltype);
if (new==NULL)
returnNULL;

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");
returnNULL;
 }
return (PyObject*)new;
}

staticPyObject*
cl_OpenCompressor(PyObject*self, PyObject*args)
{
returndoOpen(self, args, clOpenCompressor, 1);
}

staticPyObject*
cl_OpenDecompressor(PyObject*self, PyObject*args)
{
returndoOpen(self, args, clOpenDecompressor, 0);
}

staticPyObject*
cl_QueryScheme(PyObject*self, PyObject*args)
{
char*header;
intheaderlen;
intscheme;

if (!PyArg_ParseTuple(args, "s#", &header, &headerlen))
returnNULL;

scheme=clQueryScheme(header);
if (scheme<0) {
PyErr_SetString(ClError, "unknown compression scheme");
returnNULL;
 }

returnPyInt_FromLong(scheme);
}

staticPyObject*
cl_QueryMaxHeaderSize(PyObject*self, PyObject*args)
{
intscheme;

if (!PyArg_ParseTuple(args, "i", &scheme))
returnNULL;

returnPyInt_FromLong(clQueryMaxHeaderSize(scheme));
}

staticPyObject*
cl_QueryAlgorithms(PyObject*self, PyObject*args)
{
intalgorithmMediaType;
intbufferlength;
int*PVbuffer;
PyObject*list;
inti;

if (!PyArg_ParseTuple(args, "i", &algorithmMediaType))
returnNULL;

error_handler_called=0;
bufferlength=clQueryAlgorithms(algorithmMediaType, 0, 0);
if (error_handler_called)
returnNULL;

PVbuffer=PyMem_NEW(int, bufferlength);
if (PVbuffer==NULL)
returnPyErr_NoMemory();

bufferlength=clQueryAlgorithms(algorithmMediaType, PVbuffer,
bufferlength);
if (error_handler_called) {
PyMem_DEL(PVbuffer);
returnNULL;
 }

list=PyList_New(bufferlength);
if (list==NULL) {
PyMem_DEL(PVbuffer);
returnNULL;
 }

for (i=0; i<bufferlength; i++) {
if (i&1)
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
elseif (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);

returnlist;
}

staticPyObject*
cl_QuerySchemeFromName(PyObject*self, PyObject*args)
{
intalgorithmMediaType;
char*name;
intscheme;

if (!PyArg_ParseTuple(args, "is", &algorithmMediaType, &name))
returnNULL;

error_handler_called=0;
scheme=clQuerySchemeFromName(algorithmMediaType, name);
if (error_handler_called) {
PyErr_SetString(ClError, "unknown compression scheme");
returnNULL;
 }

returnPyInt_FromLong(scheme);
}

staticPyObject*
cl_GetAlgorithmName(PyObject*self, PyObject*args)
{
intscheme;
char*name;

if (!PyArg_ParseTuple(args, "i", &scheme))
returnNULL;

name=clGetAlgorithmName(scheme);
if (name==0) {
PyErr_SetString(ClError, "unknown compression scheme");
returnNULL;
 }

returnPyString_FromString(name);
}

staticPyObject*
do_set(PyObject*self, PyObject*args, int (*func)(int, int, int))
{
intscheme, paramID, value;
floatfvalue;
intis_float=0;

if (!PyArg_ParseTuple(args, "iii", &scheme, &paramID, &value)) {
PyErr_Clear();
if (!PyArg_ParseTuple(args, "iif", &scheme, &paramID, &fvalue)) {
PyErr_Clear();
PyErr_SetString(PyExc_TypeError,
"bad argument list (format '(iii)' or '(iif)')");
returnNULL;
 }
value=CL_TypeIsInt(fvalue);
is_float=1;
 } else {
/* check some parameters which we know to be floats */
switch (scheme) {
caseCL_COMPRESSION_RATIO:
caseCL_SPEED:
fvalue=value;
value=CL_TypeIsInt(fvalue);
is_float=1;
break;
 }
 }

error_handler_called=0;
value= (*func)(scheme, paramID, value);
if (error_handler_called)
returnNULL;

if (is_float)
returnPyFloat_FromDouble(CL_TypeIsFloat(value));
else
returnPyInt_FromLong(value);
}

staticPyObject*
cl_SetDefault(PyObject*self, PyObject*args)
{
returndo_set(self, args, clSetDefault);
}

staticPyObject*
cl_SetMin(PyObject*self, PyObject*args)
{
returndo_set(self, args, clSetMin);
}

staticPyObject*
cl_SetMax(PyObject*self, PyObject*args)
{
returndo_set(self, args, clSetMax);
}

#definefunc(name, handler) \
static PyObject *cl_##name(PyObject *self, PyObject *args) \
{ \
 int x; \
 if (!PyArg_ParseTuple(args, "i", &x)) return NULL; \
 return Py##handler(CL_##name(x)); \
}

#definefunc2(name, handler) \
static PyObject *cl_##name(PyObject *self, PyObject *args) \
{ \
 int a1, a2; \
 if (!PyArg_ParseTuple(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)

#ifdefCLDEBUG
staticPyObject*
cvt_type(PyObject*self, PyObject*args)
{
intnumber;
floatfnumber;

if (PyArg_Parse(args, "i", &number))
returnPyFloat_FromDouble(CL_TypeIsFloat(number));
else {
PyErr_Clear();
if (PyArg_Parse(args, "f", &fnumber))
returnPyInt_FromLong(CL_TypeIsInt(fnumber));
returnNULL;
 }
}
#endif

staticPyMethodDefcl_methods[] = {
 {"CompressImage", cl_CompressImage, METH_VARARGS},
 {"DecompressImage", cl_DecompressImage, METH_VARARGS},
 {"GetAlgorithmName", cl_GetAlgorithmName, METH_VARARGS},
 {"OpenCompressor", cl_OpenCompressor, METH_VARARGS},
 {"OpenDecompressor", cl_OpenDecompressor, METH_VARARGS},
 {"QueryAlgorithms", cl_QueryAlgorithms, METH_VARARGS},
 {"QueryMaxHeaderSize", cl_QueryMaxHeaderSize, METH_VARARGS},
 {"QueryScheme", cl_QueryScheme, METH_VARARGS},
 {"QuerySchemeFromName", cl_QuerySchemeFromName, METH_VARARGS},
 {"SetDefault", cl_SetDefault, METH_VARARGS},
 {"SetMax", cl_SetMax, METH_VARARGS},
 {"SetMin", cl_SetMin, METH_VARARGS},
 {"BytesPerSample", cl_BytesPerSample, METH_VARARGS},
 {"BytesPerPixel", cl_BytesPerPixel, METH_VARARGS},
 {"AudioFormatName", cl_AudioFormatName, METH_VARARGS},
 {"VideoFormatName", cl_VideoFormatName, METH_VARARGS},
 {"AlgorithmNumber", cl_AlgorithmNumber, METH_VARARGS},
 {"AlgorithmType", cl_AlgorithmType, METH_VARARGS},
 {"Algorithm", cl_Algorithm, METH_VARARGS},
 {"ParamNumber", cl_ParamNumber, METH_VARARGS},
 {"ParamType", cl_ParamType, METH_VARARGS},
 {"ParamID", cl_ParamID, METH_VARARGS},
#ifdefCLDEBUG
 {"cvt_type", cvt_type, METH_VARARGS},
#endif
 {NULL, NULL} /* Sentinel */
};

#ifdefCL_JPEG_SOFTWARE
#defineIRIX_5_3_LIBRARY
#endif

void
initcl(void)
{
PyObject*m, *d, *x;

if (PyErr_WarnPy3k("the cl module has been removed in "
"Python 3.0", 2) <0)
return;

m=Py_InitModule("cl", cl_methods);
if (m==NULL)
return;
d=PyModule_GetDict(m);

ClError=PyErr_NewException("cl.error", NULL, NULL);
 (void) PyDict_SetItemString(d, "error", ClError);

#ifdefCL_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
#ifdefCL_ALAW
x=PyInt_FromLong(CL_ALAW);
if (x==NULL||PyDict_SetItemString(d, "ALAW", x) <0)
return;
Py_DECREF(x);
#endif
#ifdefCL_ALGORITHM_ID
x=PyInt_FromLong(CL_ALGORITHM_ID);
if (x==NULL||PyDict_SetItemString(d, "ALGORITHM_ID", x) <0)
return;
Py_DECREF(x);
#endif
#ifdefCL_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