1 

     2 

     3 /* Cl objects */

     4 

     5 #define CLDEBUG

     6 

     7 #include <stdarg.h>

     8 #include <cl.h>

     9 #if defined(CL_JPEG_SOFTWARE) && !defined(CL_JPEG_COSMO)

    10 #include <dmedia/cl_cosmo.h>

    11 #endif

    12 #include "Python.h"

    13 

    14 typedef struct {

    15 	PyObject_HEAD

    16 	int ob_isCompressor;	/* Compressor or Decompressor */

    17 	CL_Handle ob_compressorHdl;

    18 	int *ob_paramtypes;

    19 	int ob_nparams;

    20 } clobject;

    21 

    22 static PyObject *ClError;		/* exception cl.error */

    23 

    24 static int error_handler_called = 0;

    25 

    26 /*

    27  * We want to use the function prototypes that are available in the C

    28  * compiler on the SGI.  Because of that, we need to declare the first

    29  * argument of the compressor and decompressor methods as "object *",

    30  * even though they are really "clobject *".  Therefore we cast the

    31  * argument to the proper type using this macro.

    32  */

    33 #define SELF	((clobject *) self)

    34 

    35 /********************************************************************

    36 			  Utility routines.

    37 ********************************************************************/

    38 static void

    39 cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...)

    40 {

    41 	va_list ap;

    42 	char errbuf[BUFSIZ];	/* hopefully big enough */

    43 	char *p;

    44 

    45 	if (PyErr_Occurred())	/* don't change existing error */

    46 		return;

    47 	error_handler_called = 1;

    48 	va_start(ap, fmt);

    49 	vsprintf(errbuf, fmt, ap);

    50 	va_end(ap);

    51 	p = &errbuf[strlen(errbuf) - 1]; /* swat the line feed */

    52 	if (*p == '\n')

    53 		*p = 0;

    54 	PyErr_SetString(ClError, errbuf);

    55 }

    56 

    57 /*

    58  * This assumes that params are always in the range 0 to some maximum.

    59  */

    60 static int

    61 param_type_is_float(clobject *self, int param)

    62 {

    63 	int bufferlength;

    64 

    65 	if (self->ob_paramtypes == NULL) {

    66 		error_handler_called = 0;

    67 		bufferlength = clQueryParams(self->ob_compressorHdl, 0, 0);

    68 		if (error_handler_called)

    69 			return -1;

    70 

    71 		self->ob_paramtypes = PyMem_NEW(int, bufferlength);

    72 		if (self->ob_paramtypes == NULL)

    73 			return -1;

    74 		self->ob_nparams = bufferlength / 2;

    75 

    76 		(void) clQueryParams(self->ob_compressorHdl,

    77 				     self->ob_paramtypes, bufferlength);

    78 		if (error_handler_called) {

    79 			PyMem_DEL(self->ob_paramtypes);

    80 			self->ob_paramtypes = NULL;

    81 			return -1;

    82 		}

    83 	}

    84 

    85 	if (param < 0 || param >= self->ob_nparams)

    86 		return -1;

    87 

    88 	if (self->ob_paramtypes[param*2 + 1] == CL_FLOATING_ENUM_VALUE ||

    89 	    self->ob_paramtypes[param*2 + 1] == CL_FLOATING_RANGE_VALUE)

    90 		return 1;

    91 	else

    92 		return 0;

    93 }

    94 

    95 /********************************************************************

    96 	       Single image compression/decompression.

    97 ********************************************************************/

    98 static PyObject *

    99 cl_CompressImage(PyObject *self, PyObject *args)

   100 {

   101 	int compressionScheme, width, height, originalFormat;

   102 	float compressionRatio;

   103 	int frameBufferSize, compressedBufferSize;

   104 	char *frameBuffer;

   105 	PyObject *compressedBuffer;

   106 

   107 	if (!PyArg_ParseTuple(args, "iiiifs#", &compressionScheme,

   108 			 &width, &height,

   109 			 &originalFormat, &compressionRatio, &frameBuffer,

   110 			 &frameBufferSize))

   111 		return NULL;

   112 

   113   retry:

   114 	compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);

   115 	if (compressedBuffer == NULL)

   116 		return NULL;

   117 

   118 	compressedBufferSize = frameBufferSize;

   119 	error_handler_called = 0;

   120 	if (clCompressImage(compressionScheme, width, height, originalFormat,

   121 			    compressionRatio, (void *) frameBuffer,

   122 			    &compressedBufferSize,

   123 			    (void *) PyString_AsString(compressedBuffer))

   124 	    == FAILURE || error_handler_called) {

   125 		Py_DECREF(compressedBuffer);

   126 		if (!error_handler_called)

   127 			PyErr_SetString(ClError, "clCompressImage failed");

   128 		return NULL;

   129 	}

   130 

   131 	if (compressedBufferSize > frameBufferSize) {

   132 		frameBufferSize = compressedBufferSize;

   133 		Py_DECREF(compressedBuffer);

   134 		goto retry;

   135 	}

   136 

   137 	if (compressedBufferSize < frameBufferSize)

   138 		_PyString_Resize(&compressedBuffer, compressedBufferSize);

   139 

   140 	return compressedBuffer;

   141 }

   142 

   143 static PyObject *

   144 cl_DecompressImage(PyObject *self, PyObject *args)

   145 {

   146 	int compressionScheme, width, height, originalFormat;

   147 	char *compressedBuffer;

   148 	int compressedBufferSize, frameBufferSize;

   149 	PyObject *frameBuffer;

   150 

   151 	if (!PyArg_ParseTuple(args, "iiiis#", &compressionScheme, &width, &height,

   152 			 &originalFormat, &compressedBuffer,

   153 			 &compressedBufferSize))

   154 		return NULL;

   155 

   156 	frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);

   157 

   158 	frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);

   159 	if (frameBuffer == NULL)

   160 		return NULL;

   161 

   162 	error_handler_called = 0;

   163 	if (clDecompressImage(compressionScheme, width, height, originalFormat,

   164 			      compressedBufferSize, compressedBuffer,

   165 			      (void *) PyString_AsString(frameBuffer))

   166 	    == FAILURE || error_handler_called) {

   167 		Py_DECREF(frameBuffer);

   168 		if (!error_handler_called)

   169 			PyErr_SetString(ClError, "clDecompressImage failed");

   170 		return NULL;

   171 	}

   172 

   173 	return frameBuffer;

   174 }

   175 

   176 /********************************************************************

   177 		Sequential compression/decompression.

   178 ********************************************************************/

   179 #define CheckCompressor(self)	if ((self)->ob_compressorHdl == NULL) { \

   180 	PyErr_SetString(PyExc_RuntimeError, "(de)compressor not active"); \

   181 	return NULL; \

   182 }

   183 

   184 static PyObject *

   185 doClose(clobject *self, int (*close_func)(CL_Handle))

   186 {

   187 	CheckCompressor(self);

   188 

   189 	error_handler_called = 0;

   190 	if ((*close_func)(self->ob_compressorHdl) == FAILURE ||

   191 	    error_handler_called) {

   192 		if (!error_handler_called)

   193 			PyErr_SetString(ClError, "close failed");

   194 		return NULL;

   195 	}

   196 

   197 	self->ob_compressorHdl = NULL;

   198 

   199 	if (self->ob_paramtypes)

   200 		PyMem_DEL(self->ob_paramtypes);

   201 	self->ob_paramtypes = NULL;

   202 

   203 	Py_INCREF(Py_None);

   204 	return Py_None;

   205 }

   206 

   207 static PyObject *

   208 clm_CloseCompressor(PyObject *self)

   209 {

   210 	return doClose(SELF, clCloseCompressor);

   211 }

   212 

   213 static PyObject *

   214 clm_CloseDecompressor(PyObject *self)

   215 {

   216 	return doClose(SELF, clCloseDecompressor);

   217 }

   218 

   219 static PyObject *

   220 clm_Compress(PyObject *self, PyObject *args)

   221 {

   222 	int numberOfFrames;

   223 	int frameBufferSize, compressedBufferSize, size;

   224 	char *frameBuffer;

   225 	PyObject *data;

   226 

   227 	CheckCompressor(SELF);

   228 

   229 	if (!PyArg_Parse(args, "(is#)", &numberOfFrames,

   230 			 &frameBuffer, &frameBufferSize))

   231 		return NULL;

   232 

   233 	error_handler_called = 0;

   234 	size = clGetParam(SELF->ob_compressorHdl, CL_COMPRESSED_BUFFER_SIZE);

   235 	compressedBufferSize = size;

   236 	if (error_handler_called)

   237 		return NULL;

   238 

   239 	data = PyString_FromStringAndSize(NULL, size);

   240 	if (data == NULL)

   241 		return NULL;

   242 

   243 	error_handler_called = 0;

   244 	if (clCompress(SELF->ob_compressorHdl, numberOfFrames,

   245 		       (void *) frameBuffer, &compressedBufferSize,

   246 		       (void *) PyString_AsString(data)) == FAILURE ||

   247 	    error_handler_called) {

   248 		Py_DECREF(data);

   249 		if (!error_handler_called)

   250 			PyErr_SetString(ClError, "compress failed");

   251 		return NULL;

   252 	}

   253 

   254 	if (compressedBufferSize < size)

   255 		if (_PyString_Resize(&data, compressedBufferSize))

   256 			return NULL;

   257 

   258 	if (compressedBufferSize > size) {

   259 		/* we didn't get all "compressed" data */

   260 		Py_DECREF(data);

   261 		PyErr_SetString(ClError,

   262 				"compressed data is more than fitted");

   263 		return NULL;

   264 	}

   265 

   266 	return data;

   267 }

   268 

   269 static PyObject *

   270 clm_Decompress(PyObject *self, PyObject *args)

   271 {

   272 	PyObject *data;

   273 	int numberOfFrames;

   274 	char *compressedData;

   275 	int compressedDataSize, dataSize;

   276 

   277 	CheckCompressor(SELF);

   278 

   279 	if (!PyArg_Parse(args, "(is#)", &numberOfFrames, &compressedData,

   280 			 &compressedDataSize))

   281 		return NULL;

   282 

   283 	error_handler_called = 0;

   284 	dataSize = clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE);

   285 	if (error_handler_called)

   286 		return NULL;

   287 

   288 	data = PyString_FromStringAndSize(NULL, dataSize);

   289 	if (data == NULL)

   290 		return NULL;

   291 

   292 	error_handler_called = 0;

   293 	if (clDecompress(SELF->ob_compressorHdl, numberOfFrames,

   294 			 compressedDataSize, (void *) compressedData,

   295 			 (void *) PyString_AsString(data)) == FAILURE ||

   296 	    error_handler_called) {

   297 		Py_DECREF(data);

   298 		if (!error_handler_called)

   299 			PyErr_SetString(ClError, "decompress failed");

   300 		return NULL;

   301 	}

   302 

   303 	return data;

   304 }

   305 

   306 static PyObject *

   307 doParams(clobject *self, PyObject *args, int (*func)(CL_Handle, int *, int),

   308 	 int modified)

   309 {

   310 	PyObject *list, *v;

   311 	int *PVbuffer;

   312 	int length;

   313 	int i;

   314 	float number;

   315 	

   316 	CheckCompressor(self);

   317 

   318 	if (!PyArg_Parse(args, "O", &list))

   319 		return NULL;

   320 	if (!PyList_Check(list)) {

   321 		PyErr_BadArgument();

   322 		return NULL;

   323 	}

   324 	length = PyList_Size(list);

   325 	PVbuffer = PyMem_NEW(int, length);

   326 	if (PVbuffer == NULL)

   327 		return PyErr_NoMemory();

   328 	for (i = 0; i < length; i++) {

   329 		v = PyList_GetItem(list, i);

   330 		if (PyFloat_Check(v)) {

   331 			number = PyFloat_AsDouble(v);

   332 			PVbuffer[i] = CL_TypeIsInt(number);

   333 		} else if (PyInt_Check(v)) {

   334 			PVbuffer[i] = PyInt_AsLong(v);

   335 			if ((i & 1) &&

   336 			    param_type_is_float(self, PVbuffer[i-1]) > 0) {

   337 				number = PVbuffer[i];

   338 				PVbuffer[i] = CL_TypeIsInt(number);

   339 			}

   340 		} else {

   341 			PyMem_DEL(PVbuffer);

   342 			PyErr_BadArgument();

   343 			return NULL;

   344 		}

   345 	}

   346 

   347 	error_handler_called = 0;

   348 	(*func)(self->ob_compressorHdl, PVbuffer, length);

   349 	if (error_handler_called) {

   350 		PyMem_DEL(PVbuffer);

   351 		return NULL;

   352 	}

   353 

   354 	if (modified) {

   355 		for (i = 0; i < length; i++) {

   356 			if ((i & 1) &&

   357 			    param_type_is_float(self, PVbuffer[i-1]) > 0) {

   358 				number = CL_TypeIsFloat(PVbuffer[i]);

   359 				v = PyFloat_FromDouble(number);

   360 			} else

   361 				v = PyInt_FromLong(PVbuffer[i]);

   362 			PyList_SetItem(list, i, v);

   363 		}

   364 	}

   365 

   366 	PyMem_DEL(PVbuffer);

   367 

   368 	Py_INCREF(Py_None);

   369 	return Py_None;

   370 }

   371 

   372 static PyObject *

   373 clm_GetParams(PyObject *self, PyObject *args)

   374 {

   375 	return doParams(SELF, args, clGetParams, 1);

   376 }

   377 

   378 static PyObject *

   379 clm_SetParams(PyObject *self, PyObject *args)

   380 {

   381 	return doParams(SELF, args, clSetParams, 0);

   382 }

   383 

   384 static PyObject *

   385 do_get(clobject *self, PyObject *args, int (*func)(CL_Handle, int))

   386 {

   387 	int paramID, value;

   388 	float fvalue;

   389 

   390 	CheckCompressor(self);

   391 

   392 	if (!PyArg_Parse(args, "i", &paramID))

   393 		return NULL;

   394 

   395 	error_handler_called = 0;

   396 	value = (*func)(self->ob_compressorHdl, paramID);

   397 	if (error_handler_called)

   398 		return NULL;

   399 

   400 	if (param_type_is_float(self, paramID) > 0) {

   401 		fvalue = CL_TypeIsFloat(value);

   402 		return PyFloat_FromDouble(fvalue);

   403 	}

   404 

   405 	return PyInt_FromLong(value);

   406 }

   407 

   408 static PyObject *

   409 clm_GetParam(PyObject *self, PyObject *args)

   410 {

   411 	return do_get(SELF, args, clGetParam);

   412 }

   413 

   414 static PyObject *

   415 clm_GetDefault(PyObject *self, PyObject *args)

   416 {

   417 	return do_get(SELF, args, clGetDefault);

   418 }

   419 

   420 static PyObject *

   421 clm_SetParam(PyObject *self, PyObject *args)

   422 {

   423 	int paramID, value;

   424 	float fvalue;

   425 

   426 	CheckCompressor(SELF);

   427 

   428 	if (!PyArg_Parse(args, "(ii)", &paramID, &value)) {

   429 		PyErr_Clear();

   430 		if (!PyArg_Parse(args, "(if)", &paramID, &fvalue)) {

   431 			PyErr_Clear();

   432 			PyErr_SetString(PyExc_TypeError,

   433 			       "bad argument list (format '(ii)' or '(if)')");

   434 			return NULL;

   435 		}

   436 		value = CL_TypeIsInt(fvalue);

   437 	} else {

   438 		if (param_type_is_float(SELF, paramID) > 0) {

   439 			fvalue = value;

   440 			value = CL_TypeIsInt(fvalue);

   441 		}

   442 	}

   443 

   444  	error_handler_called = 0;

   445 	value = clSetParam(SELF->ob_compressorHdl, paramID, value);

   446 	if (error_handler_called)

   447 		return NULL;

   448 

   449 	if (param_type_is_float(SELF, paramID) > 0)

   450 		return PyFloat_FromDouble(CL_TypeIsFloat(value));

   451 	else

   452 		return PyInt_FromLong(value);

   453 }

   454 

   455 static PyObject *

   456 clm_GetParamID(PyObject *self, PyObject *args)

   457 {

   458 	char *name;

   459 	int value;

   460 

   461 	CheckCompressor(SELF);

   462 

   463 	if (!PyArg_Parse(args, "s", &name))

   464 		return NULL;

   465 

   466 	error_handler_called = 0;

   467 	value = clGetParamID(SELF->ob_compressorHdl, name);

   468 	if (value == FAILURE || error_handler_called) {

   469 		if (!error_handler_called)

   470 			PyErr_SetString(ClError, "getparamid failed");

   471 		return NULL;

   472 	}

   473 

   474 	return PyInt_FromLong(value);

   475 }

   476 

   477 static PyObject *

   478 clm_QueryParams(PyObject *self)

   479 {

   480 	int bufferlength;

   481 	int *PVbuffer;

   482 	PyObject *list;

   483 	int i;

   484 

   485 	CheckCompressor(SELF);

   486 

   487 	error_handler_called = 0;

   488 	bufferlength = clQueryParams(SELF->ob_compressorHdl, 0, 0);

   489 	if (error_handler_called)

   490 		return NULL;

   491 

   492 	PVbuffer = PyMem_NEW(int, bufferlength);

   493 	if (PVbuffer == NULL)

   494 		return PyErr_NoMemory();

   495 

   496 	bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer,

   497 				     bufferlength);

   498 	if (error_handler_called) {

   499 		PyMem_DEL(PVbuffer);

   500 		return NULL;

   501 	}

   502 

   503 	list = PyList_New(bufferlength);

   504 	if (list == NULL) {

   505 		PyMem_DEL(PVbuffer);

   506 		return NULL;

   507 	}

   508 

   509 	for (i = 0; i < bufferlength; i++) {

   510 		if (i & 1)

   511 			PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));

   512 		else if (PVbuffer[i] == 0) {

   513 			Py_INCREF(Py_None);

   514 			PyList_SetItem(list, i, Py_None);

   515 		} else

   516 			PyList_SetItem(list, i,

   517 				   PyString_FromString((char *) PVbuffer[i]));

   518 	}

   519 

   520 	PyMem_DEL(PVbuffer);

   521 

   522 	return list;

   523 }

   524 

   525 static PyObject *

   526 clm_GetMinMax(PyObject *self, PyObject *args)

   527 {

   528 	int param, min, max;

   529 	float fmin, fmax;

   530 

   531 	CheckCompressor(SELF);

   532 

   533 	if (!PyArg_Parse(args, "i", &param))

   534 		return NULL;

   535 

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

   537 

   538 	if (param_type_is_float(SELF, param) > 0) {

   539 		fmin = CL_TypeIsFloat(min);

   540 		fmax = CL_TypeIsFloat(max);

   541 		return Py_BuildValue("(ff)", fmin, fmax);

   542 	}

   543 

   544 	return Py_BuildValue("(ii)", min, max);

   545 }

   546 

   547 static PyObject *

   548 clm_GetName(PyObject *self, PyObject *args)

   549 {

   550 	int param;

   551 	char *name;

   552 

   553 	CheckCompressor(SELF);

   554 

   555 	if (!PyArg_Parse(args, "i", &param))

   556 		return NULL;

   557 

   558 	error_handler_called = 0;

   559 	name = clGetName(SELF->ob_compressorHdl, param);

   560 	if (name == NULL || error_handler_called) {

   561 		if (!error_handler_called)

   562 			PyErr_SetString(ClError, "getname failed");

   563 		return NULL;

   564 	}

   565 

   566 	return PyString_FromString(name);

   567 }

   568 

   569 static PyObject *

   570 clm_QuerySchemeFromHandle(PyObject *self)

   571 {

   572 	CheckCompressor(SELF);

   573 	return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl));

   574 }

   575 

   576 static PyObject *

   577 clm_ReadHeader(PyObject *self, PyObject *args)

   578 {

   579 	char *header;

   580 	int headerSize;

   581 

   582 	CheckCompressor(SELF);

   583 

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

   585 		return NULL;

   586 

   587 	return PyInt_FromLong(clReadHeader(SELF->ob_compressorHdl,

   588 					   headerSize, header));

   589 }

   590 

   591 static PyMethodDef compressor_methods[] = {

   592 	{"close",		clm_CloseCompressor, METH_NOARGS}, /* alias */

   593 	{"CloseCompressor",	clm_CloseCompressor, METH_NOARGS},

   594 	{"Compress",		clm_Compress, METH_OLDARGS},

   595 	{"GetDefault",		clm_GetDefault, METH_OLDARGS},

   596 	{"GetMinMax",		clm_GetMinMax, METH_OLDARGS},

   597 	{"GetName",		clm_GetName, METH_OLDARGS},

   598 	{"GetParam",		clm_GetParam, METH_OLDARGS},

   599 	{"GetParamID",		clm_GetParamID, METH_OLDARGS},

   600 	{"GetParams",		clm_GetParams, METH_OLDARGS},

   601 	{"QueryParams",		clm_QueryParams, METH_NOARGS},

   602 	{"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS},

   603 	{"SetParam",		clm_SetParam, METH_OLDARGS},

   604 	{"SetParams",		clm_SetParams, METH_OLDARGS},

   605 	{NULL,			NULL}		/* sentinel */

   606 };

   607 

   608 static PyMethodDef decompressor_methods[] = {

   609 	{"close",		clm_CloseDecompressor, METH_NOARGS},	/* alias */

   610 	{"CloseDecompressor",	clm_CloseDecompressor, METH_NOARGS},

   611 	{"Decompress",		clm_Decompress, METH_OLDARGS},

   612 	{"GetDefault",		clm_GetDefault, METH_OLDARGS},

   613 	{"GetMinMax",		clm_GetMinMax, METH_OLDARGS},

   614 	{"GetName",		clm_GetName, METH_OLDARGS},

   615 	{"GetParam",		clm_GetParam, METH_OLDARGS},

   616 	{"GetParamID",		clm_GetParamID, METH_OLDARGS},

   617 	{"GetParams",		clm_GetParams, METH_OLDARGS},

   618 	{"ReadHeader",		clm_ReadHeader, METH_OLDARGS},

   619 	{"QueryParams",		clm_QueryParams, METH_NOARGS},

   620 	{"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS},

   621 	{"SetParam",		clm_SetParam, METH_OLDARGS},

   622 	{"SetParams",		clm_SetParams, METH_OLDARGS},

   623 	{NULL,			NULL}		/* sentinel */

   624 };

   625 

   626 static void

   627 cl_dealloc(PyObject *self)

   628 {

   629 	if (SELF->ob_compressorHdl) {

   630 		if (SELF->ob_isCompressor)

   631 			clCloseCompressor(SELF->ob_compressorHdl);

   632 		else

   633 			clCloseDecompressor(SELF->ob_compressorHdl);

   634 	}

   635 	PyObject_Del(self);

   636 }

   637 

   638 static PyObject *

   639 cl_getattr(PyObject *self, char *name)

   640 {

   641 	if (SELF->ob_isCompressor)

   642 		return Py_FindMethod(compressor_methods, self, name);

   643 	else

   644 		return Py_FindMethod(decompressor_methods, self, name);

   645 }

   646 

   647 static PyTypeObject Cltype = {

   648 	PyObject_HEAD_INIT(&PyType_Type)

   649 	0,			/*ob_size*/

   650 	"cl.cl",		/*tp_name*/

   651 	sizeof(clobject),	/*tp_size*/

   652 	0,			/*tp_itemsize*/

   653 	/* methods */

   654 	(destructor)cl_dealloc,	/*tp_dealloc*/

   655 	0,			/*tp_print*/

   656 	(getattrfunc)cl_getattr, /*tp_getattr*/

   657 	0,			/*tp_setattr*/

   658 	0,			/*tp_compare*/

   659 	0,			/*tp_repr*/

   660 	0,			/*tp_as_number*/

   661 	0,			/*tp_as_sequence*/

   662 	0,			/*tp_as_mapping*/

   663 };

   664 

   665 static PyObject *

   666 doOpen(PyObject *self, PyObject *args, int (*open_func)(int, CL_Handle *),

   667        int iscompressor)

   668 {

   669 	int scheme;

   670 	clobject *new;

   671 

   672 	if (!PyArg_ParseTuple(args, "i", &scheme))

   673 		return NULL;

   674 

   675 	new = PyObject_New(clobject, &Cltype);

   676 	if (new == NULL)

   677 		return NULL;

   678 

   679 	new->ob_compressorHdl = NULL;

   680 	new->ob_isCompressor = iscompressor;

   681 	new->ob_paramtypes = NULL;

   682 

   683 	error_handler_called = 0;

   684 	if ((*open_func)(scheme, &new->ob_compressorHdl) == FAILURE ||

   685 	    error_handler_called) {

   686 		Py_DECREF(new);

   687 		if (!error_handler_called)

   688 			PyErr_SetString(ClError, "Open(De)Compressor failed");

   689 		return NULL;

   690 	}

   691 	return (PyObject *)new;

   692 }

   693 

   694 static PyObject *

   695 cl_OpenCompressor(PyObject *self, PyObject *args)

   696 {

   697 	return doOpen(self, args, clOpenCompressor, 1);

   698 }

   699 

   700 static PyObject *

   701 cl_OpenDecompressor(PyObject *self, PyObject *args)

   702 {

   703 	return doOpen(self, args, clOpenDecompressor, 0);

   704 }

   705 

   706 static PyObject *

   707 cl_QueryScheme(PyObject *self, PyObject *args)

   708 {

   709 	char *header;

   710 	int headerlen;

   711 	int scheme;

   712 

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

   714 		return NULL;

   715 

   716 	scheme = clQueryScheme(header);

   717 	if (scheme < 0) {

   718 		PyErr_SetString(ClError, "unknown compression scheme");

   719 		return NULL;

   720 	}

   721 

   722 	return PyInt_FromLong(scheme);

   723 }

   724 

   725 static PyObject *

   726 cl_QueryMaxHeaderSize(PyObject *self, PyObject *args)

   727 {

   728 	int scheme;

   729 

   730 	if (!PyArg_ParseTuple(args, "i", &scheme))

   731 		return NULL;

   732 

   733 	return PyInt_FromLong(clQueryMaxHeaderSize(scheme));

   734 }

   735 

   736 static PyObject *

   737 cl_QueryAlgorithms(PyObject *self, PyObject *args)

   738 {

   739 	int algorithmMediaType;

   740 	int bufferlength;

   741 	int *PVbuffer;

   742 	PyObject *list;

   743 	int i;

   744 

   745 	if (!PyArg_ParseTuple(args, "i", &algorithmMediaType))

   746 		return NULL;

   747 

   748 	error_handler_called = 0;

   749 	bufferlength = clQueryAlgorithms(algorithmMediaType, 0, 0);

   750 	if (error_handler_called)

   751 		return NULL;

   752 

   753 	PVbuffer = PyMem_NEW(int, bufferlength);

   754 	if (PVbuffer == NULL)

   755 		return PyErr_NoMemory();

   756 

   757 	bufferlength = clQueryAlgorithms(algorithmMediaType, PVbuffer,

   758 					 bufferlength);

   759 	if (error_handler_called) {

   760 		PyMem_DEL(PVbuffer);

   761 		return NULL;

   762 	}

   763 

   764 	list = PyList_New(bufferlength);

   765 	if (list == NULL) {

   766 		PyMem_DEL(PVbuffer);

   767 		return NULL;

   768 	}

   769 

   770 	for (i = 0; i < bufferlength; i++) {

   771 		if (i & 1)

   772 			PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));

   773 		else if (PVbuffer[i] == 0) {

   774 			Py_INCREF(Py_None);

   775 			PyList_SetItem(list, i, Py_None);

   776 		} else

   777 			PyList_SetItem(list, i,

   778 				   PyString_FromString((char *) PVbuffer[i]));

   779 	}

   780 

   781 	PyMem_DEL(PVbuffer);

   782 

   783 	return list;

   784 }

   785 

   786 static PyObject *

   787 cl_QuerySchemeFromName(PyObject *self, PyObject *args)

   788 {

   789 	int algorithmMediaType;

   790 	char *name;

   791 	int scheme;

   792 

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

   794 		return NULL;

   795 

   796 	error_handler_called = 0;

   797 	scheme = clQuerySchemeFromName(algorithmMediaType, name);

   798 	if (error_handler_called) {

   799 		PyErr_SetString(ClError, "unknown compression scheme");

   800 		return NULL;

   801 	}

   802 

   803 	return PyInt_FromLong(scheme);

   804 }

   805 

   806 static PyObject *

   807 cl_GetAlgorithmName(PyObject *self, PyObject *args)

   808 {

   809 	int scheme;

   810 	char *name;

   811 

   812 	if (!PyArg_ParseTuple(args, "i", &scheme))

   813 		return NULL;

   814 

   815 	name = clGetAlgorithmName(scheme);

   816 	if (name == 0) {

   817 		PyErr_SetString(ClError, "unknown compression scheme");

   818 		return NULL;

   819 	}

   820 

   821 	return PyString_FromString(name);

   822 }

   823 

   824 static PyObject *

   825 do_set(PyObject *self, PyObject *args, int (*func)(int, int, int))

   826 {

   827 	int scheme, paramID, value;

   828 	float fvalue;

   829 	int is_float = 0;

   830 

   831 	if (!PyArg_ParseTuple(args, "iii", &scheme, &paramID, &value)) {

   832 		PyErr_Clear();

   833 		if (!PyArg_ParseTuple(args, "iif", &scheme, &paramID, &fvalue)) {

   834 			PyErr_Clear();

   835 			PyErr_SetString(PyExc_TypeError,

   836 			     "bad argument list (format '(iii)' or '(iif)')");

   837 			return NULL;

   838 		}

   839 		value = CL_TypeIsInt(fvalue);

   840 		is_float = 1;

   841 	} else {

   842 		/* check some parameters which we know to be floats */

   843 		switch (scheme) {

   844 		case CL_COMPRESSION_RATIO:

   845 		case CL_SPEED:

   846 			fvalue = value;

   847 			value = CL_TypeIsInt(fvalue);

   848 			is_float = 1;

   849 			break;

   850 		}

   851 	}

   852 

   853  	error_handler_called = 0;

   854 	value = (*func)(scheme, paramID, value);

   855 	if (error_handler_called)

   856 		return NULL;

   857 

   858 	if (is_float)

   859 		return PyFloat_FromDouble(CL_TypeIsFloat(value));

   860 	else

   861 		return PyInt_FromLong(value);

   862 }

   863 

   864 static PyObject *

   865 cl_SetDefault(PyObject *self, PyObject *args)

   866 {

   867 	return do_set(self, args, clSetDefault);

   868 }

   869 

   870 static PyObject *

   871 cl_SetMin(PyObject *self, PyObject *args)

   872 {

   873 	return do_set(self, args, clSetMin);

   874 }

   875 

   876 static PyObject *

   877 cl_SetMax(PyObject *self, PyObject *args)

   878 {

   879 	return do_set(self, args, clSetMax);

   880 }

   881 

   882 #define func(name, handler)	\

   883 static PyObject *cl_##name(PyObject *self, PyObject *args) \

   884 { \

   885 	  int x; \

   886 	  if (!PyArg_ParseTuple(args, "i", &x)) return NULL; \

   887 	  return Py##handler(CL_##name(x)); \

   888 }

   889 

   890 #define func2(name, handler)	\

   891 static PyObject *cl_##name(PyObject *self, PyObject *args) \

   892 { \

   893 	  int a1, a2; \

   894 	  if (!PyArg_ParseTuple(args, "ii", &a1, &a2)) return NULL; \

   895 	  return Py##handler(CL_##name(a1, a2)); \

   896 }

   897 

   898 func(BytesPerSample, Int_FromLong)

   899 func(BytesPerPixel, Int_FromLong)

   900 func(AudioFormatName, String_FromString)

   901 func(VideoFormatName, String_FromString)

   902 func(AlgorithmNumber, Int_FromLong)

   903 func(AlgorithmType, Int_FromLong)

   904 func2(Algorithm, Int_FromLong)

   905 func(ParamNumber, Int_FromLong)

   906 func(ParamType, Int_FromLong)

   907 func2(ParamID, Int_FromLong)

   908 

   909 #ifdef CLDEBUG

   910 	static PyObject *

   911 cvt_type(PyObject *self, PyObject *args)

   912 {

   913 	int number;

   914 	float fnumber;

   915 

   916 	if (PyArg_Parse(args, "i", &number))

   917 		return PyFloat_FromDouble(CL_TypeIsFloat(number));

   918 	else {

   919 		PyErr_Clear();

   920 		if (PyArg_Parse(args, "f", &fnumber))

   921 			return PyInt_FromLong(CL_TypeIsInt(fnumber));

   922 		return NULL;

   923 	}

   924 }

   925 #endif

   926 

   927 static PyMethodDef cl_methods[] = {

   928 	{"CompressImage",	cl_CompressImage, METH_VARARGS},

   929 	{"DecompressImage",	cl_DecompressImage, METH_VARARGS},

   930 	{"GetAlgorithmName",	cl_GetAlgorithmName, METH_VARARGS},

   931 	{"OpenCompressor",	cl_OpenCompressor, METH_VARARGS},

   932 	{"OpenDecompressor",	cl_OpenDecompressor, METH_VARARGS},

   933 	{"QueryAlgorithms",	cl_QueryAlgorithms, METH_VARARGS},

   934 	{"QueryMaxHeaderSize",	cl_QueryMaxHeaderSize, METH_VARARGS},

   935 	{"QueryScheme",		cl_QueryScheme, METH_VARARGS},

   936 	{"QuerySchemeFromName",	cl_QuerySchemeFromName, METH_VARARGS},

   937 	{"SetDefault",		cl_SetDefault, METH_VARARGS},

   938 	{"SetMax",		cl_SetMax, METH_VARARGS},

   939 	{"SetMin",		cl_SetMin, METH_VARARGS},

   940 	{"BytesPerSample",	cl_BytesPerSample, METH_VARARGS},

   941 	{"BytesPerPixel",	cl_BytesPerPixel, METH_VARARGS},

   942 	{"AudioFormatName",	cl_AudioFormatName, METH_VARARGS},

   943 	{"VideoFormatName",	cl_VideoFormatName, METH_VARARGS},

   944 	{"AlgorithmNumber",	cl_AlgorithmNumber, METH_VARARGS},

   945 	{"AlgorithmType",	cl_AlgorithmType, METH_VARARGS},

   946 	{"Algorithm",		cl_Algorithm, METH_VARARGS},

   947 	{"ParamNumber",		cl_ParamNumber, METH_VARARGS},

   948 	{"ParamType",		cl_ParamType, METH_VARARGS},

   949 	{"ParamID",		cl_ParamID, METH_VARARGS},

   950 #ifdef CLDEBUG

   951 	{"cvt_type",		cvt_type, METH_VARARGS},

   952 #endif

   953 	{NULL,			NULL} /* Sentinel */

   954 };

   955 

   956 #ifdef CL_JPEG_SOFTWARE

   957 #define IRIX_5_3_LIBRARY

   958 #endif

   959 

   960 void

   961 initcl(void)

   962 {

   963 	PyObject *m, *d, *x;

   964     

   965     if (PyErr_WarnPy3k("the cl module has been removed in "

   966                        "Python 3.0", 2) < 0)

   967         return;

   968     

   969 	m = Py_InitModule("cl", cl_methods);

   970 	if (m == NULL)

   971 		return;

   972 	d = PyModule_GetDict(m);

   973 

   974 	ClError = PyErr_NewException("cl.error", NULL, NULL);

   975 	(void) PyDict_SetItemString(d, "error", ClError);

   976 

   977 #ifdef CL_ADDED_ALGORITHM_ERROR

   978 	x = PyInt_FromLong(CL_ADDED_ALGORITHM_ERROR);

   979 	if (x == NULL || PyDict_SetItemString(d, "ADDED_ALGORITHM_ERROR", x) < 0)

   980 		return;

   981 	Py_DECREF(x);

   982 #endif

   983 #ifdef CL_ALAW

   984 	x = PyInt_FromLong(CL_ALAW);

   985 	if (x == NULL || PyDict_SetItemString(d, "ALAW", x) < 0)

   986 		return;

   987 	Py_DECREF(x);

   988 #endif

   989 #ifdef CL_ALGORITHM_ID

   990 	x = PyInt_FromLong(CL_ALGORITHM_ID);

   991 	if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_ID", x) < 0)

   992 		return;

   993 	Py_DECREF(x);

   994 #endif

   995 #ifdef CL_ALGORITHM_TABLE_FULL

   996 	x = PyInt_FromLong(CL_ALGORITHM_TABLE_FULL);

   997 	if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_TABLE_FULL", x) < 0)

   998 		return;

   999 	Py_DECREF(x);

  1000 #endif

  1001 #ifdef CL_ALGORITHM_VERSION

  1002 	x = PyInt_FromLong(CL_ALGORITHM_VERSION);

  1003 	if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_VERSION", x) < 0)

  1004 		return;

  1005 	Py_DECREF(x);

  1006 #endif

  1007 #ifdef CL_ALG_AUDIO

  1008 	x = PyInt_FromLong(CL_ALG_AUDIO);

  1009 	if (x == NULL || PyDict_SetItemString(d, "ALG_AUDIO", x) < 0)

  1010 		return;

  1011 	Py_DECREF(x);

  1012 #endif

  1013 #ifdef CL_ALG_VIDEO

  1014 	x = PyInt_FromLong(CL_ALG_VIDEO);

  1015 	if (x == NULL || PyDict_SetItemString(d, "ALG_VIDEO", x) < 0)

  1016 		return;

  1017 	Py_DECREF(x);

  1018 #endif

  1019 #ifdef CL_AUDIO

  1020 	x = PyInt_FromLong(CL_AUDIO);

  1021 	if (x == NULL || PyDict_SetItemString(d, "AUDIO", x) < 0)

  1022 		return;

  1023 	Py_DECREF(x);

  1024 #endif

  1025 #ifdef CL_AWARE_BITRATE_POLICY

  1026 	x = PyInt_FromLong(CL_AWARE_BITRATE_POLICY);

  1027 	if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_POLICY", x) < 0)

  1028 		return;

  1029 	Py_DECREF(x);

  1030 #endif

  1031 #ifdef CL_AWARE_BITRATE_TARGET

  1032 	x = PyInt_FromLong(CL_AWARE_BITRATE_TARGET);

  1033 	if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_TARGET", x) < 0)

  1034 		return;

  1035 	Py_DECREF(x);

  1036 #endif

  1037 #ifdef CL_AWARE_CHANNEL_POLICY

  1038 	x = PyInt_FromLong(CL_AWARE_CHANNEL_POLICY);

  1039 	if (x == NULL || PyDict_SetItemString(d, "AWARE_CHANNEL_POLICY", x) < 0)

  1040 		return;

  1041 	Py_DECREF(x);

  1042 #endif

  1043 #ifdef CL_AWARE_CONST_QUAL

  1044 	x = PyInt_FromLong(CL_AWARE_CONST_QUAL);

  1045 	if (x == NULL || PyDict_SetItemString(d, "AWARE_CONST_QUAL", x) < 0)

  1046 		return;

  1047 	Py_DECREF(x);

  1048 #endif

  1049 #ifdef CL_AWARE_ERROR

  1050 	x = PyInt_FromLong(CL_AWARE_ERROR);

  1051 	if (x == NULL || PyDict_SetItemString(d, "AWARE_ERROR", x) < 0)

  1052 		return;

  1053 	Py_DECREF(x);

  1054 #endif

  1055 #ifdef CL_AWARE_FIXED_RATE

  1056 	x = PyInt_FromLong(CL_AWARE_FIXED_RATE);

  1057 	if (x == NULL || PyDict_SetItemString(d, "AWARE_FIXED_RATE", x) < 0)

  1058 		return;

  1059 	Py_DECREF(x);

  1060 #endif

  1061 #ifdef CL_AWARE_INDEPENDENT

  1062 	x = PyInt_FromLong(CL_AWARE_INDEPENDENT);

  1063 	if (x == NULL || PyDict_SetItemString(d, "AWARE_INDEPENDENT", x) < 0)

  1064 		return;

  1065 	Py_DECREF(x);

  1066 #endif

  1067 #ifdef CL_AWARE_JOINT_STEREO

  1068 	x = PyInt_FromLong(CL_AWARE_JOINT_STEREO);

  1069 	if (x == NULL || PyDict_SetItemString(d, "AWARE_JOINT_STEREO", x) < 0)

  1070 		return;

  1071 	Py_DECREF(x);

  1072 #endif

  1073 #ifdef CL_AWARE_LAYER

  1074 	x = PyInt_FromLong(CL_AWARE_LAYER);

  1075 	if (x == NULL || PyDict_SetItemString(d, "AWARE_LAYER", x) < 0)

  1076 		return;

  1077 	Py_DECREF(x);

  1078 #endif

  1079 #ifdef CL_AWARE_LOSSLESS

  1080 	x = PyInt_FromLong(CL_AWARE_LOSSLESS);

  1081 	if (x == NULL || PyDict_SetItemString(d, "AWARE_LOSSLESS", x) < 0)

  1082 		return;

  1083 	Py_DECREF(x);

  1084 #endif

  1085 #ifdef CL_AWARE_MPEG_AUDIO

  1086 	x = PyInt_FromLong(CL_AWARE_MPEG_AUDIO);

  1087 	if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_AUDIO", x) < 0)

  1088 		return;

  1089 	Py_DECREF(x);

  1090 #endif

  1091 #ifdef CL_AWARE_MPEG_LAYER_I

  1092 	x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_I);

  1093 	if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_I", x) < 0)

  1094 		return;

  1095 	Py_DECREF(x);

  1096 #endif

  1097 #ifdef CL_AWARE_MPEG_LAYER_II

  1098 	x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_II);

  1099 	if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_II", x) < 0)

  1100 		return;

  1101 	Py_DECREF(x);

  1102 #endif

  1103 #ifdef CL_AWARE_MULTIRATE

  1104 	x = PyInt_FromLong(CL_AWARE_MULTIRATE);

  1105 	if (x == NULL || PyDict_SetItemString(d, "AWARE_MULTIRATE", x) < 0)

  1106 		return;

  1107 	Py_DECREF(x);

  1108 #endif

  1109 #ifdef CL_AWARE_NOISE_MARGIN

  1110 	x = PyInt_FromLong(CL_AWARE_NOISE_MARGIN);

  1111 	if (x == NULL || PyDict_SetItemString(d, "AWARE_NOISE_MARGIN", x) < 0)

  1112 		return;

  1113 	Py_DECREF(x);

  1114 #endif

  1115 #ifdef CL_AWARE_STEREO

  1116 	x = PyInt_FromLong(CL_AWARE_STEREO);

  1117 	if (x == NULL || PyDict_SetItemString(d, "AWARE_STEREO", x) < 0)

  1118 		return;

  1119 	Py_DECREF(x);

  1120 #endif

  1121 #ifdef CL_BAD_ALGORITHM_NAME

  1122 	x = PyInt_FromLong(CL_BAD_ALGORITHM_NAME);

  1123 	if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_NAME", x) < 0)

  1124 		return;

  1125 	Py_DECREF(x);

  1126 #endif

  1127 #ifdef CL_BAD_ALGORITHM_TYPE

  1128 	x = PyInt_FromLong(CL_BAD_ALGORITHM_TYPE);

  1129 	if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_TYPE", x) < 0)

  1130 		return;

  1131 	Py_DECREF(x);

  1132 #endif

  1133 #ifdef CL_BAD_BLOCK_SIZE

  1134 	x = PyInt_FromLong(CL_BAD_BLOCK_SIZE);

  1135 	if (x == NULL || PyDict_SetItemString(d, "BAD_BLOCK_SIZE", x) < 0)