* clmodule.c: use function prototypes (found and fixed some bugs this
way); more efficiently check whether parameters are float; removed
one argument from DecompressImage method; use clGetParam instead of
clGetParams where it makes sense; convert int parameters in
SetParams, SetParam, SetMin, SetMax, and SetDefault to float when
needed; added QuerySchemeFromHandle method
* Makefile: interchanged cstubs and cgen.py so that $> in rule gets
them in the right order
diff --git a/Modules/clmodule.c b/Modules/clmodule.c
index 0aeb296..655caca 100644
--- a/Modules/clmodule.c
+++ b/Modules/clmodule.c
@@ -25,6 +25,8 @@
/* Cl objects */
+#define CLDEBUG
+
#include <stdarg.h>
#include <cl.h>
#include "allobjects.h"
@@ -35,12 +37,23 @@
OB_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 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.
********************************************************************/
@@ -65,50 +78,47 @@
/*
* This assumes that params are always in the range 0 to some maximum.
- * This is not very efficient.
*/
static int
-param_type_is_float(CL_Handle comp, int param)
+param_type_is_float(clobject *self, int param)
{
int bufferlength;
- int *PVbuffer;
int ret;
- error_handler_called = 0;
- bufferlength = clQueryParams(comp, 0, 0);
- if (error_handler_called)
- return -1;
+ if (self->ob_paramtypes == NULL) {
+ error_handler_called = 0;
+ bufferlength = clQueryParams(self->ob_compressorHdl, 0, 0);
+ if (error_handler_called)
+ return -1;
- if (param < 0 || param >= bufferlength / 2)
- return -1;
+ self->ob_paramtypes = NEW(int, bufferlength);
+ if (self->ob_paramtypes == NULL)
+ return -1;
+ self->ob_nparams = bufferlength / 2;
- PVbuffer = NEW(int, bufferlength);
- if (PVbuffer == NULL)
- return -1;
-
- bufferlength = clQueryParams(comp, PVbuffer, bufferlength);
- if (error_handler_called) {
- DEL(PVbuffer);
- return -1;
+ (void) clQueryParams(self->ob_compressorHdl, self->ob_paramtypes, bufferlength);
+ if (error_handler_called) {
+ DEL(self->ob_paramtypes);
+ self->ob_paramtypes = NULL;
+ return -1;
+ }
}
- if (PVbuffer[param*2 + 1] == CL_FLOATING_ENUM_VALUE ||
- PVbuffer[param*2 + 1] == CL_FLOATING_RANGE_VALUE)
- ret = 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
- ret = 0;
-
- DEL(PVbuffer);
-
- return ret;
+ return 0;
}
/********************************************************************
Single image compression/decompression.
********************************************************************/
static object *
-cl_CompressImage(self, args)
- object *self, *args;
+cl_CompressImage(object *self, object *args)
{
int compressionScheme, width, height, originalFormat;
float compressionRatio;
@@ -153,19 +163,20 @@
}
static object *
-cl_DecompressImage(self, args)
- object *self, *args;
+cl_DecompressImage(object *self, object *args)
{
int compressionScheme, width, height, originalFormat;
char *compressedBuffer;
int compressedBufferSize, frameBufferSize;
object *frameBuffer;
- if (!getargs(args, "(iiiis#i)", &compressionScheme, &width, &height,
- &originalFormat, &compressedBuffer, &compressedBufferSize,
- &frameBufferSize))
+ if (!getargs(args, "(iiiis#)", &compressionScheme, &width, &height,
+ &originalFormat, &compressedBuffer,
+ &compressedBufferSize))
return NULL;
+ frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);
+
frameBuffer = newsizedstringobject(NULL, frameBufferSize);
if (frameBuffer == NULL)
return NULL;
@@ -186,18 +197,13 @@
/********************************************************************
Sequential compression/decompression.
********************************************************************/
-extern typeobject Cltype; /* Really static, forward */
-
#define CheckCompressor(self) if ((self)->ob_compressorHdl == NULL) { \
err_setstr(RuntimeError, "(de)compressor not active"); \
return NULL; \
}
static object *
-doClose(self, args, close_func)
- clobject *self;
- object *args;
- int (*close_func) PROTO((CL_Handle));
+doClose(clobject *self, object *args, int (*close_func)(CL_Handle))
{
CheckCompressor(self);
@@ -213,57 +219,51 @@
self->ob_compressorHdl = NULL;
+ if (self->ob_paramtypes)
+ DEL(self->ob_paramtypes);
+ self->ob_paramtypes = NULL;
+
INCREF(None);
return None;
}
static object *
-clm_CloseCompressor(self, args)
- clobject *self;
- object *args;
+clm_CloseCompressor(object *self, object *args)
{
- return doClose(self, args, clCloseCompressor);
+ return doClose(SELF, args, clCloseCompressor);
}
static object *
-clm_CloseDecompressor(self, args)
- clobject *self;
- object *args;
+clm_CloseDecompressor(object *self, object *args)
{
- return doClose(self, args, clCloseDecompressor);
+ return doClose(SELF, args, clCloseDecompressor);
}
static object *
-clm_Compress(self, args)
- clobject *self;
- object *args;
+clm_Compress(object *self, object *args)
{
int numberOfFrames;
- int frameBufferSize, compressedBufferSize;
+ int frameBufferSize, compressedBufferSize, size;
char *frameBuffer;
- int PVbuf[2];
object *data;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getargs(args, "(is#)", &numberOfFrames, &frameBuffer, &frameBufferSize))
return NULL;
- PVbuf[0] = CL_COMPRESSED_BUFFER_SIZE;
- PVbuf[1] = 0;
error_handler_called = 0;
- clGetParams(self->ob_compressorHdl, PVbuf, 2L);
+ size = clGetParam(SELF->ob_compressorHdl, CL_COMPRESSED_BUFFER_SIZE);
+ compressedBufferSize = size;
if (error_handler_called)
return NULL;
- data = newsizedstringobject(NULL, PVbuf[1]);
+ data = newsizedstringobject(NULL, size);
if (data == NULL)
return NULL;
- compressedBufferSize = PVbuf[1];
-
error_handler_called = 0;
- if (clCompress(self->ob_compressorHdl, numberOfFrames,
+ if (clCompress(SELF->ob_compressorHdl, numberOfFrames,
(void *) frameBuffer, &compressedBufferSize,
(void *) getstringvalue(data)) == FAILURE) {
DECREF(data);
@@ -272,11 +272,11 @@
return NULL;
}
- if (compressedBufferSize < PVbuf[1])
+ if (compressedBufferSize < size)
if (resizestring(&data, compressedBufferSize))
return NULL;
- if (compressedBufferSize > PVbuf[1]) {
+ if (compressedBufferSize > size) {
/* we didn't get all "compressed" data */
DECREF(data);
err_setstr(ClError, "compressed data is more than fitted");
@@ -287,35 +287,30 @@
}
static object *
-clm_Decompress(self, args)
- clobject *self;
- object *args;
+clm_Decompress(object *self, object *args)
{
- int PVbuf[2];
object *data;
int numberOfFrames;
char *compressedData;
- int compressedDataSize;
+ int compressedDataSize, dataSize;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getargs(args, "(is#)", &numberOfFrames, &compressedData,
&compressedDataSize))
return NULL;
- PVbuf[0] = CL_FRAME_BUFFER_SIZE;
- PVbuf[1] = 0;
error_handler_called = 0;
- clGetParams(self->ob_compressorHdl, PVbuf, 2L);
+ dataSize = clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE);
if (error_handler_called)
return NULL;
- data = newsizedstringobject(NULL, PVbuf[1]);
+ data = newsizedstringobject(NULL, dataSize);
if (data == NULL)
return NULL;
error_handler_called = 0;
- if (clDecompress(self->ob_compressorHdl, numberOfFrames,
+ if (clDecompress(SELF->ob_compressorHdl, numberOfFrames,
compressedDataSize, (void *) compressedData,
(void *) getstringvalue(data)) == FAILURE) {
DECREF(data);
@@ -328,11 +323,8 @@
}
static object *
-doParams(self, args, func, modified)
- clobject *self;
- object *args;
- void (*func)(CL_Handle, int *, int);
- int modified;
+doParams(clobject *self, object *args, int (*func)(CL_Handle, int *, int),
+ int modified)
{
object *list, *v;
int *PVbuffer;
@@ -357,9 +349,14 @@
if (is_floatobject(v)) {
number = getfloatvalue(v);
PVbuffer[i] = CL_TypeIsInt(number);
- } else if (is_intobject(v))
+ } else if (is_intobject(v)) {
PVbuffer[i] = getintvalue(v);
- else {
+ 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();
return NULL;
@@ -374,8 +371,7 @@
if (modified) {
for (i = 0; i < length; i++) {
if ((i & 1) &&
- param_type_is_float(self->ob_compressorHdl,
- PVbuffer[i-1]) > 0) {
+ param_type_is_float(self, PVbuffer[i-1]) > 0) {
number = CL_TypeIsFloat(PVbuffer[i]);
v = newfloatobject(number);
} else
@@ -391,26 +387,19 @@
}
static object *
-clm_GetParams(self, args)
- clobject *self;
- object *args;
+clm_GetParams(object *self, object *args)
{
- return doParams(self, args, clGetParams, 1);
+ return doParams(SELF, args, clGetParams, 1);
}
static object *
-clm_SetParams(self, args)
- clobject *self;
- object *args;
+clm_SetParams(object *self, object *args)
{
- return doParams(self, args, clSetParams, 0);
+ return doParams(SELF, args, clSetParams, 0);
}
static object *
-do_get(self, args, func)
- clobject *self;
- object *args;
- int (*func)(CL_Handle, int);
+do_get(clobject *self, object *args, int (*func)(CL_Handle, int))
{
int paramID, value;
float fvalue;
@@ -425,7 +414,7 @@
if (error_handler_called)
return NULL;
- if (param_type_is_float(self->ob_compressorHdl, paramID) > 0) {
+ if (param_type_is_float(self, paramID) > 0) {
fvalue = CL_TypeIsFloat(value);
return newfloatobject(fvalue);
}
@@ -434,31 +423,24 @@
}
static object *
-clm_GetParam(self, args)
- clobject *self;
- object *args;
+clm_GetParam(object *self, object *args)
{
- return do_get(self, args, clGetParam);
+ return do_get(SELF, args, clGetParam);
}
static object *
-clm_GetDefault(self, args)
- clobject *self;
- object *args;
+clm_GetDefault(object *self, object *args)
{
- return do_get(self, args, clGetDefault);
+ return do_get(SELF, args, clGetDefault);
}
static object *
-do_set(self, args, func)
- clobject *self;
- object *args;
- int (*func)(CL_Handle, int, int);
+clm_SetParam(object *self, object *args)
{
int paramID, value;
float fvalue;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getargs(args, "(ii)", ¶mID, &value)) {
err_clear();
@@ -468,50 +450,37 @@
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 = (*func)(self->ob_compressorHdl, paramID, value);
+ error_handler_called = 0;
+ value = clSetParam(SELF->ob_compressorHdl, paramID, value);
if (error_handler_called)
return NULL;
- if (param_type_is_float(self->ob_compressorHdl, paramID) > 0)
+ if (param_type_is_float(SELF, paramID) > 0)
return newfloatobject(CL_TypeIsFloat(value));
else
return newintobject(value);
}
static object *
-clm_SetParam(self, args)
- clobject *self;
- object *args;
-{
- return do_set(self, args, clSetParam);
-}
-
-static object *
-clm_SetDefault(self, args)
- clobject *self;
- object *args;
-{
- return do_set(self, args, clSetDefault);
-}
-
-static object *
-clm_GetParamID(self, args)
- clobject *self;
- object *args;
+clm_GetParamID(object *self, object *args)
{
char *name;
int value;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getargs(args, "s", &name))
return NULL;
error_handler_called = 0;
- value = clGetParamID(self->ob_compressorHdl, name);
+ value = clGetParamID(SELF->ob_compressorHdl, name);
if (value == FAILURE) {
if (!error_handler_called)
err_setstr(ClError, "getparamid failed");
@@ -522,22 +491,20 @@
}
static object *
-clm_QueryParams(self, args)
- clobject *self;
- object *args;
+clm_QueryParams(object *self, object *args)
{
int bufferlength;
int *PVbuffer;
object *list;
int i;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getnoarg(args))
return NULL;
error_handler_called = 0;
- bufferlength = clQueryParams(self->ob_compressorHdl, 0, 0);
+ bufferlength = clQueryParams(SELF->ob_compressorHdl, 0, 0);
if (error_handler_called)
return NULL;
@@ -545,7 +512,7 @@
if (PVbuffer == NULL)
return err_nomem();
- bufferlength = clQueryParams(self->ob_compressorHdl, PVbuffer,
+ bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer,
bufferlength);
if (error_handler_called) {
DEL(PVbuffer);
@@ -574,21 +541,19 @@
}
static object *
-clm_GetMinMax(self, args)
- clobject *self;
- object *args;
+clm_GetMinMax(object *self, object *args)
{
int param, min, max;
float fmin, fmax;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getargs(args, "i", ¶m))
return NULL;
- clGetMinMax(self->ob_compressorHdl, param, &min, &max);
+ clGetMinMax(SELF->ob_compressorHdl, param, &min, &max);
- if (param_type_is_float(self->ob_compressorHdl, param) > 0) {
+ if (param_type_is_float(SELF, param) > 0) {
fmin = CL_TypeIsFloat(min);
fmax = CL_TypeIsFloat(max);
return mkvalue("(ff)", fmin, fmax);
@@ -598,36 +563,72 @@
}
static object *
-clm_SetMin(self, args)
- clobject *self;
- object *args;
+do_set(clobject *self, object *args, int (*func)(int, int, int))
{
- return do_set(self, args, clSetMin);
+ int scheme, paramID, value;
+ float fvalue;
+
+ CheckCompressor(self);
+
+ scheme = clQuerySchemeFromHandle(self->ob_compressorHdl);
+
+ 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)')");
+ 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 = (*func)(scheme, paramID, value);
+ if (error_handler_called)
+ return NULL;
+
+ if (param_type_is_float(self, paramID) > 0)
+ return newfloatobject(CL_TypeIsFloat(value));
+ else
+ return newintobject(value);
}
static object *
-clm_SetMax(self, args)
- clobject *self;
- object *args;
+clm_SetDefault(object *self, object *args)
{
- return do_set(self, args, clSetMax);
+ return do_set(SELF, args, clSetDefault);
}
static object *
-clm_GetName(self, args)
- clobject *self;
- object *args;
+clm_SetMin(object *self, object *args)
+{
+ return do_set(SELF, args, clSetMin);
+}
+
+static object *
+clm_SetMax(object *self, object *args)
+{
+ return do_set(SELF, args, clSetMax);
+}
+
+static object *
+clm_GetName(object *self, object *args)
{
int param;
char *name;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getargs(args, "i", ¶m))
return NULL;
error_handler_called = 0;
- name = clGetName(self->ob_compressorHdl, param);
+ name = clGetName(SELF->ob_compressorHdl, param);
if (name == NULL || error_handler_called) {
if (!error_handler_called)
err_setstr(ClError, "getname failed");
@@ -638,19 +639,28 @@
}
static object *
-clm_ReadHeader(self, args)
- clobject *self;
- object *args;
+clm_QuerySchemeFromHandle(object *self, object *args)
+{
+ CheckCompressor(SELF);
+
+ if (!getnoarg(args))
+ return NULL;
+
+ return newintobject(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
+}
+
+static object *
+clm_ReadHeader(object *self, object *args)
{
char *header;
int headerSize;
- CheckCompressor(self);
+ CheckCompressor(SELF);
if (!getargs(args, "s#", &header, &headerSize))
return NULL;
- return newintobject(clReadHeader(self->ob_compressorHdl,
+ return newintobject(clReadHeader(SELF->ob_compressorHdl,
headerSize, header));
}
@@ -665,6 +675,7 @@
{"GetParamID", clm_GetParamID},
{"GetParams", clm_GetParams},
{"QueryParams", clm_QueryParams},
+ {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle},
{"SetDefault", clm_SetDefault},
{"SetMax", clm_SetMax},
{"SetMin", clm_SetMin},
@@ -685,6 +696,7 @@
{"GetParams", clm_GetParams},
{"ReadHeader", clm_ReadHeader},
{"QueryParams", clm_QueryParams},
+ {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle},
{"SetDefault", clm_SetDefault},
{"SetMax", clm_SetMax},
{"SetMin", clm_SetMin},
@@ -694,27 +706,24 @@
};
static void
-cl_dealloc(self)
- clobject *self;
+cl_dealloc(object *self)
{
- if (self->ob_compressorHdl) {
- if (self->ob_isCompressor)
- clCloseCompressor(self->ob_compressorHdl);
+ if (SELF->ob_compressorHdl) {
+ if (SELF->ob_isCompressor)
+ clCloseCompressor(SELF->ob_compressorHdl);
else
- clCloseDecompressor(self->ob_compressorHdl);
+ clCloseDecompressor(SELF->ob_compressorHdl);
}
DEL(self);
}
static object *
-cl_getattr(self, name)
- clobject *self;
- char *name;
+cl_getattr(object *self, char *name)
{
- if (self->ob_isCompressor)
- return findmethod(compressor_methods, (object *)self, name);
+ if (SELF->ob_isCompressor)
+ return findmethod(compressor_methods, self, name);
else
- return findmethod(decompressor_methods, (object *) self, name);
+ return findmethod(decompressor_methods, self, name);
}
static typeobject Cltype = {
@@ -736,10 +745,8 @@
};
static object *
-doOpen(self, args, open_func, iscompressor)
- object *self, *args;
- int (*open_func) PROTO((int, CL_Handle *));
- int iscompressor;
+doOpen(object *self, object *args, int (*open_func)(int, CL_Handle *),
+ int iscompressor)
{
int scheme;
clobject *new;
@@ -753,6 +760,7 @@
new->ob_compressorHdl = NULL;
new->ob_isCompressor = iscompressor;
+ new->ob_paramtypes = NULL;
error_handler_called = 0;
if ((*open_func)(scheme, &new->ob_compressorHdl) == FAILURE) {
@@ -765,22 +773,19 @@
}
static object *
-cl_OpenCompressor(self, args)
- object *self, *args;
+cl_OpenCompressor(object *self, object *args)
{
return doOpen(self, args, clOpenCompressor, 1);
}
static object *
-cl_OpenDecompressor(self, args)
- object *self, *args;
+cl_OpenDecompressor(object *self, object *args)
{
return doOpen(self, args, clOpenDecompressor, 0);
}
static object *
-cl_QueryScheme(self, args)
- object *self, *args;
+cl_QueryScheme(object *self, object *args)
{
char *header;
int headerlen;
@@ -799,8 +804,7 @@
}
static object *
-cl_QueryMaxHeaderSize(self, args)
- object *self, *args;
+cl_QueryMaxHeaderSize(object *self, object *args)
{
int scheme;
@@ -811,8 +815,7 @@
}
static object *
-cl_QueryAlgorithms(self, args)
- object *self, *args;
+cl_QueryAlgorithms(object *self, object *args)
{
int algorithmMediaType;
int bufferlength;
@@ -861,8 +864,7 @@
}
static object *
-cl_QuerySchemeFromName(self, args)
- object *self, *args;
+cl_QuerySchemeFromName(object *self, object *args)
{
int algorithmMediaType;
char *name;
@@ -882,8 +884,7 @@
}
static object *
-cl_GetAlgorithmName(self, args)
- object *self, *args;
+cl_GetAlgorithmName(object *self, object *args)
{
int scheme;
char *name;
@@ -900,6 +901,24 @@
return newstringobject(name);
}
+#ifdef CLDEBUG
+static object *
+cvt_type(object *self, object *args)
+{
+ int number;
+ float fnumber;
+
+ if (getargs(args, "i", &number))
+ return newfloatobject(CL_TypeIsFloat(number));
+ else {
+ err_clear();
+ if (getargs(args, "f", &fnumber))
+ return newintobject(CL_TypeIsInt(fnumber));
+ return NULL;
+ }
+}
+#endif
+
static struct methodlist cl_methods[] = {
{"CompressImage", cl_CompressImage},
{"DecompressImage", cl_DecompressImage},
@@ -910,6 +929,9 @@
{"QueryMaxHeaderSize", cl_QueryMaxHeaderSize},
{"QueryScheme", cl_QueryScheme},
{"QuerySchemeFromName", cl_QuerySchemeFromName},
+#ifdef CLDEBUG
+ {"cvt_type", cvt_type},
+#endif
{NULL, NULL} /* Sentinel */
};