diff options
Diffstat (limited to 'Modules')
| -rw-r--r-- | Modules/clmodule.c | 1114 |
1 files changed, 584 insertions, 530 deletions
diff --git a/Modules/clmodule.c b/Modules/clmodule.c index 02f1ceb..b48815e 100644 --- a/Modules/clmodule.c +++ b/Modules/clmodule.c @@ -36,19 +36,17 @@ PERFORMANCE OF THIS SOFTWARE. #include <stdarg.h> #include <cl.h> -#include "allobjects.h" -#include "modsupport.h" /* For getargs() etc. */ -#include "ceval.h" /* For call_object() */ +#include "Python.h" typedef struct { - OB_HEAD + PyObject_HEAD int ob_isCompressor; /* Compressor or Decompressor */ CL_Handle ob_compressorHdl; int *ob_paramtypes; int ob_nparams; } clobject; -static object *ClError; /* exception cl.error */ +static PyObject *ClError; /* exception cl.error */ static int error_handler_called = 0; @@ -71,7 +69,7 @@ cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...) char errbuf[BUFSIZ]; /* hopefully big enough */ char *p; - if (err_occurred()) /* don't change existing error */ + if (PyErr_Occurred()) /* don't change existing error */ return; error_handler_called = 1; va_start(ap, fmt); @@ -80,7 +78,7 @@ cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...) p = &errbuf[strlen(errbuf) - 1]; /* swat the line feed */ if (*p == '\n') *p = 0; - err_setstr(ClError, errbuf); + PyErr_SetString(ClError, errbuf); } /* @@ -97,14 +95,15 @@ param_type_is_float(clobject *self, int param) if (error_handler_called) return -1; - self->ob_paramtypes = NEW(int, bufferlength); + 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); + (void) clQueryParams(self->ob_compressorHdl, + self->ob_paramtypes, bufferlength); if (error_handler_called) { - DEL(self->ob_paramtypes); + PyMem_DEL(self->ob_paramtypes); self->ob_paramtypes = NULL; return -1; } @@ -123,22 +122,23 @@ param_type_is_float(clobject *self, int param) /******************************************************************** Single image compression/decompression. ********************************************************************/ -static object * -cl_CompressImage(object *self, object *args) +static PyObject * +cl_CompressImage(PyObject *self, PyObject *args) { int compressionScheme, width, height, originalFormat; float compressionRatio; int frameBufferSize, compressedBufferSize; char *frameBuffer; - object *compressedBuffer; + PyObject *compressedBuffer; - if (!getargs(args, "(iiiifs#)", &compressionScheme, &width, &height, - &originalFormat, &compressionRatio, &frameBuffer, - &frameBufferSize)) + if (!PyArg_Parse(args, "(iiiifs#)", &compressionScheme, + &width, &height, + &originalFormat, &compressionRatio, &frameBuffer, + &frameBufferSize)) return NULL; - retry: - compressedBuffer = newsizedstringobject(NULL, frameBufferSize); + retry: + compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize); if (compressedBuffer == NULL) return NULL; @@ -147,53 +147,54 @@ cl_CompressImage(object *self, object *args) if (clCompressImage(compressionScheme, width, height, originalFormat, compressionRatio, (void *) frameBuffer, &compressedBufferSize, - (void *) getstringvalue(compressedBuffer)) + (void *) PyString_AsString(compressedBuffer)) == FAILURE) { - DECREF(compressedBuffer); + Py_DECREF(compressedBuffer); if (!error_handler_called) - err_setstr(ClError, "clCompressImage failed"); + PyErr_SetString(ClError, "clCompressImage failed"); return NULL; } if (compressedBufferSize > frameBufferSize) { frameBufferSize = compressedBufferSize; - DECREF(compressedBuffer); + Py_DECREF(compressedBuffer); goto retry; } if (compressedBufferSize < frameBufferSize) - if (resizestring(&compressedBuffer, compressedBufferSize)) + if (_PyString_Resize(&compressedBuffer, compressedBufferSize)) return NULL; return compressedBuffer; } -static object * -cl_DecompressImage(object *self, object *args) +static PyObject * +cl_DecompressImage(PyObject *self, PyObject *args) { int compressionScheme, width, height, originalFormat; char *compressedBuffer; int compressedBufferSize, frameBufferSize; - object *frameBuffer; + PyObject *frameBuffer; - if (!getargs(args, "(iiiis#)", &compressionScheme, &width, &height, - &originalFormat, &compressedBuffer, - &compressedBufferSize)) + if (!PyArg_Parse(args, "(iiiis#)", &compressionScheme, &width, &height, + &originalFormat, &compressedBuffer, + &compressedBufferSize)) return NULL; frameBufferSize = width * height * CL_BytesPerPixel(originalFormat); - frameBuffer = newsizedstringobject(NULL, frameBufferSize); + frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize); if (frameBuffer == NULL) return NULL; error_handler_called = 0; if (clDecompressImage(compressionScheme, width, height, originalFormat, compressedBufferSize, compressedBuffer, - (void *) getstringvalue(frameBuffer)) == FAILURE) { - DECREF(frameBuffer); + (void *) PyString_AsString(frameBuffer)) + == FAILURE) { + Py_DECREF(frameBuffer); if (!error_handler_called) - err_setstr(ClError, "clDecompressImage failed"); + PyErr_SetString(ClError, "clDecompressImage failed"); return NULL; } @@ -204,58 +205,59 @@ cl_DecompressImage(object *self, object *args) Sequential compression/decompression. ********************************************************************/ #define CheckCompressor(self) if ((self)->ob_compressorHdl == NULL) { \ - err_setstr(RuntimeError, "(de)compressor not active"); \ - return NULL; \ - } + PyErr_SetString(PyExc_RuntimeError, "(de)compressor not active"); \ + return NULL; \ +} -static object * -doClose(clobject *self, object *args, int (*close_func)(CL_Handle)) +static PyObject * +doClose(clobject *self, PyObject *args, int (*close_func)(CL_Handle)) { CheckCompressor(self); - if (!getnoarg(args)) + if (!PyArg_NoArgs(args)) return NULL; error_handler_called = 0; if ((*close_func)(self->ob_compressorHdl) == FAILURE) { if (!error_handler_called) - err_setstr(ClError, "close failed"); + PyErr_SetString(ClError, "close failed"); return NULL; } self->ob_compressorHdl = NULL; if (self->ob_paramtypes) - DEL(self->ob_paramtypes); + PyMem_DEL(self->ob_paramtypes); self->ob_paramtypes = NULL; - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * -clm_CloseCompressor(object *self, object *args) +static PyObject * +clm_CloseCompressor(PyObject *self, PyObject *args) { return doClose(SELF, args, clCloseCompressor); } -static object * -clm_CloseDecompressor(object *self, object *args) +static PyObject * +clm_CloseDecompressor(PyObject *self, PyObject *args) { return doClose(SELF, args, clCloseDecompressor); } -static object * -clm_Compress(object *self, object *args) +static PyObject * +clm_Compress(PyObject *self, PyObject *args) { int numberOfFrames; int frameBufferSize, compressedBufferSize, size; char *frameBuffer; - object *data; + PyObject *data; CheckCompressor(SELF); - if (!getargs(args, "(is#)", &numberOfFrames, &frameBuffer, &frameBufferSize)) + if (!PyArg_Parse(args, "(is#)", &numberOfFrames, + &frameBuffer, &frameBufferSize)) return NULL; error_handler_called = 0; @@ -264,46 +266,47 @@ clm_Compress(object *self, object *args) if (error_handler_called) return NULL; - data = newsizedstringobject(NULL, size); + data = PyString_FromStringAndSize(NULL, size); if (data == NULL) return NULL; error_handler_called = 0; if (clCompress(SELF->ob_compressorHdl, numberOfFrames, (void *) frameBuffer, &compressedBufferSize, - (void *) getstringvalue(data)) == FAILURE) { - DECREF(data); + (void *) PyString_AsString(data)) == FAILURE) { + Py_DECREF(data); if (!error_handler_called) - err_setstr(ClError, "compress failed"); + PyErr_SetString(ClError, "compress failed"); return NULL; } if (compressedBufferSize < size) - if (resizestring(&data, compressedBufferSize)) + if (_PyString_Resize(&data, compressedBufferSize)) return NULL; if (compressedBufferSize > size) { /* we didn't get all "compressed" data */ - DECREF(data); - err_setstr(ClError, "compressed data is more than fitted"); + Py_DECREF(data); + PyErr_SetString(ClError, + "compressed data is more than fitted"); return NULL; } return data; } -static object * -clm_Decompress(object *self, object *args) +static PyObject * +clm_Decompress(PyObject *self, PyObject *args) { - object *data; + PyObject *data; int numberOfFrames; char *compressedData; int compressedDataSize, dataSize; CheckCompressor(SELF); - if (!getargs(args, "(is#)", &numberOfFrames, &compressedData, - &compressedDataSize)) + if (!PyArg_Parse(args, "(is#)", &numberOfFrames, &compressedData, + &compressedDataSize)) return NULL; error_handler_called = 0; @@ -311,28 +314,28 @@ clm_Decompress(object *self, object *args) if (error_handler_called) return NULL; - data = newsizedstringobject(NULL, dataSize); + data = PyString_FromStringAndSize(NULL, dataSize); if (data == NULL) return NULL; error_handler_called = 0; if (clDecompress(SELF->ob_compressorHdl, numberOfFrames, compressedDataSize, (void *) compressedData, - (void *) getstringvalue(data)) == FAILURE) { - DECREF(data); + (void *) PyString_AsString(data)) == FAILURE) { + Py_DECREF(data); if (!error_handler_called) - err_setstr(ClError, "decompress failed"); + PyErr_SetString(ClError, "decompress failed"); return NULL; } return data; } -static object * -doParams(clobject *self, object *args, int (*func)(CL_Handle, int *, int), +static PyObject * +doParams(clobject *self, PyObject *args, int (*func)(CL_Handle, int *, int), int modified) { - object *list, *v; + PyObject *list, *v; int *PVbuffer; int length; int i; @@ -340,31 +343,31 @@ doParams(clobject *self, object *args, int (*func)(CL_Handle, int *, int), CheckCompressor(self); - if (!getargs(args, "O", &list)) + if (!PyArg_Parse(args, "O", &list)) return NULL; - if (!is_listobject(list)) { - err_badarg(); + if (!PyList_Check(list)) { + PyErr_BadArgument(); return NULL; } - length = getlistsize(list); - PVbuffer = NEW(int, length); + length = PyList_Size(list); + PVbuffer = PyMem_NEW(int, length); if (PVbuffer == NULL) - return err_nomem(); + return PyErr_NoMemory(); for (i = 0; i < length; i++) { - v = getlistitem(list, i); - if (is_floatobject(v)) { - number = getfloatvalue(v); + v = PyList_GetItem(list, i); + if (PyFloat_Check(v)) { + number = PyFloat_AsDouble(v); PVbuffer[i] = CL_TypeIsInt(number); - } else if (is_intobject(v)) { - PVbuffer[i] = getintvalue(v); + } 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 { - DEL(PVbuffer); - err_badarg(); + PyMem_DEL(PVbuffer); + PyErr_BadArgument(); return NULL; } } @@ -372,7 +375,7 @@ doParams(clobject *self, object *args, int (*func)(CL_Handle, int *, int), error_handler_called = 0; (*func)(self->ob_compressorHdl, PVbuffer, length); if (error_handler_called) { - DEL(PVbuffer); + PyMem_DEL(PVbuffer); return NULL; } @@ -381,40 +384,40 @@ doParams(clobject *self, object *args, int (*func)(CL_Handle, int *, int), if ((i & 1) && param_type_is_float(self, PVbuffer[i-1]) > 0) { number = CL_TypeIsFloat(PVbuffer[i]); - v = newfloatobject(number); + v = PyFloat_FromDouble(number); } else - v = newintobject(PVbuffer[i]); - setlistitem(list, i, v); + v = PyInt_FromLong(PVbuffer[i]); + PyList_SetItem(list, i, v); } } - DEL(PVbuffer); + PyMem_DEL(PVbuffer); - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * -clm_GetParams(object *self, object *args) +static PyObject * +clm_GetParams(PyObject *self, PyObject *args) { return doParams(SELF, args, clGetParams, 1); } -static object * -clm_SetParams(object *self, object *args) +static PyObject * +clm_SetParams(PyObject *self, PyObject *args) { return doParams(SELF, args, clSetParams, 0); } -static object * -do_get(clobject *self, object *args, int (*func)(CL_Handle, int)) +static PyObject * +do_get(clobject *self, PyObject *args, int (*func)(CL_Handle, int)) { int paramID, value; float fvalue; CheckCompressor(self); - if (!getargs(args, "i", ¶mID)) + if (!PyArg_Parse(args, "i", ¶mID)) return NULL; error_handler_called = 0; @@ -424,37 +427,38 @@ do_get(clobject *self, object *args, int (*func)(CL_Handle, int)) if (param_type_is_float(self, paramID) > 0) { fvalue = CL_TypeIsFloat(value); - return newfloatobject(fvalue); + return PyFloat_FromDouble(fvalue); } - return newintobject(value); + return PyInt_FromLong(value); } -static object * -clm_GetParam(object *self, object *args) +static PyObject * +clm_GetParam(PyObject *self, PyObject *args) { return do_get(SELF, args, clGetParam); } -static object * -clm_GetDefault(object *self, object *args) +static PyObject * +clm_GetDefault(PyObject *self, PyObject *args) { return do_get(SELF, args, clGetDefault); } -static object * -clm_SetParam(object *self, object *args) +static PyObject * +clm_SetParam(PyObject *self, PyObject *args) { int paramID, value; float fvalue; CheckCompressor(SELF); - if (!getargs(args, "(ii)", ¶mID, &value)) { - err_clear(); - if (!getargs(args, "(if)", ¶mID, &fvalue)) { - err_clear(); - err_setstr(TypeError, "bad argument list (format '(ii)' or '(if)')"); + if (!PyArg_Parse(args, "(ii)", ¶mID, &value)) { + PyErr_Clear(); + if (!PyArg_Parse(args, "(if)", ¶mID, &fvalue)) { + PyErr_Clear(); + PyErr_SetString(PyExc_TypeError, + "bad argument list (format '(ii)' or '(if)')"); return NULL; } value = CL_TypeIsInt(fvalue); @@ -471,44 +475,44 @@ clm_SetParam(object *self, object *args) return NULL; if (param_type_is_float(SELF, paramID) > 0) - return newfloatobject(CL_TypeIsFloat(value)); + return PyFloat_FromDouble(CL_TypeIsFloat(value)); else - return newintobject(value); + return PyInt_FromLong(value); } -static object * -clm_GetParamID(object *self, object *args) +static PyObject * +clm_GetParamID(PyObject *self, PyObject *args) { char *name; int value; CheckCompressor(SELF); - if (!getargs(args, "s", &name)) + if (!PyArg_Parse(args, "s", &name)) return NULL; error_handler_called = 0; value = clGetParamID(SELF->ob_compressorHdl, name); if (value == FAILURE) { if (!error_handler_called) - err_setstr(ClError, "getparamid failed"); + PyErr_SetString(ClError, "getparamid failed"); return NULL; } - return newintobject(value); + return PyInt_FromLong(value); } -static object * -clm_QueryParams(object *self, object *args) +static PyObject * +clm_QueryParams(PyObject *self, PyObject *args) { int bufferlength; int *PVbuffer; - object *list; + PyObject *list; int i; CheckCompressor(SELF); - if (!getnoarg(args)) + if (!PyArg_NoArgs(args)) return NULL; error_handler_called = 0; @@ -516,47 +520,48 @@ clm_QueryParams(object *self, object *args) if (error_handler_called) return NULL; - PVbuffer = NEW(int, bufferlength); + PVbuffer = PyMem_NEW(int, bufferlength); if (PVbuffer == NULL) - return err_nomem(); + return PyErr_NoMemory(); bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer, bufferlength); if (error_handler_called) { - DEL(PVbuffer); + PyMem_DEL(PVbuffer); return NULL; } - list = newlistobject(bufferlength); + list = PyList_New(bufferlength); if (list == NULL) { - DEL(PVbuffer); + PyMem_DEL(PVbuffer); return NULL; } for (i = 0; i < bufferlength; i++) { if (i & 1) - setlistitem(list, i, newintobject(PVbuffer[i])); + PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i])); else if (PVbuffer[i] == 0) { - INCREF(None); - setlistitem(list, i, None); + Py_INCREF(Py_None); + PyList_SetItem(list, i, Py_None); } else - setlistitem(list, i, newstringobject((char *) PVbuffer[i])); + PyList_SetItem(list, i, + PyString_FromString((char *) PVbuffer[i])); } - DEL(PVbuffer); + PyMem_DEL(PVbuffer); return list; } -static object * -clm_GetMinMax(object *self, object *args) +static PyObject * +clm_GetMinMax(PyObject *self, PyObject *args) { int param, min, max; float fmin, fmax; CheckCompressor(SELF); - if (!getargs(args, "i", ¶m)) + if (!PyArg_Parse(args, "i", ¶m)) return NULL; clGetMinMax(SELF->ob_compressorHdl, param, &min, &max); @@ -564,61 +569,61 @@ clm_GetMinMax(object *self, object *args) if (param_type_is_float(SELF, param) > 0) { fmin = CL_TypeIsFloat(min); fmax = CL_TypeIsFloat(max); - return mkvalue("(ff)", fmin, fmax); + return Py_BuildValue("(ff)", fmin, fmax); } - return mkvalue("(ii)", min, max); + return Py_BuildValue("(ii)", min, max); } -static object * -clm_GetName(object *self, object *args) +static PyObject * +clm_GetName(PyObject *self, PyObject *args) { int param; char *name; CheckCompressor(SELF); - if (!getargs(args, "i", ¶m)) + if (!PyArg_Parse(args, "i", ¶m)) return NULL; error_handler_called = 0; name = clGetName(SELF->ob_compressorHdl, param); if (name == NULL || error_handler_called) { if (!error_handler_called) - err_setstr(ClError, "getname failed"); + PyErr_SetString(ClError, "getname failed"); return NULL; } - return newstringobject(name); + return PyString_FromString(name); } -static object * -clm_QuerySchemeFromHandle(object *self, object *args) +static PyObject * +clm_QuerySchemeFromHandle(PyObject *self, PyObject *args) { CheckCompressor(SELF); - if (!getnoarg(args)) + if (!PyArg_NoArgs(args)) return NULL; - return newintobject(clQuerySchemeFromHandle(SELF->ob_compressorHdl)); + return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl)); } -static object * -clm_ReadHeader(object *self, object *args) +static PyObject * +clm_ReadHeader(PyObject *self, PyObject *args) { char *header; int headerSize; CheckCompressor(SELF); - if (!getargs(args, "s#", &header, &headerSize)) + if (!PyArg_Parse(args, "s#", &header, &headerSize)) return NULL; - return newintobject(clReadHeader(SELF->ob_compressorHdl, - headerSize, header)); + return PyInt_FromLong(clReadHeader(SELF->ob_compressorHdl, + headerSize, header)); } -static struct methodlist compressor_methods[] = { +static PyMethodDef compressor_methods[] = { {"close", clm_CloseCompressor}, /* alias */ {"CloseCompressor", clm_CloseCompressor}, {"Compress", clm_Compress}, @@ -635,7 +640,7 @@ static struct methodlist compressor_methods[] = { {NULL, NULL} /* sentinel */ }; -static struct methodlist decompressor_methods[] = { +static PyMethodDef decompressor_methods[] = { {"close", clm_CloseDecompressor}, /* alias */ {"CloseDecompressor", clm_CloseDecompressor}, {"Decompress", clm_Decompress}, @@ -654,7 +659,7 @@ static struct methodlist decompressor_methods[] = { }; static void -cl_dealloc(object *self) +cl_dealloc(PyObject *self) { if (SELF->ob_compressorHdl) { if (SELF->ob_isCompressor) @@ -662,20 +667,20 @@ cl_dealloc(object *self) else clCloseDecompressor(SELF->ob_compressorHdl); } - DEL(self); + PyMem_DEL(self); } -static object * -cl_getattr(object *self, char *name) +static PyObject * +cl_getattr(PyObject *self, char *name) { if (SELF->ob_isCompressor) - return findmethod(compressor_methods, self, name); + return Py_FindMethod(compressor_methods, self, name); else - return findmethod(decompressor_methods, self, name); + return Py_FindMethod(decompressor_methods, self, name); } -static typeobject Cltype = { - OB_HEAD_INIT(&Typetype) +static PyTypeObject Cltype = { + PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ "cl", /*tp_name*/ sizeof(clobject), /*tp_size*/ @@ -692,17 +697,17 @@ static typeobject Cltype = { 0, /*tp_as_mapping*/ }; -static object * -doOpen(object *self, object *args, int (*open_func)(int, CL_Handle *), +static PyObject * +doOpen(PyObject *self, PyObject *args, int (*open_func)(int, CL_Handle *), int iscompressor) { int scheme; clobject *new; - if (!getargs(args, "i", &scheme)) + if (!PyArg_Parse(args, "i", &scheme)) return NULL; - new = NEWOBJ(clobject, &Cltype); + new = PyObject_NEW(clobject, &Cltype); if (new == NULL) return NULL; @@ -712,66 +717,66 @@ doOpen(object *self, object *args, int (*open_func)(int, CL_Handle *), error_handler_called = 0; if ((*open_func)(scheme, &new->ob_compressorHdl) == FAILURE) { - DECREF(new); + Py_DECREF(new); if (!error_handler_called) - err_setstr(ClError, "Open(De)Compressor failed"); + PyErr_SetString(ClError, "Open(De)Compressor failed"); return NULL; } - return (object *)new; + return (PyObject *)new; } -static object * -cl_OpenCompressor(object *self, object *args) +static PyObject * +cl_OpenCompressor(PyObject *self, PyObject *args) { return doOpen(self, args, clOpenCompressor, 1); } -static object * -cl_OpenDecompressor(object *self, object *args) +static PyObject * +cl_OpenDecompressor(PyObject *self, PyObject *args) { return doOpen(self, args, clOpenDecompressor, 0); } -static object * -cl_QueryScheme(object *self, object *args) +static PyObject * +cl_QueryScheme(PyObject *self, PyObject *args) { char *header; int headerlen; int scheme; - if (!getargs(args, "s#", &header, &headerlen)) + if (!PyArg_Parse(args, "s#", &header, &headerlen)) return NULL; scheme = clQueryScheme(header); if (scheme < 0) { - err_setstr(ClError, "unknown compression scheme"); + PyErr_SetString(ClError, "unknown compression scheme"); return NULL; } - return newintobject(scheme); + return PyInt_FromLong(scheme); } -static object * -cl_QueryMaxHeaderSize(object *self, object *args) +static PyObject * +cl_QueryMaxHeaderSize(PyObject *self, PyObject *args) { int scheme; - if (!getargs(args, "i", &scheme)) + if (!PyArg_Parse(args, "i", &scheme)) return NULL; - return newintobject(clQueryMaxHeaderSize(scheme)); + return PyInt_FromLong(clQueryMaxHeaderSize(scheme)); } -static object * -cl_QueryAlgorithms(object *self, object *args) +static PyObject * +cl_QueryAlgorithms(PyObject *self, PyObject *args) { int algorithmMediaType; int bufferlength; int *PVbuffer; - object *list; + PyObject *list; int i; - if (!getargs(args, "i", &algorithmMediaType)) + if (!PyArg_Parse(args, "i", &algorithmMediaType)) return NULL; error_handler_called = 0; @@ -779,88 +784,90 @@ cl_QueryAlgorithms(object *self, object *args) if (error_handler_called) return NULL; - PVbuffer = NEW(int, bufferlength); + PVbuffer = PyMem_NEW(int, bufferlength); if (PVbuffer == NULL) - return err_nomem(); + return PyErr_NoMemory(); bufferlength = clQueryAlgorithms(algorithmMediaType, PVbuffer, - bufferlength); + bufferlength); if (error_handler_called) { - DEL(PVbuffer); + PyMem_DEL(PVbuffer); return NULL; } - list = newlistobject(bufferlength); + list = PyList_New(bufferlength); if (list == NULL) { - DEL(PVbuffer); + PyMem_DEL(PVbuffer); return NULL; } for (i = 0; i < bufferlength; i++) { if (i & 1) - setlistitem(list, i, newintobject(PVbuffer[i])); + PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i])); else if (PVbuffer[i] == 0) { - INCREF(None); - setlistitem(list, i, None); + Py_INCREF(Py_None); + PyList_SetItem(list, i, Py_None); } else - setlistitem(list, i, newstringobject((char *) PVbuffer[i])); + PyList_SetItem(list, i, + PyString_FromString((char *) PVbuffer[i])); } - DEL(PVbuffer); + PyMem_DEL(PVbuffer); return list; } -static object * -cl_QuerySchemeFromName(object *self, object *args) +static PyObject * +cl_QuerySchemeFromName(PyObject *self, PyObject *args) { int algorithmMediaType; char *name; int scheme; - if (!getargs(args, "(is)", &algorithmMediaType, &name)) + if (!PyArg_Parse(args, "(is)", &algorithmMediaType, &name)) return NULL; error_handler_called = 0; scheme = clQuerySchemeFromName(algorithmMediaType, name); if (error_handler_called) { - err_setstr(ClError, "unknown compression scheme"); + PyErr_SetString(ClError, "unknown compression scheme"); return NULL; } - return newintobject(scheme); + return PyInt_FromLong(scheme); } -static object * -cl_GetAlgorithmName(object *self, object *args) +static PyObject * +cl_GetAlgorithmName(PyObject *self, PyObject *args) { int scheme; char *name; - if (!getargs(args, "i", &scheme)) + if (!PyArg_Parse(args, "i", &scheme)) return NULL; name = clGetAlgorithmName(scheme); if (name == 0) { - err_setstr(ClError, "unknown compression scheme"); + PyErr_SetString(ClError, "unknown compression scheme"); return NULL; } - return newstringobject(name); + return PyString_FromString(name); } -static object * -do_set(object *self, object *args, int (*func)(int, int, int)) +static PyObject * +do_set(PyObject *self, PyObject *args, int (*func)(int, int, int)) { int scheme, paramID, value; float fvalue; int is_float = 0; - if (!getargs(args, "(iii)", &scheme, ¶mID, &value)) { - err_clear(); - if (!getargs(args, "(iif)", &scheme, ¶mID, &fvalue)) { - err_clear(); - err_setstr(TypeError, "bad argument list (format '(iii)' or '(iif)')"); + if (!PyArg_Parse(args, "(iii)", &scheme, ¶mID, &value)) { + PyErr_Clear(); + if (!PyArg_Parse(args, "(iif)", &scheme, ¶mID, &fvalue)) { + PyErr_Clear(); + PyErr_SetString(PyExc_TypeError, + "bad argument list (format '(iii)' or '(iif)')"); return NULL; } value = CL_TypeIsInt(fvalue); @@ -883,75 +890,75 @@ do_set(object *self, object *args, int (*func)(int, int, int)) return NULL; if (is_float) - return newfloatobject(CL_TypeIsFloat(value)); + return PyFloat_FromDouble(CL_TypeIsFloat(value)); else - return newintobject(value); + return PyInt_FromLong(value); } -static object * -cl_SetDefault(object *self, object *args) +static PyObject * +cl_SetDefault(PyObject *self, PyObject *args) { return do_set(self, args, clSetDefault); } -static object * -cl_SetMin(object *self, object *args) +static PyObject * +cl_SetMin(PyObject *self, PyObject *args) { return do_set(self, args, clSetMin); } -static object * -cl_SetMax(object *self, object *args) +static PyObject * +cl_SetMax(PyObject *self, PyObject *args) { return do_set(self, args, clSetMax); } -#define func(name, type) \ - static object *cl_##name(object *self, object *args) \ - { \ - int x; \ - if (!getargs(args, "i", &x)) return NULL; \ - return new##type##object(CL_##name(x)); \ - } +#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, type) \ - static object *cl_##name(object *self, object *args) \ - { \ - int a1, a2; \ - if (!getargs(args, "(ii)", &a1, &a2)) return NULL; \ - return new##type##object(CL_##name(a1, a2)); \ - } +#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) -func(BytesPerPixel,int) -func(AudioFormatName,string) -func(VideoFormatName,string) -func(AlgorithmNumber,int) -func(AlgorithmType,int) -func2(Algorithm,int) -func(ParamNumber,int) -func(ParamType,int) -func2(ParamID,int) +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 object * -cvt_type(object *self, object *args) + static PyObject * +cvt_type(PyObject *self, PyObject *args) { int number; float fnumber; - if (getargs(args, "i", &number)) - return newfloatobject(CL_TypeIsFloat(number)); + if (PyArg_Parse(args, "i", &number)) + return PyFloat_FromDouble(CL_TypeIsFloat(number)); else { - err_clear(); - if (getargs(args, "f", &fnumber)) - return newintobject(CL_TypeIsInt(fnumber)); + PyErr_Clear(); + if (PyArg_Parse(args, "f", &fnumber)) + return PyInt_FromLong(CL_TypeIsInt(fnumber)); return NULL; } } #endif -static struct methodlist cl_methods[] = { +static PyMethodDef cl_methods[] = { {"CompressImage", cl_CompressImage}, {"DecompressImage", cl_DecompressImage}, {"GetAlgorithmName", cl_GetAlgorithmName}, @@ -987,302 +994,349 @@ static struct methodlist cl_methods[] = { void initcl() { - object *m, *d; - - m = initmodule("cl", cl_methods); - d = getmoduledict(m); - - ClError = newstringobject("cl.error"); - (void) dictinsert(d, "error", ClError); - - (void) dictinsert(d, "MAX_NUMBER_OF_ORIGINAL_FORMATS", - newintobject(CL_MAX_NUMBER_OF_ORIGINAL_FORMATS)); - (void) dictinsert(d, "MONO", newintobject(CL_MONO)); - (void) dictinsert(d, "STEREO_INTERLEAVED", - newintobject(CL_STEREO_INTERLEAVED)); - (void) dictinsert(d, "RGB", newintobject(CL_RGB)); - (void) dictinsert(d, "RGBX", newintobject(CL_RGBX)); - (void) dictinsert(d, "RGBA", newintobject(CL_RGBA)); - (void) dictinsert(d, "RGB332", newintobject(CL_RGB332)); - (void) dictinsert(d, "GRAYSCALE", newintobject(CL_GRAYSCALE)); - (void) dictinsert(d, "Y", newintobject(CL_Y)); - (void) dictinsert(d, "YUV", newintobject(CL_YUV)); - (void) dictinsert(d, "YCbCr", newintobject(CL_YCbCr)); - (void) dictinsert(d, "YUV422", newintobject(CL_YUV422)); - (void) dictinsert(d, "YCbCr422", newintobject(CL_YCbCr422)); - (void) dictinsert(d, "YUV422HC", newintobject(CL_YUV422HC)); - (void) dictinsert(d, "YCbCr422HC", newintobject(CL_YCbCr422HC)); - (void) dictinsert(d, "YUV422DC", newintobject(CL_YUV422DC)); - (void) dictinsert(d, "YCbCr422DC", newintobject(CL_YCbCr422DC)); - (void) dictinsert(d, "RGB8", newintobject(CL_RGB8)); - (void) dictinsert(d, "BEST_FIT", newintobject(CL_BEST_FIT)); - (void) dictinsert(d, "MAX_NUMBER_OF_AUDIO_ALGORITHMS", - newintobject(CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS)); - (void) dictinsert(d, "MAX_NUMBER_OF_VIDEO_ALGORITHMS", - newintobject(CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS)); - (void) dictinsert(d, "AUDIO", newintobject(CL_AUDIO)); - (void) dictinsert(d, "VIDEO", newintobject(CL_VIDEO)); - (void) dictinsert(d, "UNKNOWN_SCHEME", - newintobject(CL_UNKNOWN_SCHEME)); - (void) dictinsert(d, "UNCOMPRESSED_AUDIO", - newintobject(CL_UNCOMPRESSED_AUDIO)); - (void) dictinsert(d, "G711_ULAW", newintobject(CL_G711_ULAW)); - (void) dictinsert(d, "ULAW", newintobject(CL_ULAW)); - (void) dictinsert(d, "G711_ALAW", newintobject(CL_G711_ALAW)); - (void) dictinsert(d, "ALAW", newintobject(CL_ALAW)); - (void) dictinsert(d, "AWARE_MPEG_AUDIO", - newintobject(CL_AWARE_MPEG_AUDIO)); - (void) dictinsert(d, "AWARE_MULTIRATE", - newintobject(CL_AWARE_MULTIRATE)); - (void) dictinsert(d, "UNCOMPRESSED", newintobject(CL_UNCOMPRESSED)); - (void) dictinsert(d, "UNCOMPRESSED_VIDEO", - newintobject(CL_UNCOMPRESSED_VIDEO)); - (void) dictinsert(d, "RLE", newintobject(CL_RLE)); - (void) dictinsert(d, "JPEG", newintobject(CL_JPEG)); + PyObject *m, *d; + + m = Py_InitModule("cl", cl_methods); + d = PyModule_GetDict(m); + + ClError = PyString_FromString("cl.error"); + (void) PyDict_SetItemString(d, "error", ClError); + + (void) PyDict_SetItemString(d, "MAX_NUMBER_OF_ORIGINAL_FORMATS", + PyInt_FromLong(CL_MAX_NUMBER_OF_ORIGINAL_FORMATS)); + (void) PyDict_SetItemString(d, "MONO", PyInt_FromLong(CL_MONO)); + (void) PyDict_SetItemString(d, "STEREO_INTERLEAVED", + PyInt_FromLong(CL_STEREO_INTERLEAVED)); + (void) PyDict_SetItemString(d, "RGB", PyInt_FromLong(CL_RGB)); + (void) PyDict_SetItemString(d, "RGBX", PyInt_FromLong(CL_RGBX)); + (void) PyDict_SetItemString(d, "RGBA", PyInt_FromLong(CL_RGBA)); + (void) PyDict_SetItemString(d, "RGB332", PyInt_FromLong(CL_RGB332)); + (void) PyDict_SetItemString(d, "GRAYSCALE", + PyInt_FromLong(CL_GRAYSCALE)); + (void) PyDict_SetItemString(d, "Y", PyInt_FromLong(CL_Y)); + (void) PyDict_SetItemString(d, "YUV", PyInt_FromLong(CL_YUV)); + (void) PyDict_SetItemString(d, "YCbCr", PyInt_FromLong(CL_YCbCr)); + (void) PyDict_SetItemString(d, "YUV422", PyInt_FromLong(CL_YUV422)); + (void) PyDict_SetItemString(d, "YCbCr422", + PyInt_FromLong(CL_YCbCr422)); + (void) PyDict_SetItemString(d, "YUV422HC", + PyInt_FromLong(CL_YUV422HC)); + (void) PyDict_SetItemString(d, "YCbCr422HC", + PyInt_FromLong(CL_YCbCr422HC)); + (void) PyDict_SetItemString(d, "YUV422DC", + PyInt_FromLong(CL_YUV422DC)); + (void) PyDict_SetItemString(d, "YCbCr422DC", + PyInt_FromLong(CL_YCbCr422DC)); + (void) PyDict_SetItemString(d, "RGB8", PyInt_FromLong(CL_RGB8)); + (void) PyDict_SetItemString(d, "BEST_FIT", + PyInt_FromLong(CL_BEST_FIT)); + (void) PyDict_SetItemString(d, "MAX_NUMBER_OF_AUDIO_ALGORITHMS", + PyInt_FromLong(CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS)); + (void) PyDict_SetItemString(d, "MAX_NUMBER_OF_VIDEO_ALGORITHMS", + PyInt_FromLong(CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS)); + (void) PyDict_SetItemString(d, "AUDIO", PyInt_FromLong(CL_AUDIO)); + (void) PyDict_SetItemString(d, "VIDEO", PyInt_FromLong(CL_VIDEO)); + (void) PyDict_SetItemString(d, "UNKNOWN_SCHEME", + PyInt_FromLong(CL_UNKNOWN_SCHEME)); + (void) PyDict_SetItemString(d, "UNCOMPRESSED_AUDIO", + PyInt_FromLong(CL_UNCOMPRESSED_AUDIO)); + (void) PyDict_SetItemString(d, "G711_ULAW", + PyInt_FromLong(CL_G711_ULAW)); + (void) PyDict_SetItemString(d, "ULAW", PyInt_FromLong(CL_ULAW)); + (void) PyDict_SetItemString(d, "G711_ALAW", + PyInt_FromLong(CL_G711_ALAW)); + (void) PyDict_SetItemString(d, "ALAW", PyInt_FromLong(CL_ALAW)); + (void) PyDict_SetItemString(d, "AWARE_MPEG_AUDIO", + PyInt_FromLong(CL_AWARE_MPEG_AUDIO)); + (void) PyDict_SetItemString(d, "AWARE_MULTIRATE", + PyInt_FromLong(CL_AWARE_MULTIRATE)); + (void) PyDict_SetItemString(d, "UNCOMPRESSED", + PyInt_FromLong(CL_UNCOMPRESSED)); + (void) PyDict_SetItemString(d, "UNCOMPRESSED_VIDEO", + PyInt_FromLong(CL_UNCOMPRESSED_VIDEO)); + (void) PyDict_SetItemString(d, "RLE", PyInt_FromLong(CL_RLE)); + (void) PyDict_SetItemString(d, "JPEG", PyInt_FromLong(CL_JPEG)); #ifdef IRIX_5_3_LIBRARY - (void) dictinsert(d, "JPEG_SOFTWARE", newintobject(CL_JPEG_SOFTWARE)); + (void) PyDict_SetItemString(d, "JPEG_SOFTWARE", + PyInt_FromLong(CL_JPEG_SOFTWARE)); #endif - (void) dictinsert(d, "MPEG_VIDEO", newintobject(CL_MPEG_VIDEO)); - (void) dictinsert(d, "MVC1", newintobject(CL_MVC1)); - (void) dictinsert(d, "RTR", newintobject(CL_RTR)); - (void) dictinsert(d, "RTR1", newintobject(CL_RTR1)); - (void) dictinsert(d, "HDCC", newintobject(CL_HDCC)); - (void) dictinsert(d, "MVC2", newintobject(CL_MVC2)); - (void) dictinsert(d, "RLE24", newintobject(CL_RLE24)); - (void) dictinsert(d, "MAX_NUMBER_OF_PARAMS", - newintobject(CL_MAX_NUMBER_OF_PARAMS)); - (void) dictinsert(d, "IMAGE_WIDTH", newintobject(CL_IMAGE_WIDTH)); - (void) dictinsert(d, "IMAGE_HEIGHT", newintobject(CL_IMAGE_HEIGHT)); - (void) dictinsert(d, "ORIGINAL_FORMAT", - newintobject(CL_ORIGINAL_FORMAT)); - (void) dictinsert(d, "INTERNAL_FORMAT", - newintobject(CL_INTERNAL_FORMAT)); - (void) dictinsert(d, "COMPONENTS", newintobject(CL_COMPONENTS)); - (void) dictinsert(d, "BITS_PER_COMPONENT", - newintobject(CL_BITS_PER_COMPONENT)); - (void) dictinsert(d, "FRAME_RATE", newintobject(CL_FRAME_RATE)); - (void) dictinsert(d, "COMPRESSION_RATIO", - newintobject(CL_COMPRESSION_RATIO)); - (void) dictinsert(d, "EXACT_COMPRESSION_RATIO", - newintobject(CL_EXACT_COMPRESSION_RATIO)); - (void) dictinsert(d, "FRAME_BUFFER_SIZE", - newintobject(CL_FRAME_BUFFER_SIZE)); - (void) dictinsert(d, "COMPRESSED_BUFFER_SIZE", - newintobject(CL_COMPRESSED_BUFFER_SIZE)); - (void) dictinsert(d, "BLOCK_SIZE", newintobject(CL_BLOCK_SIZE)); - (void) dictinsert(d, "PREROLL", newintobject(CL_PREROLL)); - (void) dictinsert(d, "FRAME_TYPE", newintobject(CL_FRAME_TYPE)); - (void) dictinsert(d, "ALGORITHM_ID", newintobject(CL_ALGORITHM_ID)); - (void) dictinsert(d, "ALGORITHM_VERSION", - newintobject(CL_ALGORITHM_VERSION)); - (void) dictinsert(d, "ORIENTATION", newintobject(CL_ORIENTATION)); - (void) dictinsert(d, "NUMBER_OF_FRAMES", - newintobject(CL_NUMBER_OF_FRAMES)); - (void) dictinsert(d, "SPEED", newintobject(CL_SPEED)); - (void) dictinsert(d, "LAST_FRAME_INDEX", - newintobject(CL_LAST_FRAME_INDEX)); + (void) PyDict_SetItemString(d, "MPEG_VIDEO", + PyInt_FromLong(CL_MPEG_VIDEO)); + (void) PyDict_SetItemString(d, "MVC1", PyInt_FromLong(CL_MVC1)); + (void) PyDict_SetItemString(d, "RTR", PyInt_FromLong(CL_RTR)); + (void) PyDict_SetItemString(d, "RTR1", PyInt_FromLong(CL_RTR1)); + (void) PyDict_SetItemString(d, "HDCC", PyInt_FromLong(CL_HDCC)); + (void) PyDict_SetItemString(d, "MVC2", PyInt_FromLong(CL_MVC2)); + (void) PyDict_SetItemString(d, "RLE24", PyInt_FromLong(CL_RLE24)); + (void) PyDict_SetItemString(d, "MAX_NUMBER_OF_PARAMS", + PyInt_FromLong(CL_MAX_NUMBER_OF_PARAMS)); + (void) PyDict_SetItemString(d, "IMAGE_WIDTH", + PyInt_FromLong(CL_IMAGE_WIDTH)); + (void) PyDict_SetItemString(d, "IMAGE_HEIGHT", + PyInt_FromLong(CL_IMAGE_HEIGHT)); + (void) PyDict_SetItemString(d, "ORIGINAL_FORMAT", + PyInt_FromLong(CL_ORIGINAL_FORMAT)); + (void) PyDict_SetItemString(d, "INTERNAL_FORMAT", + PyInt_FromLong(CL_INTERNAL_FORMAT)); + (void) PyDict_SetItemString(d, "COMPONENTS", + PyInt_FromLong(CL_COMPONENTS)); + (void) PyDict_SetItemString(d, "BITS_PER_COMPONENT", + PyInt_FromLong(CL_BITS_PER_COMPONENT)); + (void) PyDict_SetItemString(d, "FRAME_RATE", + PyInt_FromLong(CL_FRAME_RATE)); + (void) PyDict_SetItemString(d, "COMPRESSION_RATIO", + PyInt_FromLong(CL_COMPRESSION_RATIO)); + (void) PyDict_SetItemString(d, "EXACT_COMPRESSION_RATIO", + PyInt_FromLong(CL_EXACT_COMPRESSION_RATIO)); + (void) PyDict_SetItemString(d, "FRAME_BUFFER_SIZE", + PyInt_FromLong(CL_FRAME_BUFFER_SIZE)); + (void) PyDict_SetItemString(d, "COMPRESSED_BUFFER_SIZE", + PyInt_FromLong(CL_COMPRESSED_BUFFER_SIZE)); + (void) PyDict_SetItemString(d, "BLOCK_SIZE", + PyInt_FromLong(CL_BLOCK_SIZE)); + (void) PyDict_SetItemString(d, "PREROLL", PyInt_FromLong(CL_PREROLL)); + (void) PyDict_SetItemString(d, "FRAME_TYPE", + PyInt_FromLong(CL_FRAME_TYPE)); + (void) PyDict_SetItemString(d, "ALGORITHM_ID", + PyInt_FromLong(CL_ALGORITHM_ID)); + (void) PyDict_SetItemString(d, "ALGORITHM_VERSION", + PyInt_FromLong(CL_ALGORITHM_VERSION)); + (void) PyDict_SetItemString(d, "ORIENTATION", + PyInt_FromLong(CL_ORIENTATION)); + (void) PyDict_SetItemString(d, "NUMBER_OF_FRAMES", + PyInt_FromLong(CL_NUMBER_OF_FRAMES)); + (void) PyDict_SetItemString(d, "SPEED", PyInt_FromLong(CL_SPEED)); + (void) PyDict_SetItemString(d, "LAST_FRAME_INDEX", + PyInt_FromLong(CL_LAST_FRAME_INDEX)); #ifdef IRIX_5_3_LIBRARY - (void) dictinsert(d, "ENABLE_IMAGEINFO", - newintobject(CL_ENABLE_IMAGEINFO)); - (void) dictinsert(d, "INTERNAL_IMAGE_WIDTH", - newintobject(CL_INTERNAL_IMAGE_WIDTH)); - (void) dictinsert(d, "INTERNAL_IMAGE_HEIGHT", - newintobject(CL_INTERNAL_IMAGE_HEIGHT)); + (void) PyDict_SetItemString(d, "ENABLE_IMAGEINFO", + PyInt_FromLong(CL_ENABLE_IMAGEINFO)); + (void) PyDict_SetItemString(d, "INTERNAL_IMAGE_WIDTH", + PyInt_FromLong(CL_INTERNAL_IMAGE_WIDTH)); + (void) PyDict_SetItemString(d, "INTERNAL_IMAGE_HEIGHT", + PyInt_FromLong(CL_INTERNAL_IMAGE_HEIGHT)); #endif - (void) dictinsert(d, "NUMBER_OF_PARAMS", - newintobject(CL_NUMBER_OF_PARAMS)); + (void) PyDict_SetItemString(d, "NUMBER_OF_PARAMS", + PyInt_FromLong(CL_NUMBER_OF_PARAMS)); #ifdef IRIX_5_3_LIBRARY - (void) dictinsert(d, "MVC2_LUMA_THRESHOLD", - newintobject(CL_MVC2_LUMA_THRESHOLD)); - (void) dictinsert(d, "MVC2_CHROMA_THRESHOLD", - newintobject(CL_MVC2_CHROMA_THRESHOLD)); - (void) dictinsert(d, "MVC2_EDGE_THRESHOLD", - newintobject(CL_MVC2_EDGE_THRESHOLD)); - (void) dictinsert(d, "MVC2_BLENDING", newintobject(CL_MVC2_BLENDING)); - (void) dictinsert(d, "MVC2_BLENDING_OFF", - newintobject(CL_MVC2_BLENDING_OFF)); - (void) dictinsert(d, "MVC2_BLENDING_ON", - newintobject(CL_MVC2_BLENDING_ON)); - (void) dictinsert(d, "JPEG_QUALITY_FACTOR", - newintobject(CL_JPEG_QUALITY_FACTOR)); - (void) dictinsert(d, "JPEG_STREAM_HEADERS", - newintobject(CL_JPEG_STREAM_HEADERS)); - (void) dictinsert(d, "JPEG_QUANTIZATION_TABLES", - newintobject(CL_JPEG_QUANTIZATION_TABLES)); - (void) dictinsert(d, "JPEG_NUM_PARAMS", - newintobject(CL_JPEG_NUM_PARAMS)); - (void) dictinsert(d, "RTR_QUALITY_LEVEL", - newintobject(CL_RTR_QUALITY_LEVEL)); - (void) dictinsert(d, "HDCC_TILE_THRESHOLD", - newintobject(CL_HDCC_TILE_THRESHOLD)); - (void) dictinsert(d, "HDCC_SAMPLES_PER_TILE", - newintobject(CL_HDCC_SAMPLES_PER_TILE)); + (void) PyDict_SetItemString(d, "MVC2_LUMA_THRESHOLD", + PyInt_FromLong(CL_MVC2_LUMA_THRESHOLD)); + (void) PyDict_SetItemString(d, "MVC2_CHROMA_THRESHOLD", + PyInt_FromLong(CL_MVC2_CHROMA_THRESHOLD)); + (void) PyDict_SetItemString(d, "MVC2_EDGE_THRESHOLD", + PyInt_FromLong(CL_MVC2_EDGE_THRESHOLD)); + (void) PyDict_SetItemString(d, "MVC2_BLENDING", + PyInt_FromLong(CL_MVC2_BLENDING)); + (void) PyDict_SetItemString(d, "MVC2_BLENDING_OFF", + PyInt_FromLong(CL_MVC2_BLENDING_OFF)); + (void) PyDict_SetItemString(d, "MVC2_BLENDING_ON", + PyInt_FromLong(CL_MVC2_BLENDING_ON)); + (void) PyDict_SetItemString(d, "JPEG_QUALITY_FACTOR", + PyInt_FromLong(CL_JPEG_QUALITY_FACTOR)); + (void) PyDict_SetItemString(d, "JPEG_STREAM_HEADERS", + PyInt_FromLong(CL_JPEG_STREAM_HEADERS)); + (void) PyDict_SetItemString(d, "JPEG_QUANTIZATION_TABLES", + PyInt_FromLong(CL_JPEG_QUANTIZATION_TABLES)); + (void) PyDict_SetItemString(d, "JPEG_NUM_PARAMS", + PyInt_FromLong(CL_JPEG_NUM_PARAMS)); + (void) PyDict_SetItemString(d, "RTR_QUALITY_LEVEL", + PyInt_FromLong(CL_RTR_QUALITY_LEVEL)); + (void) PyDict_SetItemString(d, "HDCC_TILE_THRESHOLD", + PyInt_FromLong(CL_HDCC_TILE_THRESHOLD)); + (void) PyDict_SetItemString(d, "HDCC_SAMPLES_PER_TILE", + PyInt_FromLong(CL_HDCC_SAMPLES_PER_TILE)); #endif - (void) dictinsert(d, "END_OF_SEQUENCE", - newintobject(CL_END_OF_SEQUENCE)); - (void) dictinsert(d, "CHANNEL_POLICY", - newintobject(CL_CHANNEL_POLICY)); - (void) dictinsert(d, "NOISE_MARGIN", newintobject(CL_NOISE_MARGIN)); - (void) dictinsert(d, "BITRATE_POLICY", - newintobject(CL_BITRATE_POLICY)); - (void) dictinsert(d, "BITRATE_TARGET", - newintobject(CL_BITRATE_TARGET)); - (void) dictinsert(d, "LAYER", newintobject(CL_LAYER)); - (void) dictinsert(d, "ENUM_VALUE", newintobject(CL_ENUM_VALUE)); - (void) dictinsert(d, "RANGE_VALUE", newintobject(CL_RANGE_VALUE)); - (void) dictinsert(d, "FLOATING_ENUM_VALUE", - newintobject(CL_FLOATING_ENUM_VALUE)); - (void) dictinsert(d, "FLOATING_RANGE_VALUE", - newintobject(CL_FLOATING_RANGE_VALUE)); - (void) dictinsert(d, "DECOMPRESSOR", newintobject(CL_DECOMPRESSOR)); - (void) dictinsert(d, "COMPRESSOR", newintobject(CL_COMPRESSOR)); - (void) dictinsert(d, "CODEC", newintobject(CL_CODEC)); - (void) dictinsert(d, "NONE", newintobject(CL_NONE)); + (void) PyDict_SetItemString(d, "END_OF_SEQUENCE", + PyInt_FromLong(CL_END_OF_SEQUENCE)); + (void) PyDict_SetItemString(d, "CHANNEL_POLICY", + PyInt_FromLong(CL_CHANNEL_POLICY)); + (void) PyDict_SetItemString(d, "NOISE_MARGIN", + PyInt_FromLong(CL_NOISE_MARGIN)); + (void) PyDict_SetItemString(d, "BITRATE_POLICY", + PyInt_FromLong(CL_BITRATE_POLICY)); + (void) PyDict_SetItemString(d, "BITRATE_TARGET", + PyInt_FromLong(CL_BITRATE_TARGET)); + (void) PyDict_SetItemString(d, "LAYER", PyInt_FromLong(CL_LAYER)); + (void) PyDict_SetItemString(d, "ENUM_VALUE", + PyInt_FromLong(CL_ENUM_VALUE)); + (void) PyDict_SetItemString(d, "RANGE_VALUE", + PyInt_FromLong(CL_RANGE_VALUE)); + (void) PyDict_SetItemString(d, "FLOATING_ENUM_VALUE", + PyInt_FromLong(CL_FLOATING_ENUM_VALUE)); + (void) PyDict_SetItemString(d, "FLOATING_RANGE_VALUE", + PyInt_FromLong(CL_FLOATING_RANGE_VALUE)); + (void) PyDict_SetItemString(d, "DECOMPRESSOR", + PyInt_FromLong(CL_DECOMPRESSOR)); + (void) PyDict_SetItemString(d, "COMPRESSOR", + PyInt_FromLong(CL_COMPRESSOR)); + (void) PyDict_SetItemString(d, "CODEC", PyInt_FromLong(CL_CODEC)); + (void) PyDict_SetItemString(d, "NONE", PyInt_FromLong(CL_NONE)); #ifdef IRIX_5_3_LIBRARY - (void) dictinsert(d, "BUF_FRAME", newintobject(CL_BUF_FRAME)); - (void) dictinsert(d, "BUF_DATA", newintobject(CL_BUF_DATA)); + (void) PyDict_SetItemString(d, "BUF_FRAME", + PyInt_FromLong(CL_BUF_FRAME)); + (void) PyDict_SetItemString(d, "BUF_DATA", + PyInt_FromLong(CL_BUF_DATA)); #endif #ifdef CL_FRAME - (void) dictinsert(d, "FRAME", newintobject(CL_FRAME)); - (void) dictinsert(d, "DATA", newintobject(CL_DATA)); + (void) PyDict_SetItemString(d, "FRAME", PyInt_FromLong(CL_FRAME)); + (void) PyDict_SetItemString(d, "DATA", PyInt_FromLong(CL_DATA)); #endif - (void) dictinsert(d, "NONE", newintobject(CL_NONE)); - (void) dictinsert(d, "KEYFRAME", newintobject(CL_KEYFRAME)); - (void) dictinsert(d, "INTRA", newintobject(CL_INTRA)); - (void) dictinsert(d, "PREDICTED", newintobject(CL_PREDICTED)); - (void) dictinsert(d, "BIDIRECTIONAL", newintobject(CL_BIDIRECTIONAL)); - (void) dictinsert(d, "TOP_DOWN", newintobject(CL_TOP_DOWN)); - (void) dictinsert(d, "BOTTOM_UP", newintobject(CL_BOTTOM_UP)); + (void) PyDict_SetItemString(d, "NONE", PyInt_FromLong(CL_NONE)); + (void) PyDict_SetItemString(d, "KEYFRAME", + PyInt_FromLong(CL_KEYFRAME)); + (void) PyDict_SetItemString(d, "INTRA", PyInt_FromLong(CL_INTRA)); + (void) PyDict_SetItemString(d, "PREDICTED", + PyInt_FromLong(CL_PREDICTED)); + (void) PyDict_SetItemString(d, "BIDIRECTIONAL", + PyInt_FromLong(CL_BIDIRECTIONAL)); + (void) PyDict_SetItemString(d, "TOP_DOWN", + PyInt_FromLong(CL_TOP_DOWN)); + (void) PyDict_SetItemString(d, "BOTTOM_UP", + PyInt_FromLong(CL_BOTTOM_UP)); #ifdef IRIX_5_3_LIBRARY - (void) dictinsert(d, "CONTINUOUS_BLOCK", - newintobject(CL_CONTINUOUS_BLOCK)); - (void) dictinsert(d, "CONTINUOUS_NONBLOCK", - newintobject(CL_CONTINUOUS_NONBLOCK)); - (void) dictinsert(d, "EXTERNAL_DEVICE", - newintobject((long)CL_EXTERNAL_DEVICE)); + (void) PyDict_SetItemString(d, "CONTINUOUS_BLOCK", + PyInt_FromLong(CL_CONTINUOUS_BLOCK)); + (void) PyDict_SetItemString(d, "CONTINUOUS_NONBLOCK", + PyInt_FromLong(CL_CONTINUOUS_NONBLOCK)); + (void) PyDict_SetItemString(d, "EXTERNAL_DEVICE", + PyInt_FromLong((long)CL_EXTERNAL_DEVICE)); #endif - (void) dictinsert(d, "AWCMP_STEREO", newintobject(AWCMP_STEREO)); - (void) dictinsert(d, "AWCMP_JOINT_STEREO", - newintobject(AWCMP_JOINT_STEREO)); - (void) dictinsert(d, "AWCMP_INDEPENDENT", - newintobject(AWCMP_INDEPENDENT)); - (void) dictinsert(d, "AWCMP_FIXED_RATE", - newintobject(AWCMP_FIXED_RATE)); - (void) dictinsert(d, "AWCMP_CONST_QUAL", - newintobject(AWCMP_CONST_QUAL)); - (void) dictinsert(d, "AWCMP_LOSSLESS", newintobject(AWCMP_LOSSLESS)); - (void) dictinsert(d, "AWCMP_MPEG_LAYER_I", - newintobject(AWCMP_MPEG_LAYER_I)); - (void) dictinsert(d, "AWCMP_MPEG_LAYER_II", - newintobject(AWCMP_MPEG_LAYER_II)); - (void) dictinsert(d, "HEADER_START_CODE", - newintobject(CL_HEADER_START_CODE)); - (void) dictinsert(d, "BAD_NO_BUFFERSPACE", - newintobject(CL_BAD_NO_BUFFERSPACE)); - (void) dictinsert(d, "BAD_PVBUFFER", newintobject(CL_BAD_PVBUFFER)); - (void) dictinsert(d, "BAD_BUFFERLENGTH_NEG", - newintobject(CL_BAD_BUFFERLENGTH_NEG)); - (void) dictinsert(d, "BAD_BUFFERLENGTH_ODD", - newintobject(CL_BAD_BUFFERLENGTH_ODD)); - (void) dictinsert(d, "BAD_PARAM", newintobject(CL_BAD_PARAM)); - (void) dictinsert(d, "BAD_COMPRESSION_SCHEME", - newintobject(CL_BAD_COMPRESSION_SCHEME)); - (void) dictinsert(d, "BAD_COMPRESSOR_HANDLE", - newintobject(CL_BAD_COMPRESSOR_HANDLE)); - (void) dictinsert(d, "BAD_COMPRESSOR_HANDLE_POINTER", - newintobject(CL_BAD_COMPRESSOR_HANDLE_POINTER)); - (void) dictinsert(d, "BAD_BUFFER_HANDLE", - newintobject(CL_BAD_BUFFER_HANDLE)); - (void) dictinsert(d, "BAD_BUFFER_QUERY_SIZE", - newintobject(CL_BAD_BUFFER_QUERY_SIZE)); - (void) dictinsert(d, "JPEG_ERROR", newintobject(CL_JPEG_ERROR)); - (void) dictinsert(d, "BAD_FRAME_SIZE", - newintobject(CL_BAD_FRAME_SIZE)); - (void) dictinsert(d, "PARAM_OUT_OF_RANGE", - newintobject(CL_PARAM_OUT_OF_RANGE)); - (void) dictinsert(d, "ADDED_ALGORITHM_ERROR", - newintobject(CL_ADDED_ALGORITHM_ERROR)); - (void) dictinsert(d, "BAD_ALGORITHM_TYPE", - newintobject(CL_BAD_ALGORITHM_TYPE)); - (void) dictinsert(d, "BAD_ALGORITHM_NAME", - newintobject(CL_BAD_ALGORITHM_NAME)); - (void) dictinsert(d, "BAD_BUFFERING", newintobject(CL_BAD_BUFFERING)); - (void) dictinsert(d, "BUFFER_NOT_CREATED", - newintobject(CL_BUFFER_NOT_CREATED)); - (void) dictinsert(d, "BAD_BUFFER_EXISTS", - newintobject(CL_BAD_BUFFER_EXISTS)); - (void) dictinsert(d, "BAD_INTERNAL_FORMAT", - newintobject(CL_BAD_INTERNAL_FORMAT)); - (void) dictinsert(d, "BAD_BUFFER_POINTER", - newintobject(CL_BAD_BUFFER_POINTER)); - (void) dictinsert(d, "FRAME_BUFFER_SIZE_ZERO", - newintobject(CL_FRAME_BUFFER_SIZE_ZERO)); - (void) dictinsert(d, "BAD_STREAM_HEADER", - newintobject(CL_BAD_STREAM_HEADER)); - (void) dictinsert(d, "BAD_LICENSE", newintobject(CL_BAD_LICENSE)); - (void) dictinsert(d, "AWARE_ERROR", newintobject(CL_AWARE_ERROR)); - (void) dictinsert(d, "BAD_BUFFER_SIZE_POINTER", - newintobject(CL_BAD_BUFFER_SIZE_POINTER)); - (void) dictinsert(d, "BAD_BUFFER_SIZE", - newintobject(CL_BAD_BUFFER_SIZE)); - (void) dictinsert(d, "BAD_BUFFER_TYPE", - newintobject(CL_BAD_BUFFER_TYPE)); - (void) dictinsert(d, "BAD_HEADER_SIZE", - newintobject(CL_BAD_HEADER_SIZE)); - (void) dictinsert(d, "BAD_FUNCTION_POINTER", - newintobject(CL_BAD_FUNCTION_POINTER)); - (void) dictinsert(d, "BAD_SCHEME_POINTER", - newintobject(CL_BAD_SCHEME_POINTER)); - (void) dictinsert(d, "BAD_STRING_POINTER", - newintobject(CL_BAD_STRING_POINTER)); - (void) dictinsert(d, "BAD_MIN_GT_MAX", - newintobject(CL_BAD_MIN_GT_MAX)); - (void) dictinsert(d, "BAD_INITIAL_VALUE", - newintobject(CL_BAD_INITIAL_VALUE)); - (void) dictinsert(d, "BAD_PARAM_ID_POINTER", - newintobject(CL_BAD_PARAM_ID_POINTER)); - (void) dictinsert(d, "BAD_PARAM_TYPE", - newintobject(CL_BAD_PARAM_TYPE)); - (void) dictinsert(d, "BAD_TEXT_STRING_PTR", - newintobject(CL_BAD_TEXT_STRING_PTR)); - (void) dictinsert(d, "BAD_FUNCTIONALITY", - newintobject(CL_BAD_FUNCTIONALITY)); - (void) dictinsert(d, "BAD_NUMBER_OF_BLOCKS", - newintobject(CL_BAD_NUMBER_OF_BLOCKS)); - (void) dictinsert(d, "BAD_BLOCK_SIZE", - newintobject(CL_BAD_BLOCK_SIZE)); - (void) dictinsert(d, "BAD_POINTER", newintobject(CL_BAD_POINTER)); - (void) dictinsert(d, "BAD_BOARD", newintobject(CL_BAD_BOARD)); - (void) dictinsert(d, "MVC2_ERROR", newintobject(CL_MVC2_ERROR)); + (void) PyDict_SetItemString(d, "AWCMP_STEREO", + PyInt_FromLong(AWCMP_STEREO)); + (void) PyDict_SetItemString(d, "AWCMP_JOINT_STEREO", + PyInt_FromLong(AWCMP_JOINT_STEREO)); + (void) PyDict_SetItemString(d, "AWCMP_INDEPENDENT", + PyInt_FromLong(AWCMP_INDEPENDENT)); + (void) PyDict_SetItemString(d, "AWCMP_FIXED_RATE", + PyInt_FromLong(AWCMP_FIXED_RATE)); + (void) PyDict_SetItemString(d, "AWCMP_CONST_QUAL", + PyInt_FromLong(AWCMP_CONST_QUAL)); + (void) PyDict_SetItemString(d, "AWCMP_LOSSLESS", + PyInt_FromLong(AWCMP_LOSSLESS)); + (void) PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_I", + PyInt_FromLong(AWCMP_MPEG_LAYER_I)); + (void) PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_II", + PyInt_FromLong(AWCMP_MPEG_LAYER_II)); + (void) PyDict_SetItemString(d, "HEADER_START_CODE", + PyInt_FromLong(CL_HEADER_START_CODE)); + (void) PyDict_SetItemString(d, "BAD_NO_BUFFERSPACE", + PyInt_FromLong(CL_BAD_NO_BUFFERSPACE)); + (void) PyDict_SetItemString(d, "BAD_PVBUFFER", + PyInt_FromLong(CL_BAD_PVBUFFER)); + (void) PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", + PyInt_FromLong(CL_BAD_BUFFERLENGTH_NEG)); + (void) PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", + PyInt_FromLong(CL_BAD_BUFFERLENGTH_ODD)); + (void) PyDict_SetItemString(d, "BAD_PARAM", + PyInt_FromLong(CL_BAD_PARAM)); + (void) PyDict_SetItemString(d, "BAD_COMPRESSION_SCHEME", + PyInt_FromLong(CL_BAD_COMPRESSION_SCHEME)); + (void) PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE", + PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE)); + (void) PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE_POINTER", + PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE_POINTER)); + (void) PyDict_SetItemString(d, "BAD_BUFFER_HANDLE", + PyInt_FromLong(CL_BAD_BUFFER_HANDLE)); + (void) PyDict_SetItemString(d, "BAD_BUFFER_QUERY_SIZE", + PyInt_FromLong(CL_BAD_BUFFER_QUERY_SIZE)); + (void) PyDict_SetItemString(d, "JPEG_ERROR", + PyInt_FromLong(CL_JPEG_ERROR)); + (void) PyDict_SetItemString(d, "BAD_FRAME_SIZE", + PyInt_FromLong(CL_BAD_FRAME_SIZE)); + (void) PyDict_SetItemString(d, "PARAM_OUT_OF_RANGE", + PyInt_FromLong(CL_PARAM_OUT_OF_RANGE)); + (void) PyDict_SetItemString(d, "ADDED_ALGORITHM_ERROR", + PyInt_FromLong(CL_ADDED_ALGORITHM_ERROR)); + (void) PyDict_SetItemString(d, "BAD_ALGORITHM_TYPE", + PyInt_FromLong(CL_BAD_ALGORITHM_TYPE)); + (void) PyDict_SetItemString(d, "BAD_ALGORITHM_NAME", + PyInt_FromLong(CL_BAD_ALGORITHM_NAME)); + (void) PyDict_SetItemString(d, "BAD_BUFFERING", + PyInt_FromLong(CL_BAD_BUFFERING)); + (void) PyDict_SetItemString(d, "BUFFER_NOT_CREATED", + PyInt_FromLong(CL_BUFFER_NOT_CREATED)); + (void) PyDict_SetItemString(d, "BAD_BUFFER_EXISTS", + PyInt_FromLong(CL_BAD_BUFFER_EXISTS)); + (void) PyDict_SetItemString(d, "BAD_INTERNAL_FORMAT", + PyInt_FromLong(CL_BAD_INTERNAL_FORMAT)); + (void) PyDict_SetItemString(d, "BAD_BUFFER_POINTER", + PyInt_FromLong(CL_BAD_BUFFER_POINTER)); + (void) PyDict_SetItemString(d, "FRAME_BUFFER_SIZE_ZERO", + PyInt_FromLong(CL_FRAME_BUFFER_SIZE_ZERO)); + (void) PyDict_SetItemString(d, "BAD_STREAM_HEADER", + PyInt_FromLong(CL_BAD_STREAM_HEADER)); + (void) PyDict_SetItemString(d, "BAD_LICENSE", + PyInt_FromLong(CL_BAD_LICENSE)); + (void) PyDict_SetItemString(d, "AWARE_ERROR", + PyInt_FromLong(CL_AWARE_ERROR)); + (void) PyDict_SetItemString(d, "BAD_BUFFER_SIZE_POINTER", + PyInt_FromLong(CL_BAD_BUFFER_SIZE_POINTER)); + (void) PyDict_SetItemString(d, "BAD_BUFFER_SIZE", + PyInt_FromLong(CL_BAD_BUFFER_SIZE)); + (void) PyDict_SetItemString(d, "BAD_BUFFER_TYPE", + PyInt_FromLong(CL_BAD_BUFFER_TYPE)); + (void) PyDict_SetItemString(d, "BAD_HEADER_SIZE", + PyInt_FromLong(CL_BAD_HEADER_SIZE)); + (void) PyDict_SetItemString(d, "BAD_FUNCTION_POINTER", + PyInt_FromLong(CL_BAD_FUNCTION_POINTER)); + (void) PyDict_SetItemString(d, "BAD_SCHEME_POINTER", + PyInt_FromLong(CL_BAD_SCHEME_POINTER)); + (void) PyDict_SetItemString(d, "BAD_STRING_POINTER", + PyInt_FromLong(CL_BAD_STRING_POINTER)); + (void) PyDict_SetItemString(d, "BAD_MIN_GT_MAX", + PyInt_FromLong(CL_BAD_MIN_GT_MAX)); + (void) PyDict_SetItemString(d, "BAD_INITIAL_VALUE", + PyInt_FromLong(CL_BAD_INITIAL_VALUE)); + (void) PyDict_SetItemString(d, "BAD_PARAM_ID_POINTER", + PyInt_FromLong(CL_BAD_PARAM_ID_POINTER)); + (void) PyDict_SetItemString(d, "BAD_PARAM_TYPE", + PyInt_FromLong(CL_BAD_PARAM_TYPE)); + (void) PyDict_SetItemString(d, "BAD_TEXT_STRING_PTR", + PyInt_FromLong(CL_BAD_TEXT_STRING_PTR)); + (void) PyDict_SetItemString(d, "BAD_FUNCTIONALITY", + PyInt_FromLong(CL_BAD_FUNCTIONALITY)); + (void) PyDict_SetItemString(d, "BAD_NUMBER_OF_BLOCKS", + PyInt_FromLong(CL_BAD_NUMBER_OF_BLOCKS)); + (void) PyDict_SetItemString(d, "BAD_BLOCK_SIZE", + PyInt_FromLong(CL_BAD_BLOCK_SIZE)); + (void) PyDict_SetItemString(d, "BAD_POINTER", + PyInt_FromLong(CL_BAD_POINTER)); + (void) PyDict_SetItemString(d, "BAD_BOARD", + PyInt_FromLong(CL_BAD_BOARD)); + (void) PyDict_SetItemString(d, "MVC2_ERROR", + PyInt_FromLong(CL_MVC2_ERROR)); #ifdef IRIX_5_3_LIBRARY - (void) dictinsert(d, "NEXT_NOT_AVAILABLE", - newintobject(CL_NEXT_NOT_AVAILABLE)); - (void) dictinsert(d, "SCHEME_BUSY", newintobject(CL_SCHEME_BUSY)); - (void) dictinsert(d, "SCHEME_NOT_AVAILABLE", - newintobject(CL_SCHEME_NOT_AVAILABLE)); + (void) PyDict_SetItemString(d, "NEXT_NOT_AVAILABLE", + PyInt_FromLong(CL_NEXT_NOT_AVAILABLE)); + (void) PyDict_SetItemString(d, "SCHEME_BUSY", + PyInt_FromLong(CL_SCHEME_BUSY)); + (void) PyDict_SetItemString(d, "SCHEME_NOT_AVAILABLE", + PyInt_FromLong(CL_SCHEME_NOT_AVAILABLE)); #endif #ifdef CL_LUMA_THRESHOLD /* backward compatibility */ - (void) dictinsert(d, "LUMA_THRESHOLD", - newintobject(CL_LUMA_THRESHOLD)); - (void) dictinsert(d, "CHROMA_THRESHOLD", - newintobject(CL_CHROMA_THRESHOLD)); - (void) dictinsert(d, "EDGE_THRESHOLD", - newintobject(CL_EDGE_THRESHOLD)); - (void) dictinsert(d, "BLENDING", newintobject(CL_BLENDING)); - (void) dictinsert(d, "QUALITY_FACTOR", - newintobject(CL_QUALITY_FACTOR)); - (void) dictinsert(d, "STREAM_HEADERS", - newintobject(CL_STREAM_HEADERS)); - (void) dictinsert(d, "QUALITY_LEVEL", newintobject(CL_QUALITY_LEVEL)); - (void) dictinsert(d, "TILE_THRESHOLD", - newintobject(CL_TILE_THRESHOLD)); - (void) dictinsert(d, "SAMPLES_PER_TILE", - newintobject(CL_SAMPLES_PER_TILE)); + (void) PyDict_SetItemString(d, "LUMA_THRESHOLD", + PyInt_FromLong(CL_LUMA_THRESHOLD)); + (void) PyDict_SetItemString(d, "CHROMA_THRESHOLD", + PyInt_FromLong(CL_CHROMA_THRESHOLD)); + (void) PyDict_SetItemString(d, "EDGE_THRESHOLD", + PyInt_FromLong(CL_EDGE_THRESHOLD)); + (void) PyDict_SetItemString(d, "BLENDING", + PyInt_FromLong(CL_BLENDING)); + (void) PyDict_SetItemString(d, "QUALITY_FACTOR", + PyInt_FromLong(CL_QUALITY_FACTOR)); + (void) PyDict_SetItemString(d, "STREAM_HEADERS", + PyInt_FromLong(CL_STREAM_HEADERS)); + (void) PyDict_SetItemString(d, "QUALITY_LEVEL", + PyInt_FromLong(CL_QUALITY_LEVEL)); + (void) PyDict_SetItemString(d, "TILE_THRESHOLD", + PyInt_FromLong(CL_TILE_THRESHOLD)); + (void) PyDict_SetItemString(d, "SAMPLES_PER_TILE", + PyInt_FromLong(CL_SAMPLES_PER_TILE)); #endif - if (err_occurred()) - fatal("can't initialize module cl"); + if (PyErr_Occurred()) + Py_FatalError("can't initialize module cl"); (void) clSetErrorHandler(cl_ErrorHandler); } |