Modules/clmodule.c

   1 /***********************************************************
   2 Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
   3 Amsterdam, The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25
  26 /* Cl objects */
  27
  28 #define CLDEBUG
  29
  30 #include <stdarg.h>
  31 #include <cl.h>
  32 #include "allobjects.h"
  33 #include "modsupport.h"         /* For getargs() etc. */
  34 #include "ceval.h"              /* For call_object() */
  35
  36 typedef struct {
  37         OB_HEAD
  38         int ob_isCompressor;    /* Compressor or Decompressor */
  39         CL_Handle ob_compressorHdl;
  40         int *ob_paramtypes;
  41         int ob_nparams;
  42 } clobject;
  43
  44 static object *ClError;         /* exception cl.error */
  45
  46 static int error_handler_called = 0;
  47
  48 /*
  49  * We want to use the function prototypes that are available in the C
  50  * compiler on the SGI.  Because of that, we need to declare the first
  51  * argument of the compressor and decompressor methods as "object *",
  52  * even though they are really "clobject *".  Therefore we cast the
  53  * argument to the proper type using this macro.
  54  */
  55 #define SELF    ((clobject *) self)
  56
  57 /********************************************************************
  58                           Utility routines.
  59 ********************************************************************/
  60 static void
  61 cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...)
  62 {
  63         va_list ap;
  64         char errbuf[BUFSIZ];    /* hopefully big enough */
  65         char *p;
  66
  67         if (err_occurred())     /* don't change existing error */
  68                 return;
  69         error_handler_called = 1;
  70         va_start(ap, fmt);
  71         vsprintf(errbuf, fmt, ap);
  72         va_end(ap);
  73         p = &errbuf[strlen(errbuf) - 1]; /* swat the line feed */
  74         if (*p == '\n')
  75                 *p = 0;
  76         err_setstr(ClError, errbuf);
  77 }
  78
  79 /*
  80  * This assumes that params are always in the range 0 to some maximum.
  81  */
  82 static int
  83 param_type_is_float(clobject *self, int param)
  84 {
  85         int bufferlength;
  86         int ret;
  87
  88         if (self->ob_paramtypes == NULL) {
  89                 error_handler_called = 0;
  90                 bufferlength = clQueryParams(self->ob_compressorHdl, 0, 0);
  91                 if (error_handler_called)
  92                         return -1;
  93
  94                 self->ob_paramtypes = NEW(int, bufferlength);
  95                 if (self->ob_paramtypes == NULL)
  96                         return -1;
  97                 self->ob_nparams = bufferlength / 2;
  98
  99                 (void) clQueryParams(self->ob_compressorHdl, self->ob_paramtypes, bufferlength);
 100                 if (error_handler_called) {
 101                         DEL(self->ob_paramtypes);
 102                         self->ob_paramtypes = NULL;
 103                         return -1;
 104                 }
 105         }
 106
 107         if (param < 0 || param >= self->ob_nparams)
 108                 return -1;
 109
 110         if (self->ob_paramtypes[param*2 + 1] == CL_FLOATING_ENUM_VALUE ||
 111             self->ob_paramtypes[param*2 + 1] == CL_FLOATING_RANGE_VALUE)
 112                 return 1;
 113         else
 114                 return 0;
 115 }
 116
 117 /********************************************************************
 118                Single image compression/decompression.
 119 ********************************************************************/
 120 static object *
 121 cl_CompressImage(object *self, object *args)
 122 {
 123         int compressionScheme, width, height, originalFormat;
 124         float compressionRatio;
 125         int frameBufferSize, compressedBufferSize;
 126         char *frameBuffer;
 127         object *compressedBuffer;
 128
 129         if (!getargs(args, "(iiiifs#)", &compressionScheme, &width, &height,
 130                      &originalFormat, &compressionRatio, &frameBuffer,
 131                      &frameBufferSize))
 132                 return NULL;
 133
 134  retry:
 135         compressedBuffer = newsizedstringobject(NULL, frameBufferSize);
 136         if (compressedBuffer == NULL)
 137                 return NULL;
 138
 139         compressedBufferSize = frameBufferSize;
 140         error_handler_called = 0;
 141         if (clCompressImage(compressionScheme, width, height, originalFormat,
 142                             compressionRatio, (void *) frameBuffer,
 143                             &compressedBufferSize,
 144                             (void *) getstringvalue(compressedBuffer))
 145             == FAILURE) {
 146                 DECREF(compressedBuffer);
 147                 if (!error_handler_called)
 148                         err_setstr(ClError, "clCompressImage failed");
 149                 return NULL;
 150         }
 151
 152         if (compressedBufferSize > frameBufferSize) {
 153                 frameBufferSize = compressedBufferSize;
 154                 DECREF(compressedBuffer);
 155                 goto retry;
 156         }
 157
 158         if (compressedBufferSize < frameBufferSize)
 159                 if (resizestring(&compressedBuffer, compressedBufferSize))
 160                         return NULL;
 161
 162         return compressedBuffer;
 163 }
 164
 165 static object *
 166 cl_DecompressImage(object *self, object *args)
 167 {
 168         int compressionScheme, width, height, originalFormat;
 169         char *compressedBuffer;
 170         int compressedBufferSize, frameBufferSize;
 171         object *frameBuffer;
 172
 173         if (!getargs(args, "(iiiis#)", &compressionScheme, &width, &height,
 174                      &originalFormat, &compressedBuffer,
 175                      &compressedBufferSize))
 176                 return NULL;
 177
 178         frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);
 179
 180         frameBuffer = newsizedstringobject(NULL, frameBufferSize);
 181         if (frameBuffer == NULL)
 182                 return NULL;
 183
 184         error_handler_called = 0;
 185         if (clDecompressImage(compressionScheme, width, height, originalFormat,
 186                               compressedBufferSize, compressedBuffer,
 187                               (void *) getstringvalue(frameBuffer)) == FAILURE) {
 188                 DECREF(frameBuffer);
 189                 if (!error_handler_called)
 190                         err_setstr(ClError, "clDecompressImage failed");
 191                 return NULL;
 192         }
 193
 194         return frameBuffer;
 195 }
 196
 197 /********************************************************************
 198                 Sequential compression/decompression.
 199 ********************************************************************/
 200 #define CheckCompressor(self)   if ((self)->ob_compressorHdl == NULL) { \
 201                                         err_setstr(RuntimeError, "(de)compressor not active"); \
 202                                         return NULL; \
 203                                 }
 204
 205 static object *
 206 doClose(clobject *self, object *args, int (*close_func)(CL_Handle))
 207 {
 208         CheckCompressor(self);
 209
 210         if (!getnoarg(args))
 211                 return NULL;
 212
 213         error_handler_called = 0;
 214         if ((*close_func)(self->ob_compressorHdl) == FAILURE) {
 215                 if (!error_handler_called)
 216                         err_setstr(ClError, "close failed");
 217                 return NULL;
 218         }
 219
 220         self->ob_compressorHdl = NULL;
 221
 222         if (self->ob_paramtypes)
 223                 DEL(self->ob_paramtypes);
 224         self->ob_paramtypes = NULL;
 225
 226         INCREF(None);
 227         return None;
 228 }
 229
 230 static object *
 231 clm_CloseCompressor(object *self, object *args)
 232 {
 233         return doClose(SELF, args, clCloseCompressor);
 234 }
 235
 236 static object *
 237 clm_CloseDecompressor(object *self, object *args)
 238 {
 239         return doClose(SELF, args, clCloseDecompressor);
 240 }
 241
 242 static object *
 243 clm_Compress(object *self, object *args)
 244 {
 245         int numberOfFrames;
 246         int frameBufferSize, compressedBufferSize, size;
 247         char *frameBuffer;
 248         object *data;
 249
 250         CheckCompressor(SELF);
 251
 252         if (!getargs(args, "(is#)", &numberOfFrames, &frameBuffer, &frameBufferSize))
 253                 return NULL;
 254
 255         error_handler_called = 0;
 256         size = clGetParam(SELF->ob_compressorHdl, CL_COMPRESSED_BUFFER_SIZE);
 257         compressedBufferSize = size;
 258         if (error_handler_called)
 259                 return NULL;
 260
 261         data = newsizedstringobject(NULL, size);
 262         if (data == NULL)
 263                 return NULL;
 264
 265         error_handler_called = 0;
 266         if (clCompress(SELF->ob_compressorHdl, numberOfFrames,
 267                        (void *) frameBuffer, &compressedBufferSize,
 268                        (void *) getstringvalue(data)) == FAILURE) {
 269                 DECREF(data);
 270                 if (!error_handler_called)
 271                         err_setstr(ClError, "compress failed");
 272                 return NULL;
 273         }
 274
 275         if (compressedBufferSize < size)
 276                 if (resizestring(&data, compressedBufferSize))
 277                         return NULL;
 278
 279         if (compressedBufferSize > size) {
 280                 /* we didn't get all "compressed" data */
 281                 DECREF(data);
 282                 err_setstr(ClError, "compressed data is more than fitted");
 283                 return NULL;
 284         }
 285
 286         return data;
 287 }
 288
 289 static object *
 290 clm_Decompress(object *self, object *args)
 291 {
 292         object *data;
 293         int numberOfFrames;
 294         char *compressedData;
 295         int compressedDataSize, dataSize;
 296
 297         CheckCompressor(SELF);
 298
 299         if (!getargs(args, "(is#)", &numberOfFrames, &compressedData,
 300                      &compressedDataSize))
 301                 return NULL;
 302
 303         error_handler_called = 0;
 304         dataSize = clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE);
 305         if (error_handler_called)
 306                 return NULL;
 307
 308         data = newsizedstringobject(NULL, dataSize);
 309         if (data == NULL)
 310                 return NULL;
 311
 312         error_handler_called = 0;
 313         if (clDecompress(SELF->ob_compressorHdl, numberOfFrames,
 314                          compressedDataSize, (void *) compressedData,
 315                          (void *) getstringvalue(data)) == FAILURE) {
 316                 DECREF(data);
 317                 if (!error_handler_called)
 318                         err_setstr(ClError, "decompress failed");
 319                 return NULL;
 320         }
 321
 322         return data;
 323 }
 324
 325 static object *
 326 doParams(clobject *self, object *args, int (*func)(CL_Handle, int *, int),
 327          int modified)
 328 {
 329         object *list, *v;
 330         int *PVbuffer;
 331         int length;
 332         int i;
 333         float number;
 334
 335         CheckCompressor(self);
 336
 337         if (!getargs(args, "O", &list))
 338                 return NULL;
 339         if (!is_listobject(list)) {
 340                 err_badarg();
 341                 return NULL;
 342         }
 343         length = getlistsize(list);
 344         PVbuffer = NEW(int, length);
 345         if (PVbuffer == NULL)
 346                 return err_nomem();
 347         for (i = 0; i < length; i++) {
 348                 v = getlistitem(list, i);
 349                 if (is_floatobject(v)) {
 350                         number = getfloatvalue(v);
 351                         PVbuffer[i] = CL_TypeIsInt(number);
 352                 } else if (is_intobject(v)) {
 353                         PVbuffer[i] = getintvalue(v);
 354                         if ((i & 1) &&
 355                             param_type_is_float(self, PVbuffer[i-1]) > 0) {
 356                                 number = PVbuffer[i];
 357                                 PVbuffer[i] = CL_TypeIsInt(number);
 358                         }
 359                 } else {
 360                         DEL(PVbuffer);
 361                         err_badarg();
 362                         return NULL;
 363                 }
 364         }
 365
 366         error_handler_called = 0;
 367         (*func)(self->ob_compressorHdl, PVbuffer, length);
 368         if (error_handler_called) {
 369                 DEL(PVbuffer);
 370                 return NULL;
 371         }
 372
 373         if (modified) {
 374                 for (i = 0; i < length; i++) {
 375                         if ((i & 1) &&
 376                             param_type_is_float(self, PVbuffer[i-1]) > 0) {
 377                                 number = CL_TypeIsFloat(PVbuffer[i]);
 378                                 v = newfloatobject(number);
 379                         } else
 380                                 v = newintobject(PVbuffer[i]);
 381                         setlistitem(list, i, v);
 382                 }
 383         }
 384
 385         DEL(PVbuffer);
 386
 387         INCREF(None);
 388         return None;
 389 }
 390
 391 static object *
 392 clm_GetParams(object *self, object *args)
 393 {
 394         return doParams(SELF, args, clGetParams, 1);
 395 }
 396
 397 static object *
 398 clm_SetParams(object *self, object *args)
 399 {
 400         return doParams(SELF, args, clSetParams, 0);
 401 }
 402
 403 static object *
 404 do_get(clobject *self, object *args, int (*func)(CL_Handle, int))
 405 {
 406         int paramID, value;
 407         float fvalue;
 408
 409         CheckCompressor(self);
 410
 411         if (!getargs(args, "i", &paramID))
 412                 return NULL;
 413
 414         error_handler_called = 0;
 415         value = (*func)(self->ob_compressorHdl, paramID);
 416         if (error_handler_called)
 417                 return NULL;
 418
 419         if (param_type_is_float(self, paramID) > 0) {
 420                 fvalue = CL_TypeIsFloat(value);
 421                 return newfloatobject(fvalue);
 422         }
 423
 424         return newintobject(value);
 425 }
 426
 427 static object *
 428 clm_GetParam(object *self, object *args)
 429 {
 430         return do_get(SELF, args, clGetParam);
 431 }
 432
 433 static object *
 434 clm_GetDefault(object *self, object *args)
 435 {
 436         return do_get(SELF, args, clGetDefault);
 437 }
 438
 439 static object *
 440 clm_SetParam(object *self, object *args)
 441 {
 442         int paramID, value;
 443         float fvalue;
 444
 445         CheckCompressor(SELF);
 446
 447         if (!getargs(args, "(ii)", &paramID, &value)) {
 448                 err_clear();
 449                 if (!getargs(args, "(if)", &paramID, &fvalue)) {
 450                         err_clear();
 451                         err_setstr(TypeError, "bad argument list (format '(ii)' or '(if)')");
 452                         return NULL;
 453                 }
 454                 value = CL_TypeIsInt(fvalue);
 455         } else {
 456                 if (param_type_is_float(SELF, paramID) > 0) {
 457                         fvalue = value;
 458                         value = CL_TypeIsInt(fvalue);
 459                 }
 460         }
 461
 462         error_handler_called = 0;
 463         value = clSetParam(SELF->ob_compressorHdl, paramID, value);
 464         if (error_handler_called)
 465                 return NULL;
 466
 467         if (param_type_is_float(SELF, paramID) > 0)
 468                 return newfloatobject(CL_TypeIsFloat(value));
 469         else
 470                 return newintobject(value);
 471 }
 472
 473 static object *
 474 clm_GetParamID(object *self, object *args)
 475 {
 476         char *name;
 477         int value;
 478
 479         CheckCompressor(SELF);
 480
 481         if (!getargs(args, "s", &name))
 482                 return NULL;
 483
 484         error_handler_called = 0;
 485         value = clGetParamID(SELF->ob_compressorHdl, name);
 486         if (value == FAILURE) {
 487                 if (!error_handler_called)
 488                         err_setstr(ClError, "getparamid failed");
 489                 return NULL;
 490         }
 491
 492         return newintobject(value);
 493 }
 494
 495 static object *
 496 clm_QueryParams(object *self, object *args)
 497 {
 498         int bufferlength;
 499         int *PVbuffer;
 500         object *list;
 501         int i;
 502
 503         CheckCompressor(SELF);
 504
 505         if (!getnoarg(args))
 506                 return NULL;
 507
 508         error_handler_called = 0;
 509         bufferlength = clQueryParams(SELF->ob_compressorHdl, 0, 0);
 510         if (error_handler_called)
 511                 return NULL;
 512
 513         PVbuffer = NEW(int, bufferlength);
 514         if (PVbuffer == NULL)
 515                 return err_nomem();
 516
 517         bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer,
 518                                      bufferlength);
 519         if (error_handler_called) {
 520                 DEL(PVbuffer);
 521                 return NULL;
 522         }
 523
 524         list = newlistobject(bufferlength);
 525         if (list == NULL) {
 526                 DEL(PVbuffer);
 527                 return NULL;
 528         }
 529
 530         for (i = 0; i < bufferlength; i++) {
 531                 if (i & 1)
 532                         setlistitem(list, i, newintobject(PVbuffer[i]));
 533                 else if (PVbuffer[i] == 0) {
 534                         INCREF(None);
 535                         setlistitem(list, i, None);
 536                 } else
 537                         setlistitem(list, i, newstringobject((char *) PVbuffer[i]));
 538         }
 539
 540         DEL(PVbuffer);
 541
 542         return list;
 543 }
 544
 545 static object *
 546 clm_GetMinMax(object *self, object *args)
 547 {
 548         int param, min, max;
 549         float fmin, fmax;
 550
 551         CheckCompressor(SELF);
 552
 553         if (!getargs(args, "i", &param))
 554                 return NULL;
 555
 556         clGetMinMax(SELF->ob_compressorHdl, param, &min, &max);
 557
 558         if (param_type_is_float(SELF, param) > 0) {
 559                 fmin = CL_TypeIsFloat(min);
 560                 fmax = CL_TypeIsFloat(max);
 561                 return mkvalue("(ff)", fmin, fmax);
 562         }
 563
 564         return mkvalue("(ii)", min, max);
 565 }
 566
 567 static object *
 568 clm_GetName(object *self, object *args)
 569 {
 570         int param;
 571         char *name;
 572
 573         CheckCompressor(SELF);
 574
 575         if (!getargs(args, "i", &param))
 576                 return NULL;
 577
 578         error_handler_called = 0;
 579         name = clGetName(SELF->ob_compressorHdl, param);
 580         if (name == NULL || error_handler_called) {
 581                 if (!error_handler_called)
 582                         err_setstr(ClError, "getname failed");
 583                 return NULL;
 584         }
 585
 586         return newstringobject(name);
 587 }
 588
 589 static object *
 590 clm_QuerySchemeFromHandle(object *self, object *args)
 591 {
 592         CheckCompressor(SELF);
 593
 594         if (!getnoarg(args))
 595                 return NULL;
 596
 597         return newintobject(clQuerySchemeFromHandle(SELF->ob_compressorHdl));
 598 }
 599
 600 static object *
 601 clm_ReadHeader(object *self, object *args)
 602 {
 603         char *header;
 604         int headerSize;
 605
 606         CheckCompressor(SELF);
 607
 608         if (!getargs(args, "s#", &header, &headerSize))
 609                 return NULL;
 610
 611         return newintobject(clReadHeader(SELF->ob_compressorHdl,
 612                                          headerSize, header));
 613 }
 614
 615 static struct methodlist compressor_methods[] = {
 616         {"close",               clm_CloseCompressor}, /* alias */
 617         {"CloseCompressor",     clm_CloseCompressor},
 618         {"Compress",            clm_Compress},
 619         {"GetDefault",          clm_GetDefault},
 620         {"GetMinMax",           clm_GetMinMax},
 621         {"GetName",             clm_GetName},
 622         {"GetParam",            clm_GetParam},
 623         {"GetParamID",          clm_GetParamID},
 624         {"GetParams",           clm_GetParams},
 625         {"QueryParams",         clm_QueryParams},
 626         {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle},
 627         {"SetParam",            clm_SetParam},
 628         {"SetParams",           clm_SetParams},
 629         {NULL,                  NULL}           /* sentinel */
 630 };
 631
 632 static struct methodlist decompressor_methods[] = {
 633         {"close",               clm_CloseDecompressor}, /* alias */
 634         {"CloseDecompressor",   clm_CloseDecompressor},
 635         {"Decompress",          clm_Decompress},
 636         {"GetDefault",          clm_GetDefault},
 637         {"GetMinMax",           clm_GetMinMax},
 638         {"GetName",             clm_GetName},
 639         {"GetParam",            clm_GetParam},
 640         {"GetParamID",          clm_GetParamID},
 641         {"GetParams",           clm_GetParams},
 642         {"ReadHeader",          clm_ReadHeader},
 643         {"QueryParams",         clm_QueryParams},
 644         {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle},
 645         {"SetParam",            clm_SetParam},
 646         {"SetParams",           clm_SetParams},
 647         {NULL,                  NULL}           /* sentinel */
 648 };
 649
 650 static void
 651 cl_dealloc(object *self)
 652 {
 653         if (SELF->ob_compressorHdl) {
 654                 if (SELF->ob_isCompressor)
 655                         clCloseCompressor(SELF->ob_compressorHdl);
 656                 else
 657                         clCloseDecompressor(SELF->ob_compressorHdl);
 658         }
 659         DEL(self);
 660 }
 661
 662 static object *
 663 cl_getattr(object *self, char *name)
 664 {
 665         if (SELF->ob_isCompressor)
 666                 return findmethod(compressor_methods, self, name);
 667         else
 668                 return findmethod(decompressor_methods, self, name);
 669 }
 670
 671 static typeobject Cltype = {
 672         OB_HEAD_INIT(&Typetype)
 673         0,                      /*ob_size*/
 674         "cl",                   /*tp_name*/
 675         sizeof(clobject),       /*tp_size*/
 676         0,                      /*tp_itemsize*/
 677         /* methods */
 678         (destructor)cl_dealloc, /*tp_dealloc*/
 679         0,                      /*tp_print*/
 680         (getattrfunc)cl_getattr, /*tp_getattr*/
 681         0,                      /*tp_setattr*/
 682         0,                      /*tp_compare*/
 683         0,                      /*tp_repr*/
 684         0,                      /*tp_as_number*/
 685         0,                      /*tp_as_sequence*/
 686         0,                      /*tp_as_mapping*/
 687 };
 688
 689 static object *
 690 doOpen(object *self, object *args, int (*open_func)(int, CL_Handle *),
 691        int iscompressor)
 692 {
 693         int scheme;
 694         clobject *new;
 695
 696         if (!getargs(args, "i", &scheme))
 697                 return NULL;
 698
 699         new = NEWOBJ(clobject, &Cltype);
 700         if (new == NULL)
 701                 return NULL;
 702
 703         new->ob_compressorHdl = NULL;
 704         new->ob_isCompressor = iscompressor;
 705         new->ob_paramtypes = NULL;
 706
 707         error_handler_called = 0;
 708         if ((*open_func)(scheme, &new->ob_compressorHdl) == FAILURE) {
 709                 DECREF(new);
 710                 if (!error_handler_called)
 711                         err_setstr(ClError, "Open(De)Compressor failed");
 712                 return NULL;
 713         }
 714         return (object *)new;
 715 }
 716
 717 static object *
 718 cl_OpenCompressor(object *self, object *args)
 719 {
 720         return doOpen(self, args, clOpenCompressor, 1);
 721 }
 722
 723 static object *
 724 cl_OpenDecompressor(object *self, object *args)
 725 {
 726         return doOpen(self, args, clOpenDecompressor, 0);
 727 }
 728
 729 static object *
 730 cl_QueryScheme(object *self, object *args)
 731 {
 732         char *header;
 733         int headerlen;
 734         int scheme;
 735
 736         if (!getargs(args, "s#", &header, &headerlen))
 737                 return NULL;
 738
 739         scheme = clQueryScheme(header);
 740         if (scheme < 0) {
 741                 err_setstr(ClError, "unknown compression scheme");
 742                 return NULL;
 743         }
 744
 745         return newintobject(scheme);
 746 }
 747
 748 static object *
 749 cl_QueryMaxHeaderSize(object *self, object *args)
 750 {
 751         int scheme;
 752
 753         if (!getargs(args, "i", &scheme))
 754                 return NULL;
 755
 756         return newintobject(clQueryMaxHeaderSize(scheme));
 757 }
 758
 759 static object *
 760 cl_QueryAlgorithms(object *self, object *args)
 761 {
 762         int algorithmMediaType;
 763         int bufferlength;
 764         int *PVbuffer;
 765         object *list;
 766         int i;
 767
 768         if (!getargs(args, "i", &algorithmMediaType))
 769                 return NULL;
 770
 771         error_handler_called = 0;
 772         bufferlength = clQueryAlgorithms(algorithmMediaType, 0, 0);
 773         if (error_handler_called)
 774                 return NULL;
 775
 776         PVbuffer = NEW(int, bufferlength);
 777         if (PVbuffer == NULL)
 778                 return err_nomem();
 779
 780         bufferlength = clQueryAlgorithms(algorithmMediaType, PVbuffer,
 781                                      bufferlength);
 782         if (error_handler_called) {
 783                 DEL(PVbuffer);
 784                 return NULL;
 785         }
 786
 787         list = newlistobject(bufferlength);
 788         if (list == NULL) {
 789                 DEL(PVbuffer);
 790                 return NULL;
 791         }
 792
 793         for (i = 0; i < bufferlength; i++) {
 794                 if (i & 1)
 795                         setlistitem(list, i, newintobject(PVbuffer[i]));
 796                 else if (PVbuffer[i] == 0) {
 797                         INCREF(None);
 798                         setlistitem(list, i, None);
 799                 } else
 800                         setlistitem(list, i, newstringobject((char *) PVbuffer[i]));
 801         }
 802
 803         DEL(PVbuffer);
 804
 805         return list;
 806 }
 807
 808 static object *
 809 cl_QuerySchemeFromName(object *self, object *args)
 810 {
 811         int algorithmMediaType;
 812         char *name;
 813         int scheme;
 814
 815         if (!getargs(args, "(is)", &algorithmMediaType, &name))
 816                 return NULL;
 817
 818         error_handler_called = 0;
 819         scheme = clQuerySchemeFromName(algorithmMediaType, name);
 820         if (error_handler_called) {
 821                 err_setstr(ClError, "unknown compression scheme");
 822                 return NULL;
 823         }
 824
 825         return newintobject(scheme);
 826 }
 827
 828 static object *
 829 cl_GetAlgorithmName(object *self, object *args)
 830 {
 831         int scheme;
 832         char *name;
 833
 834         if (!getargs(args, "i", &scheme))
 835                 return NULL;
 836
 837         name = clGetAlgorithmName(scheme);
 838         if (name == 0) {
 839                 err_setstr(ClError, "unknown compression scheme");
 840                 return NULL;
 841         }
 842
 843         return newstringobject(name);
 844 }
 845
 846 static object *
 847 do_set(object *self, object *args, int (*func)(int, int, int))
 848 {
 849         int scheme, paramID, value;
 850         float fvalue;
 851         int is_float = 0;
 852
 853         if (!getargs(args, "(iii)", &scheme, &paramID, &value)) {
 854                 err_clear();
 855                 if (!getargs(args, "(iif)", &scheme, &paramID, &fvalue)) {
 856                         err_clear();
 857                         err_setstr(TypeError, "bad argument list (format '(iii)' or '(iif)')");
 858                         return NULL;
 859                 }
 860                 value = CL_TypeIsInt(fvalue);
 861                 is_float = 1;
 862         } else {
 863                 /* check some parameters which we know to be floats */
 864                 switch (scheme) {
 865                 case CL_COMPRESSION_RATIO:
 866                 case CL_SPEED:
 867                         fvalue = value;
 868                         value = CL_TypeIsInt(fvalue);
 869                         is_float = 1;
 870                         break;
 871                 }
 872         }
 873
 874         error_handler_called = 0;
 875         value = (*func)(scheme, paramID, value);
 876         if (error_handler_called)
 877                 return NULL;
 878
 879         if (is_float)
 880                 return newfloatobject(CL_TypeIsFloat(value));
 881         else
 882                 return newintobject(value);
 883 }
 884
 885 static object *
 886 cl_SetDefault(object *self, object *args)
 887 {
 888         return do_set(self, args, clSetDefault);
 889 }
 890
 891 static object *
 892 cl_SetMin(object *self, object *args)
 893 {
 894         return do_set(self, args, clSetMin);
 895 }
 896
 897 static object *
 898 cl_SetMax(object *self, object *args)
 899 {
 900         return do_set(self, args, clSetMax);
 901 }
 902
 903 #ifdef CLDEBUG
 904 static object *
 905 cvt_type(object *self, object *args)
 906 {
 907         int number;
 908         float fnumber;
 909
 910         if (getargs(args, "i", &number))
 911                 return newfloatobject(CL_TypeIsFloat(number));
 912         else {
 913                 err_clear();
 914                 if (getargs(args, "f", &fnumber))
 915                         return newintobject(CL_TypeIsInt(fnumber));
 916                 return NULL;
 917         }
 918 }
 919 #endif
 920
 921 static struct methodlist cl_methods[] = {
 922         {"CompressImage",       cl_CompressImage},
 923         {"DecompressImage",     cl_DecompressImage},
 924         {"GetAlgorithmName",    cl_GetAlgorithmName},
 925         {"OpenCompressor",      cl_OpenCompressor},
 926         {"OpenDecompressor",    cl_OpenDecompressor},
 927         {"QueryAlgorithms",     cl_QueryAlgorithms},
 928         {"QueryMaxHeaderSize",  cl_QueryMaxHeaderSize},
 929         {"QueryScheme",         cl_QueryScheme},
 930         {"QuerySchemeFromName", cl_QuerySchemeFromName},
 931         {"SetDefault",          cl_SetDefault},
 932         {"SetMax",              cl_SetMax},
 933         {"SetMin",              cl_SetMin},
 934 #ifdef CLDEBUG
 935         {"cvt_type",            cvt_type},
 936 #endif
 937         {NULL,                  NULL} /* Sentinel */
 938 };
 939
 940 void
 941 initcl()
 942 {
 943         object *m, *d;
 944
 945         m = initmodule("cl", cl_methods);
 946         d = getmoduledict(m);
 947
 948         ClError = newstringobject("cl.error");
 949         if (ClError == NULL || dictinsert(d, "error", ClError) != 0)
 950                 fatal("can't define cl.error");
 951
 952         (void) clSetErrorHandler(cl_ErrorHandler);
 953 }