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", ¶mID)) 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)", ¶mID, &value)) { 429 PyErr_Clear(); 430 if (!PyArg_Parse(args, "(if)", ¶mID, &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", ¶m)) 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", ¶m)) 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, ¶mID, &value)) { 832 PyErr_Clear(); 833 if (!PyArg_ParseTuple(args, "iif", &scheme, ¶mID, &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) 1136 return; 1137 Py_DECREF(x); 1138 #endif 1139 #ifdef CL_BAD_BOARD 1140 x = PyInt_FromLong(CL_BAD_BOARD); 1141 if (x == NULL || PyDict_SetItemString(d, "BAD_BOARD", x) < 0) 1142 return; 1143 Py_DECREF(x); 1144 #endif 1145 #ifdef CL_BAD_BUFFERING 1146 x = PyInt_FromLong(CL_BAD_BUFFERING); 1147 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERING", x) < 0) 1148 return; 1149 Py_DECREF(x); 1150 #endif 1151 #ifdef CL_BAD_BUFFERLENGTH_NEG 1152 x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_NEG); 1153 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0) 1154 return; 1155 Py_DECREF(x); 1156 #endif 1157 #ifdef CL_BAD_BUFFERLENGTH_ODD 1158 x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_ODD); 1159 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0) 1160 return; 1161 Py_DECREF(x); 1162 #endif 1163 #ifdef CL_BAD_BUFFER_EXISTS 1164 x = PyInt_FromLong(CL_BAD_BUFFER_EXISTS); 1165 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_EXISTS", x) < 0) 1166 return; 1167 Py_DECREF(x); 1168 #endif 1169 #ifdef CL_BAD_BUFFER_HANDLE 1170 x = PyInt_FromLong(CL_BAD_BUFFER_HANDLE); 1171 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_HANDLE", x) < 0) 1172 return; 1173 Py_DECREF(x); 1174 #endif 1175 #ifdef CL_BAD_BUFFER_POINTER 1176 x = PyInt_FromLong(CL_BAD_BUFFER_POINTER); 1177 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_POINTER", x) < 0) 1178 return; 1179 Py_DECREF(x); 1180 #endif 1181 #ifdef CL_BAD_BUFFER_QUERY_SIZE 1182 x = PyInt_FromLong(CL_BAD_BUFFER_QUERY_SIZE); 1183 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_QUERY_SIZE", x) < 0) 1184 return; 1185 Py_DECREF(x); 1186 #endif 1187 #ifdef CL_BAD_BUFFER_SIZE 1188 x = PyInt_FromLong(CL_BAD_BUFFER_SIZE); 1189 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE", x) < 0) 1190 return; 1191 Py_DECREF(x); 1192 #endif 1193 #ifdef CL_BAD_BUFFER_SIZE_POINTER 1194 x = PyInt_FromLong(CL_BAD_BUFFER_SIZE_POINTER); 1195 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE_POINTER", x) < 0) 1196 return; 1197 Py_DECREF(x); 1198 #endif 1199 #ifdef CL_BAD_BUFFER_TYPE 1200 x = PyInt_FromLong(CL_BAD_BUFFER_TYPE); 1201 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_TYPE", x) < 0) 1202 return; 1203 Py_DECREF(x); 1204 #endif 1205 #ifdef CL_BAD_COMPRESSION_SCHEME 1206 x = PyInt_FromLong(CL_BAD_COMPRESSION_SCHEME); 1207 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSION_SCHEME", x) < 0) 1208 return; 1209 Py_DECREF(x); 1210 #endif 1211 #ifdef CL_BAD_COMPRESSOR_HANDLE 1212 x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE); 1213 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE", x) < 0) 1214 return; 1215 Py_DECREF(x); 1216 #endif 1217 #ifdef CL_BAD_COMPRESSOR_HANDLE_POINTER 1218 x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE_POINTER); 1219 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE_POINTER", x) < 0) 1220 return; 1221 Py_DECREF(x); 1222 #endif 1223 #ifdef CL_BAD_FRAME_SIZE 1224 x = PyInt_FromLong(CL_BAD_FRAME_SIZE); 1225 if (x == NULL || PyDict_SetItemString(d, "BAD_FRAME_SIZE", x) < 0) 1226 return; 1227 Py_DECREF(x); 1228 #endif 1229 #ifdef CL_BAD_FUNCTIONALITY 1230 x = PyInt_FromLong(CL_BAD_FUNCTIONALITY); 1231 if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTIONALITY", x) < 0) 1232 return; 1233 Py_DECREF(x); 1234 #endif 1235 #ifdef CL_BAD_FUNCTION_POINTER 1236 x = PyInt_FromLong(CL_BAD_FUNCTION_POINTER); 1237 if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTION_POINTER", x) < 0) 1238 return; 1239 Py_DECREF(x); 1240 #endif 1241 #ifdef CL_BAD_HEADER_SIZE 1242 x = PyInt_FromLong(CL_BAD_HEADER_SIZE); 1243 if (x == NULL || PyDict_SetItemString(d, "BAD_HEADER_SIZE", x) < 0) 1244 return; 1245 Py_DECREF(x); 1246 #endif 1247 #ifdef CL_BAD_INITIAL_VALUE 1248 x = PyInt_FromLong(CL_BAD_INITIAL_VALUE); 1249 if (x == NULL || PyDict_SetItemString(d, "BAD_INITIAL_VALUE", x) < 0) 1250 return; 1251 Py_DECREF(x); 1252 #endif 1253 #ifdef CL_BAD_INTERNAL_FORMAT 1254 x = PyInt_FromLong(CL_BAD_INTERNAL_FORMAT); 1255 if (x == NULL || PyDict_SetItemString(d, "BAD_INTERNAL_FORMAT", x) < 0) 1256 return; 1257 Py_DECREF(x); 1258 #endif 1259 #ifdef CL_BAD_LICENSE 1260 x = PyInt_FromLong(CL_BAD_LICENSE); 1261 if (x == NULL || PyDict_SetItemString(d, "BAD_LICENSE", x) < 0) 1262 return; 1263 Py_DECREF(x); 1264 #endif 1265 #ifdef CL_BAD_MIN_GT_MAX 1266 x = PyInt_FromLong(CL_BAD_MIN_GT_MAX); 1267 if (x == NULL || PyDict_SetItemString(d, "BAD_MIN_GT_MAX", x) < 0) 1268 return; 1269 Py_DECREF(x); 1270 #endif 1271 #ifdef CL_BAD_NO_BUFFERSPACE 1272 x = PyInt_FromLong(CL_BAD_NO_BUFFERSPACE); 1273 if (x == NULL || PyDict_SetItemString(d, "BAD_NO_BUFFERSPACE", x) < 0) 1274 return; 1275 Py_DECREF(x); 1276 #endif 1277 #ifdef CL_BAD_NUMBER_OF_BLOCKS 1278 x = PyInt_FromLong(CL_BAD_NUMBER_OF_BLOCKS); 1279 if (x == NULL || PyDict_SetItemString(d, "BAD_NUMBER_OF_BLOCKS", x) < 0) 1280 return; 1281 Py_DECREF(x); 1282 #endif 1283 #ifdef CL_BAD_PARAM 1284 x = PyInt_FromLong(CL_BAD_PARAM); 1285 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0) 1286 return; 1287 Py_DECREF(x); 1288 #endif 1289 #ifdef CL_BAD_PARAM_ID_POINTER 1290 x = PyInt_FromLong(CL_BAD_PARAM_ID_POINTER); 1291 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_ID_POINTER", x) < 0) 1292 return; 1293 Py_DECREF(x); 1294 #endif 1295 #ifdef CL_BAD_PARAM_TYPE 1296 x = PyInt_FromLong(CL_BAD_PARAM_TYPE); 1297 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_TYPE", x) < 0) 1298 return; 1299 Py_DECREF(x); 1300 #endif 1301 #ifdef CL_BAD_POINTER 1302 x = PyInt_FromLong(CL_BAD_POINTER); 1303 if (x == NULL || PyDict_SetItemString(d, "BAD_POINTER", x) < 0) 1304 return; 1305 Py_DECREF(x); 1306 #endif 1307 #ifdef CL_BAD_PVBUFFER 1308 x = PyInt_FromLong(CL_BAD_PVBUFFER); 1309 if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0) 1310 return; 1311 Py_DECREF(x); 1312 #endif 1313 #ifdef CL_BAD_SCHEME_POINTER 1314 x = PyInt_FromLong(CL_BAD_SCHEME_POINTER); 1315 if (x == NULL || PyDict_SetItemString(d, "BAD_SCHEME_POINTER", x) < 0) 1316 return; 1317 Py_DECREF(x); 1318 #endif 1319 #ifdef CL_BAD_STREAM_HEADER 1320 x = PyInt_FromLong(CL_BAD_STREAM_HEADER); 1321 if (x == NULL || PyDict_SetItemString(d, "BAD_STREAM_HEADER", x) < 0) 1322 return; 1323 Py_DECREF(x); 1324 #endif 1325 #ifdef CL_BAD_STRING_POINTER 1326 x = PyInt_FromLong(CL_BAD_STRING_POINTER); 1327 if (x == NULL || PyDict_SetItemString(d, "BAD_STRING_POINTER", x) < 0) 1328 return; 1329 Py_DECREF(x); 1330 #endif 1331 #ifdef CL_BAD_TEXT_STRING_PTR 1332 x = PyInt_FromLong(CL_BAD_TEXT_STRING_PTR); 1333 if (x == NULL || PyDict_SetItemString(d, "BAD_TEXT_STRING_PTR", x) < 0) 1334 return; 1335 Py_DECREF(x); 1336 #endif 1337 #ifdef CL_BEST_FIT 1338 x = PyInt_FromLong(CL_BEST_FIT); 1339 if (x == NULL || PyDict_SetItemString(d, "BEST_FIT", x) < 0) 1340 return; 1341 Py_DECREF(x); 1342 #endif 1343 #ifdef CL_BIDIRECTIONAL 1344 x = PyInt_FromLong(CL_BIDIRECTIONAL); 1345 if (x == NULL || PyDict_SetItemString(d, "BIDIRECTIONAL", x) < 0) 1346 return; 1347 Py_DECREF(x); 1348 #endif 1349 #ifdef CL_BITRATE 1350 x = PyInt_FromLong(CL_BITRATE); 1351 if (x == NULL || PyDict_SetItemString(d, "BITRATE", x) < 0) 1352 return; 1353 Py_DECREF(x); 1354 #endif 1355 #ifdef CL_BITRATE_POLICY 1356 x = PyInt_FromLong(CL_BITRATE_POLICY); 1357 if (x == NULL || PyDict_SetItemString(d, "BITRATE_POLICY", x) < 0) 1358 return; 1359 Py_DECREF(x); 1360 #endif 1361 #ifdef CL_BITRATE_TARGET 1362 x = PyInt_FromLong(CL_BITRATE_TARGET); 1363 if (x == NULL || PyDict_SetItemString(d, "BITRATE_TARGET", x) < 0) 1364 return; 1365 Py_DECREF(x); 1366 #endif 1367 #ifdef CL_BITS_PER_COMPONENT 1368 x = PyInt_FromLong(CL_BITS_PER_COMPONENT); 1369 if (x == NULL || PyDict_SetItemString(d, "BITS_PER_COMPONENT", x) < 0) 1370 return; 1371 Py_DECREF(x); 1372 #endif 1373 #ifdef CL_BLENDING 1374 x = PyInt_FromLong(CL_BLENDING); 1375 if (x == NULL || PyDict_SetItemString(d, "BLENDING", x) < 0) 1376 return; 1377 Py_DECREF(x); 1378 #endif 1379 #ifdef CL_BLOCK_SIZE 1380 x = PyInt_FromLong(CL_BLOCK_SIZE); 1381 if (x == NULL || PyDict_SetItemString(d, "BLOCK_SIZE", x) < 0) 1382 return; 1383 Py_DECREF(x); 1384 #endif 1385 #ifdef CL_BOTTOM_UP 1386 x = PyInt_FromLong(CL_BOTTOM_UP); 1387 if (x == NULL || PyDict_SetItemString(d, "BOTTOM_UP", x) < 0) 1388 return; 1389 Py_DECREF(x); 1390 #endif 1391 #ifdef CL_BUFFER_NOT_CREATED 1392 x = PyInt_FromLong(CL_BUFFER_NOT_CREATED); 1393 if (x == NULL || PyDict_SetItemString(d, "BUFFER_NOT_CREATED", x) < 0) 1394 return; 1395 Py_DECREF(x); 1396 #endif 1397 #ifdef CL_BUF_COMPRESSED 1398 x = PyInt_FromLong(CL_BUF_COMPRESSED); 1399 if (x == NULL || PyDict_SetItemString(d, "BUF_COMPRESSED", x) < 0) 1400 return; 1401 Py_DECREF(x); 1402 #endif 1403 #ifdef CL_BUF_DATA 1404 x = PyInt_FromLong(CL_BUF_DATA); 1405 if (x == NULL || PyDict_SetItemString(d, "BUF_DATA", x) < 0) 1406 return; 1407 Py_DECREF(x); 1408 #endif 1409 #ifdef CL_BUF_FRAME 1410 x = PyInt_FromLong(CL_BUF_FRAME); 1411 if (x == NULL || PyDict_SetItemString(d, "BUF_FRAME", x) < 0) 1412 return; 1413 Py_DECREF(x); 1414 #endif 1415 #ifdef CL_CHANNEL_POLICY 1416 x = PyInt_FromLong(CL_CHANNEL_POLICY); 1417 if (x == NULL || PyDict_SetItemString(d, "CHANNEL_POLICY", x) < 0) 1418 return; 1419 Py_DECREF(x); 1420 #endif 1421 #ifdef CL_CHROMA_THRESHOLD 1422 x = PyInt_FromLong(CL_CHROMA_THRESHOLD); 1423 if (x == NULL || PyDict_SetItemString(d, "CHROMA_THRESHOLD", x) < 0) 1424 return; 1425 Py_DECREF(x); 1426 #endif 1427 #ifdef CL_CODEC 1428 x = PyInt_FromLong(CL_CODEC); 1429 if (x == NULL || PyDict_SetItemString(d, "CODEC", x) < 0) 1430 return; 1431 Py_DECREF(x); 1432 #endif 1433 #ifdef CL_COMPONENTS 1434 x = PyInt_FromLong(CL_COMPONENTS); 1435 if (x == NULL || PyDict_SetItemString(d, "COMPONENTS", x) < 0) 1436 return; 1437 Py_DECREF(x); 1438 #endif 1439 #ifdef CL_COMPRESSED_BUFFER_SIZE 1440 x = PyInt_FromLong(CL_COMPRESSED_BUFFER_SIZE); 1441 if (x == NULL || PyDict_SetItemString(d, "COMPRESSED_BUFFER_SIZE", x) < 0) 1442 return; 1443 Py_DECREF(x); 1444 #endif 1445 #ifdef CL_COMPRESSION_RATIO 1446 x = PyInt_FromLong(CL_COMPRESSION_RATIO); 1447 if (x == NULL || PyDict_SetItemString(d, "COMPRESSION_RATIO", x) < 0) 1448 return; 1449 Py_DECREF(x); 1450 #endif 1451 #ifdef CL_COMPRESSOR 1452 x = PyInt_FromLong(CL_COMPRESSOR); 1453 if (x == NULL || PyDict_SetItemString(d, "COMPRESSOR", x) < 0) 1454 return; 1455 Py_DECREF(x); 1456 #endif 1457 #ifdef CL_CONTINUOUS_BLOCK 1458 x = PyInt_FromLong(CL_CONTINUOUS_BLOCK); 1459 if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_BLOCK", x) < 0) 1460 return; 1461 Py_DECREF(x); 1462 #endif 1463 #ifdef CL_CONTINUOUS_NONBLOCK 1464 x = PyInt_FromLong(CL_CONTINUOUS_NONBLOCK); 1465 if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_NONBLOCK", x) < 0) 1466 return; 1467 Py_DECREF(x); 1468 #endif 1469 #ifdef CL_COSMO_CODEC_CONTROL 1470 x = PyInt_FromLong(CL_COSMO_CODEC_CONTROL); 1471 if (x == NULL || PyDict_SetItemString(d, "COSMO_CODEC_CONTROL", x) < 0) 1472 return; 1473 Py_DECREF(x); 1474 #endif 1475 #ifdef CL_COSMO_NUM_PARAMS 1476 x = PyInt_FromLong(CL_COSMO_NUM_PARAMS); 1477 if (x == NULL || PyDict_SetItemString(d, "COSMO_NUM_PARAMS", x) < 0) 1478 return; 1479 Py_DECREF(x); 1480 #endif 1481 #ifdef CL_COSMO_VALUE_BASE 1482 x = PyInt_FromLong(CL_COSMO_VALUE_BASE); 1483 if (x == NULL || PyDict_SetItemString(d, "COSMO_VALUE_BASE", x) < 0) 1484 return; 1485 Py_DECREF(x); 1486 #endif 1487 #ifdef CL_COSMO_VIDEO_MANUAL_CONTROL 1488 x = PyInt_FromLong(CL_COSMO_VIDEO_MANUAL_CONTROL); 1489 if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_MANUAL_CONTROL", x) < 0) 1490 return; 1491 Py_DECREF(x); 1492 #endif 1493 #ifdef CL_COSMO_VIDEO_TRANSFER_MODE 1494 x = PyInt_FromLong(CL_COSMO_VIDEO_TRANSFER_MODE); 1495 if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_TRANSFER_MODE", x) < 0) 1496 return; 1497 Py_DECREF(x); 1498 #endif 1499 #ifdef CL_DATA 1500 x = PyInt_FromLong(CL_DATA); 1501 if (x == NULL || PyDict_SetItemString(d, "DATA", x) < 0) 1502 return; 1503 Py_DECREF(x); 1504 #endif 1505 #ifdef CL_DECOMPRESSOR 1506 x = PyInt_FromLong(CL_DECOMPRESSOR); 1507 if (x == NULL || PyDict_SetItemString(d, "DECOMPRESSOR", x) < 0) 1508 return; 1509 Py_DECREF(x); 1510 #endif 1511 #ifdef CL_DSO_ERROR 1512 x = PyInt_FromLong(CL_DSO_ERROR); 1513 if (x == NULL || PyDict_SetItemString(d, "DSO_ERROR", x) < 0) 1514 return; 1515 Py_DECREF(x); 1516 #endif 1517 #ifdef CL_EDGE_THRESHOLD 1518 x = PyInt_FromLong(CL_EDGE_THRESHOLD); 1519 if (x == NULL || PyDict_SetItemString(d, "EDGE_THRESHOLD", x) < 0) 1520 return; 1521 Py_DECREF(x); 1522 #endif 1523 #ifdef CL_ENABLE_IMAGEINFO 1524 x = PyInt_FromLong(CL_ENABLE_IMAGEINFO); 1525 if (x == NULL || PyDict_SetItemString(d, "ENABLE_IMAGEINFO", x) < 0) 1526 return; 1527 Py_DECREF(x); 1528 #endif 1529 #ifdef CL_END_OF_SEQUENCE 1530 x = PyInt_FromLong(CL_END_OF_SEQUENCE); 1531 if (x == NULL || PyDict_SetItemString(d, "END_OF_SEQUENCE", x) < 0) 1532 return; 1533 Py_DECREF(x); 1534 #endif 1535 #ifdef CL_ENUM_VALUE 1536 x = PyInt_FromLong(CL_ENUM_VALUE); 1537 if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0) 1538 return; 1539 Py_DECREF(x); 1540 #endif 1541 #ifdef CL_EXACT_COMPRESSION_RATIO 1542 x = PyInt_FromLong(CL_EXACT_COMPRESSION_RATIO); 1543 if (x == NULL || PyDict_SetItemString(d, "EXACT_COMPRESSION_RATIO", x) < 0) 1544 return; 1545 Py_DECREF(x); 1546 #endif 1547 #ifdef CL_EXTERNAL_DEVICE 1548 x = PyInt_FromLong((long) CL_EXTERNAL_DEVICE); 1549 if (x == NULL || PyDict_SetItemString(d, "EXTERNAL_DEVICE", x) < 0) 1550 return; 1551 Py_DECREF(x); 1552 #endif 1553 #ifdef CL_FLOATING_ENUM_VALUE 1554 x = PyInt_FromLong(CL_FLOATING_ENUM_VALUE); 1555 if (x == NULL || PyDict_SetItemString(d, "FLOATING_ENUM_VALUE", x) < 0) 1556 return; 1557 Py_DECREF(x); 1558 #endif 1559 #ifdef CL_FLOATING_RANGE_VALUE 1560 x = PyInt_FromLong(CL_FLOATING_RANGE_VALUE); 1561 if (x == NULL || PyDict_SetItemString(d, "FLOATING_RANGE_VALUE", x) < 0) 1562 return; 1563 Py_DECREF(x); 1564 #endif 1565 #ifdef CL_FORMAT 1566 x = PyInt_FromLong(CL_FORMAT); 1567 if (x == NULL || PyDict_SetItemString(d, "FORMAT", x) < 0) 1568 return; 1569 Py_DECREF(x); 1570 #endif 1571 #ifdef CL_FORMAT_ABGR 1572 x = PyInt_FromLong(CL_FORMAT_ABGR); 1573 if (x == NULL || PyDict_SetItemString(d, "FORMAT_ABGR", x) < 0) 1574 return; 1575 Py_DECREF(x); 1576 #endif 1577 #ifdef CL_FORMAT_BGR 1578 x = PyInt_FromLong(CL_FORMAT_BGR); 1579 if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR", x) < 0) 1580 return; 1581 Py_DECREF(x); 1582 #endif 1583 #ifdef CL_FORMAT_BGR233 1584 x = PyInt_FromLong(CL_FORMAT_BGR233); 1585 if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR233", x) < 0) 1586 return; 1587 Py_DECREF(x); 1588 #endif 1589 #ifdef CL_FORMAT_GRAYSCALE 1590 x = PyInt_FromLong(CL_FORMAT_GRAYSCALE); 1591 if (x == NULL || PyDict_SetItemString(d, "FORMAT_GRAYSCALE", x) < 0) 1592 return; 1593 Py_DECREF(x); 1594 #endif 1595 #ifdef CL_FORMAT_MONO 1596 x = PyInt_FromLong(CL_FORMAT_MONO); 1597 if (x == NULL || PyDict_SetItemString(d, "FORMAT_MONO", x) < 0) 1598 return; 1599 Py_DECREF(x); 1600 #endif 1601 #ifdef CL_FORMAT_RBG323 1602 x = PyInt_FromLong(CL_FORMAT_RBG323); 1603 if (x == NULL || PyDict_SetItemString(d, "FORMAT_RBG323", x) < 0) 1604 return; 1605 Py_DECREF(x); 1606 #endif 1607 #ifdef CL_FORMAT_STEREO_INTERLEAVED 1608 x = PyInt_FromLong(CL_FORMAT_STEREO_INTERLEAVED); 1609 if (x == NULL || PyDict_SetItemString(d, "FORMAT_STEREO_INTERLEAVED", x) < 0) 1610 return; 1611 Py_DECREF(x); 1612 #endif 1613 #ifdef CL_FORMAT_XBGR 1614 x = PyInt_FromLong(CL_FORMAT_XBGR); 1615 if (x == NULL || PyDict_SetItemString(d, "FORMAT_XBGR", x) < 0) 1616 return; 1617 Py_DECREF(x); 1618 #endif 1619 #ifdef CL_FORMAT_YCbCr 1620 x = PyInt_FromLong(CL_FORMAT_YCbCr); 1621 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr", x) < 0) 1622 return; 1623 Py_DECREF(x); 1624 #endif 1625 #ifdef CL_FORMAT_YCbCr422 1626 x = PyInt_FromLong(CL_FORMAT_YCbCr422); 1627 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422", x) < 0) 1628 return; 1629 Py_DECREF(x); 1630 #endif 1631 #ifdef CL_FORMAT_YCbCr422DC 1632 x = PyInt_FromLong(CL_FORMAT_YCbCr422DC); 1633 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422DC", x) < 0) 1634 return; 1635 Py_DECREF(x); 1636 #endif 1637 #ifdef CL_FRAME 1638 x = PyInt_FromLong(CL_FRAME); 1639 if (x == NULL || PyDict_SetItemString(d, "FRAME", x) < 0) 1640 return; 1641 Py_DECREF(x); 1642 #endif 1643 #ifdef CL_FRAMES_PER_CHUNK 1644 x = PyInt_FromLong(CL_FRAMES_PER_CHUNK); 1645 if (x == NULL || PyDict_SetItemString(d, "FRAMES_PER_CHUNK", x) < 0) 1646 return; 1647 Py_DECREF(x); 1648 #endif 1649 #ifdef CL_FRAME_BUFFER_SIZE 1650 x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE); 1651 if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE", x) < 0) 1652 return; 1653 Py_DECREF(x); 1654 #endif 1655 #ifdef CL_FRAME_BUFFER_SIZE_ZERO 1656 x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE_ZERO); 1657 if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE_ZERO", x) < 0) 1658 return; 1659 Py_DECREF(x); 1660 #endif 1661 #ifdef CL_FRAME_INDEX 1662 x = PyInt_FromLong(CL_FRAME_INDEX); 1663 if (x == NULL || PyDict_SetItemString(d, "FRAME_INDEX", x) < 0) 1664 return; 1665 Py_DECREF(x); 1666 #endif 1667 #ifdef CL_FRAME_RATE 1668 x = PyInt_FromLong(CL_FRAME_RATE); 1669 if (x == NULL || PyDict_SetItemString(d, "FRAME_RATE", x) < 0) 1670 return; 1671 Py_DECREF(x); 1672 #endif 1673 #ifdef CL_FRAME_SIZE 1674 x = PyInt_FromLong(CL_FRAME_SIZE); 1675 if (x == NULL || PyDict_SetItemString(d, "FRAME_SIZE", x) < 0) 1676 return; 1677 Py_DECREF(x); 1678 #endif 1679 #ifdef CL_FRAME_TYPE 1680 x = PyInt_FromLong(CL_FRAME_TYPE); 1681 if (x == NULL || PyDict_SetItemString(d, "FRAME_TYPE", x) < 0) 1682 return; 1683 Py_DECREF(x); 1684 #endif 1685 #ifdef CL_G711_ALAW 1686 x = PyInt_FromLong(CL_G711_ALAW); 1687 if (x == NULL || PyDict_SetItemString(d, "G711_ALAW", x) < 0) 1688 return; 1689 Py_DECREF(x); 1690 #endif 1691 #ifdef CL_G711_ALAW_SOFTWARE 1692 x = PyInt_FromLong(CL_G711_ALAW_SOFTWARE); 1693 if (x == NULL || PyDict_SetItemString(d, "G711_ALAW_SOFTWARE", x) < 0) 1694 return; 1695 Py_DECREF(x); 1696 #endif 1697 #ifdef CL_G711_ULAW 1698 x = PyInt_FromLong(CL_G711_ULAW); 1699 if (x == NULL || PyDict_SetItemString(d, "G711_ULAW", x) < 0) 1700 return; 1701 Py_DECREF(x); 1702 #endif 1703 #ifdef CL_G711_ULAW_SOFTWARE 1704 x = PyInt_FromLong(CL_G711_ULAW_SOFTWARE); 1705 if (x == NULL || PyDict_SetItemString(d, "G711_ULAW_SOFTWARE", x) < 0) 1706 return; 1707 Py_DECREF(x); 1708 #endif 1709 #ifdef CL_GRAYSCALE 1710 x = PyInt_FromLong(CL_GRAYSCALE); 1711 if (x == NULL || PyDict_SetItemString(d, "GRAYSCALE", x) < 0) 1712 return; 1713 Py_DECREF(x); 1714 #endif 1715 #ifdef CL_HDCC 1716 x = PyInt_FromLong(CL_HDCC); 1717 if (x == NULL || PyDict_SetItemString(d, "HDCC", x) < 0) 1718 return; 1719 Py_DECREF(x); 1720 #endif 1721 #ifdef CL_HDCC_SAMPLES_PER_TILE 1722 x = PyInt_FromLong(CL_HDCC_SAMPLES_PER_TILE); 1723 if (x == NULL || PyDict_SetItemString(d, "HDCC_SAMPLES_PER_TILE", x) < 0) 1724 return; 1725 Py_DECREF(x); 1726 #endif 1727 #ifdef CL_HDCC_SOFTWARE 1728 x = PyInt_FromLong(CL_HDCC_SOFTWARE); 1729 if (x == NULL || PyDict_SetItemString(d, "HDCC_SOFTWARE", x) < 0) 1730 return; 1731 Py_DECREF(x); 1732 #endif 1733 #ifdef CL_HDCC_TILE_THRESHOLD 1734 x = PyInt_FromLong(CL_HDCC_TILE_THRESHOLD); 1735 if (x == NULL || PyDict_SetItemString(d, "HDCC_TILE_THRESHOLD", x) < 0) 1736 return; 1737 Py_DECREF(x); 1738 #endif 1739 #ifdef CL_HEADER_START_CODE 1740 x = PyInt_FromLong(CL_HEADER_START_CODE); 1741 if (x == NULL || PyDict_SetItemString(d, "HEADER_START_CODE", x) < 0) 1742 return; 1743 Py_DECREF(x); 1744 #endif 1745 #ifdef CL_IMAGEINFO_FIELDMASK 1746 x = PyInt_FromLong(CL_IMAGEINFO_FIELDMASK); 1747 if (x == NULL || PyDict_SetItemString(d, "IMAGEINFO_FIELDMASK", x) < 0) 1748 return; 1749 Py_DECREF(x); 1750 #endif 1751 #ifdef CL_IMAGE_CROP_BOTTOM 1752 x = PyInt_FromLong(CL_IMAGE_CROP_BOTTOM); 1753 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_BOTTOM", x) < 0) 1754 return; 1755 Py_DECREF(x); 1756 #endif 1757 #ifdef CL_IMAGE_CROP_LEFT 1758 x = PyInt_FromLong(CL_IMAGE_CROP_LEFT); 1759 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_LEFT", x) < 0) 1760 return; 1761 Py_DECREF(x); 1762 #endif 1763 #ifdef CL_IMAGE_CROP_RIGHT 1764 x = PyInt_FromLong(CL_IMAGE_CROP_RIGHT); 1765 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_RIGHT", x) < 0) 1766 return; 1767 Py_DECREF(x); 1768 #endif 1769 #ifdef CL_IMAGE_CROP_TOP 1770 x = PyInt_FromLong(CL_IMAGE_CROP_TOP); 1771 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_TOP", x) < 0) 1772 return; 1773 Py_DECREF(x); 1774 #endif 1775 #ifdef CL_IMAGE_HEIGHT 1776 x = PyInt_FromLong(CL_IMAGE_HEIGHT); 1777 if (x == NULL || PyDict_SetItemString(d, "IMAGE_HEIGHT", x) < 0) 1778 return; 1779 Py_DECREF(x); 1780 #endif 1781 #ifdef CL_IMAGE_WIDTH 1782 x = PyInt_FromLong(CL_IMAGE_WIDTH); 1783 if (x == NULL || PyDict_SetItemString(d, "IMAGE_WIDTH", x) < 0) 1784 return; 1785 Py_DECREF(x); 1786 #endif 1787 #ifdef CL_IMPACT_CODEC_CONTROL 1788 x = PyInt_FromLong(CL_IMPACT_CODEC_CONTROL); 1789 if (x == NULL || PyDict_SetItemString(d, "IMPACT_CODEC_CONTROL", x) < 0) 1790 return; 1791 Py_DECREF(x); 1792 #endif 1793 #ifdef CL_IMPACT_FRAME_INTERLEAVE 1794 x = PyInt_FromLong(CL_IMPACT_FRAME_INTERLEAVE); 1795 if (x == NULL || PyDict_SetItemString(d, "IMPACT_FRAME_INTERLEAVE", x) < 0) 1796 return; 1797 Py_DECREF(x); 1798 #endif 1799 #ifdef CL_IMPACT_NUM_PARAMS 1800 x = PyInt_FromLong(CL_IMPACT_NUM_PARAMS); 1801 if (x == NULL || PyDict_SetItemString(d, "IMPACT_NUM_PARAMS", x) < 0) 1802 return; 1803 Py_DECREF(x); 1804 #endif 1805 #ifdef CL_INTERNAL_FORMAT 1806 x = PyInt_FromLong(CL_INTERNAL_FORMAT); 1807 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_FORMAT", x) < 0) 1808 return; 1809 Py_DECREF(x); 1810 #endif 1811 #ifdef CL_INTERNAL_IMAGE_HEIGHT 1812 x = PyInt_FromLong(CL_INTERNAL_IMAGE_HEIGHT); 1813 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_HEIGHT", x) < 0) 1814 return; 1815 Py_DECREF(x); 1816 #endif 1817 #ifdef CL_INTERNAL_IMAGE_WIDTH 1818 x = PyInt_FromLong(CL_INTERNAL_IMAGE_WIDTH); 1819 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_WIDTH", x) < 0) 1820 return; 1821 Py_DECREF(x); 1822 #endif 1823 #ifdef CL_INTRA 1824 x = PyInt_FromLong(CL_INTRA); 1825 if (x == NULL || PyDict_SetItemString(d, "INTRA", x) < 0) 1826 return; 1827 Py_DECREF(x); 1828 #endif 1829 #ifdef CL_JPEG 1830 x = PyInt_FromLong(CL_JPEG); 1831 if (x == NULL || PyDict_SetItemString(d, "JPEG", x) < 0) 1832 return; 1833 Py_DECREF(x); 1834 #endif 1835 #ifdef CL_JPEG_COSMO 1836 x = PyInt_FromLong(CL_JPEG_COSMO); 1837 if (x == NULL || PyDict_SetItemString(d, "JPEG_COSMO", x) < 0) 1838 return; 1839 Py_DECREF(x); 1840 #endif 1841 #ifdef CL_JPEG_ERROR 1842 x = PyInt_FromLong(CL_JPEG_ERROR); 1843 if (x == NULL || PyDict_SetItemString(d, "JPEG_ERROR", x) < 0) 1844 return; 1845 Py_DECREF(x); 1846 #endif 1847 #ifdef CL_JPEG_IMPACT 1848 x = PyInt_FromLong(CL_JPEG_IMPACT); 1849 if (x == NULL || PyDict_SetItemString(d, "JPEG_IMPACT", x) < 0) 1850 return; 1851 Py_DECREF(x); 1852 #endif 1853 #ifdef CL_JPEG_NUM_PARAMS 1854 x = PyInt_FromLong(CL_JPEG_NUM_PARAMS); 1855 if (x == NULL || PyDict_SetItemString(d, "JPEG_NUM_PARAMS", x) < 0) 1856 return; 1857 Py_DECREF(x); 1858 #endif 1859 #ifdef CL_JPEG_QUALITY_FACTOR 1860 x = PyInt_FromLong(CL_JPEG_QUALITY_FACTOR); 1861 if (x == NULL || PyDict_SetItemString(d, "JPEG_QUALITY_FACTOR", x) < 0) 1862 return; 1863 Py_DECREF(x); 1864 #endif 1865 #ifdef CL_JPEG_QUANTIZATION_TABLES 1866 x = PyInt_FromLong(CL_JPEG_QUANTIZATION_TABLES); 1867 if (x == NULL || PyDict_SetItemString(d, "JPEG_QUANTIZATION_TABLES", x) < 0) 1868 return; 1869 Py_DECREF(x); 1870 #endif 1871 #ifdef CL_JPEG_SOFTWARE 1872 x = PyInt_FromLong(CL_JPEG_SOFTWARE); 1873 if (x == NULL || PyDict_SetItemString(d, "JPEG_SOFTWARE", x) < 0) 1874 return; 1875 Py_DECREF(x); 1876 #endif 1877 #ifdef CL_JPEG_STREAM_HEADERS 1878 x = PyInt_FromLong(CL_JPEG_STREAM_HEADERS); 1879 if (x == NULL || PyDict_SetItemString(d, "JPEG_STREAM_HEADERS", x) < 0) 1880 return; 1881 Py_DECREF(x); 1882 #endif 1883 #ifdef CL_KEYFRAME 1884 x = PyInt_FromLong(CL_KEYFRAME); 1885 if (x == NULL || PyDict_SetItemString(d, "KEYFRAME", x) < 0) 1886 return; 1887 Py_DECREF(x); 1888 #endif 1889 #ifdef CL_KEYFRAME_DISTANCE 1890 x = PyInt_FromLong(CL_KEYFRAME_DISTANCE); 1891 if (x == NULL || PyDict_SetItemString(d, "KEYFRAME_DISTANCE", x) < 0) 1892 return; 1893 Py_DECREF(x); 1894 #endif 1895 #ifdef CL_LAST_FRAME_INDEX 1896 x = PyInt_FromLong(CL_LAST_FRAME_INDEX); 1897 if (x == NULL || PyDict_SetItemString(d, "LAST_FRAME_INDEX", x) < 0) 1898 return; 1899 Py_DECREF(x); 1900 #endif 1901 #ifdef CL_LAYER 1902 x = PyInt_FromLong(CL_LAYER); 1903 if (x == NULL || PyDict_SetItemString(d, "LAYER", x) < 0) 1904 return; 1905 Py_DECREF(x); 1906 #endif 1907 #ifdef CL_LUMA_THRESHOLD 1908 x = PyInt_FromLong(CL_LUMA_THRESHOLD); 1909 if (x == NULL || PyDict_SetItemString(d, "LUMA_THRESHOLD", x) < 0) 1910 return; 1911 Py_DECREF(x); 1912 #endif 1913 #ifdef CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS 1914 x = PyInt_FromLong(CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS); 1915 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_AUDIO_ALGORITHMS", x) < 0) 1916 return; 1917 Py_DECREF(x); 1918 #endif 1919 #ifdef CL_MAX_NUMBER_OF_FORMATS 1920 x = PyInt_FromLong(CL_MAX_NUMBER_OF_FORMATS); 1921 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_FORMATS", x) < 0) 1922 return; 1923 Py_DECREF(x); 1924 #endif 1925 #ifdef CL_MAX_NUMBER_OF_ORIGINAL_FORMATS 1926 x = PyInt_FromLong(CL_MAX_NUMBER_OF_ORIGINAL_FORMATS); 1927 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_ORIGINAL_FORMATS", x) < 0) 1928 return; 1929 Py_DECREF(x); 1930 #endif 1931 #ifdef CL_MAX_NUMBER_OF_PARAMS 1932 x = PyInt_FromLong(CL_MAX_NUMBER_OF_PARAMS); 1933 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_PARAMS", x) < 0) 1934 return; 1935 Py_DECREF(x); 1936 #endif 1937 #ifdef CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS 1938 x = PyInt_FromLong(CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS); 1939 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_VIDEO_ALGORITHMS", x) < 0) 1940 return; 1941 Py_DECREF(x); 1942 #endif 1943 #ifdef CL_MONO 1944 x = PyInt_FromLong(CL_MONO); 1945 if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0) 1946 return; 1947 Py_DECREF(x); 1948 #endif 1949 #ifdef CL_MPEG1_AUDIO_AWARE 1950 x = PyInt_FromLong(CL_MPEG1_AUDIO_AWARE); 1951 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_AWARE", x) < 0) 1952 return; 1953 Py_DECREF(x); 1954 #endif 1955 #ifdef CL_MPEG1_AUDIO_LAYER 1956 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER); 1957 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER", x) < 0) 1958 return; 1959 Py_DECREF(x); 1960 #endif 1961 #ifdef CL_MPEG1_AUDIO_LAYER_I 1962 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_I); 1963 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_I", x) < 0) 1964 return; 1965 Py_DECREF(x); 1966 #endif 1967 #ifdef CL_MPEG1_AUDIO_LAYER_II 1968 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_II); 1969 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_II", x) < 0) 1970 return; 1971 Py_DECREF(x); 1972 #endif 1973 #ifdef CL_MPEG1_AUDIO_MODE 1974 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE); 1975 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE", x) < 0) 1976 return; 1977 Py_DECREF(x); 1978 #endif 1979 #ifdef CL_MPEG1_AUDIO_MODE_DUAL 1980 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_DUAL); 1981 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_DUAL", x) < 0) 1982 return; 1983 Py_DECREF(x); 1984 #endif 1985 #ifdef CL_MPEG1_AUDIO_MODE_JOINT 1986 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_JOINT); 1987 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_JOINT", x) < 0) 1988 return; 1989 Py_DECREF(x); 1990 #endif 1991 #ifdef CL_MPEG1_AUDIO_MODE_SINGLE 1992 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_SINGLE); 1993 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_SINGLE", x) < 0) 1994 return; 1995 Py_DECREF(x); 1996 #endif 1997 #ifdef CL_MPEG1_AUDIO_MODE_STEREO 1998 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_STEREO); 1999 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_STEREO", x) < 0) 2000 return; 2001 Py_DECREF(x); 2002 #endif 2003 #ifdef CL_MPEG1_AUDIO_SOFTWARE 2004 x = PyInt_FromLong(CL_MPEG1_AUDIO_SOFTWARE); 2005 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_SOFTWARE", x) < 0) 2006 return; 2007 Py_DECREF(x); 2008 #endif 2009 #ifdef CL_MPEG1_END_OF_STREAM 2010 x = PyInt_FromLong(CL_MPEG1_END_OF_STREAM); 2011 if (x == NULL || PyDict_SetItemString(d, "MPEG1_END_OF_STREAM", x) < 0) 2012 return; 2013 Py_DECREF(x); 2014 #endif 2015 #ifdef CL_MPEG1_ERROR 2016 x = PyInt_FromLong(CL_MPEG1_ERROR); 2017 if (x == NULL || PyDict_SetItemString(d, "MPEG1_ERROR", x) < 0) 2018 return; 2019 Py_DECREF(x); 2020 #endif 2021 #ifdef CL_MPEG1_NUM_PARAMS 2022 x = PyInt_FromLong(CL_MPEG1_NUM_PARAMS); 2023 if (x == NULL || PyDict_SetItemString(d, "MPEG1_NUM_PARAMS", x) < 0) 2024 return; 2025 Py_DECREF(x); 2026 #endif 2027 #ifdef CL_MPEG1_VIDEO_M 2028 x = PyInt_FromLong(CL_MPEG1_VIDEO_M); 2029 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_M", x) < 0) 2030 return; 2031 Py_DECREF(x); 2032 #endif 2033 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X 2034 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X); 2035 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X", x) < 0) 2036 return; 2037 Py_DECREF(x); 2038 #endif 2039 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y 2040 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y); 2041 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y", x) < 0) 2042 return; 2043 Py_DECREF(x); 2044 #endif 2045 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X 2046 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X); 2047 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X", x) < 0) 2048 return; 2049 Py_DECREF(x); 2050 #endif 2051 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y 2052 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y); 2053 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y", x) < 0) 2054 return; 2055 Py_DECREF(x); 2056 #endif 2057 #ifdef CL_MPEG1_VIDEO_N 2058 x = PyInt_FromLong(CL_MPEG1_VIDEO_N); 2059 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_N", x) < 0) 2060 return; 2061 Py_DECREF(x); 2062 #endif 2063 #ifdef CL_MPEG1_VIDEO_SOFTNESS 2064 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS); 2065 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS", x) < 0) 2066 return; 2067 Py_DECREF(x); 2068 #endif 2069 #ifdef CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM 2070 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM); 2071 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MAXIMUM", x) < 0) 2072 return; 2073 Py_DECREF(x); 2074 #endif 2075 #ifdef CL_MPEG1_VIDEO_SOFTNESS_MEDIUM 2076 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MEDIUM); 2077 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MEDIUM", x) < 0) 2078 return; 2079 Py_DECREF(x); 2080 #endif 2081 #ifdef CL_MPEG1_VIDEO_SOFTNESS_NONE 2082 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_NONE); 2083 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_NONE", x) < 0) 2084 return; 2085 Py_DECREF(x); 2086 #endif 2087 #ifdef CL_MPEG1_VIDEO_SOFTWARE 2088 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTWARE); 2089 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTWARE", x) < 0) 2090 return; 2091 Py_DECREF(x); 2092 #endif 2093 #ifdef CL_MPEG_VIDEO 2094 x = PyInt_FromLong(CL_MPEG_VIDEO); 2095 if (x == NULL || PyDict_SetItemString(d, "MPEG_VIDEO", x) < 0) 2096 return; 2097 Py_DECREF(x); 2098 #endif 2099 #ifdef CL_MULTIRATE_AWARE 2100 x = PyInt_FromLong(CL_MULTIRATE_AWARE); 2101 if (x == NULL || PyDict_SetItemString(d, "MULTIRATE_AWARE", x) < 0) 2102 return; 2103 Py_DECREF(x); 2104 #endif 2105 #ifdef CL_MVC1 2106 x = PyInt_FromLong(CL_MVC1); 2107 if (x == NULL || PyDict_SetItemString(d, "MVC1", x) < 0) 2108 return; 2109 Py_DECREF(x); 2110 #endif 2111 #ifdef CL_MVC1_SOFTWARE 2112 x = PyInt_FromLong(CL_MVC1_SOFTWARE); 2113 if (x == NULL || PyDict_SetItemString(d, "MVC1_SOFTWARE", x) < 0) 2114 return; 2115 Py_DECREF(x); 2116 #endif 2117 #ifdef CL_MVC2 2118 x = PyInt_FromLong(CL_MVC2); 2119 if (x == NULL || PyDict_SetItemString(d, "MVC2", x) < 0) 2120 return; 2121 Py_DECREF(x); 2122 #endif 2123 #ifdef CL_MVC2_BLENDING 2124 x = PyInt_FromLong(CL_MVC2_BLENDING); 2125 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING", x) < 0) 2126 return; 2127 Py_DECREF(x); 2128 #endif 2129 #ifdef CL_MVC2_BLENDING_OFF 2130 x = PyInt_FromLong(CL_MVC2_BLENDING_OFF); 2131 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_OFF", x) < 0) 2132 return; 2133 Py_DECREF(x); 2134 #endif 2135 #ifdef CL_MVC2_BLENDING_ON 2136 x = PyInt_FromLong(CL_MVC2_BLENDING_ON); 2137 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_ON", x) < 0) 2138 return; 2139 Py_DECREF(x); 2140 #endif 2141 #ifdef CL_MVC2_CHROMA_THRESHOLD 2142 x = PyInt_FromLong(CL_MVC2_CHROMA_THRESHOLD); 2143 if (x == NULL || PyDict_SetItemString(d, "MVC2_CHROMA_THRESHOLD", x) < 0) 2144 return; 2145 Py_DECREF(x); 2146 #endif 2147 #ifdef CL_MVC2_EDGE_THRESHOLD 2148 x = PyInt_FromLong(CL_MVC2_EDGE_THRESHOLD); 2149 if (x == NULL || PyDict_SetItemString(d, "MVC2_EDGE_THRESHOLD", x) < 0) 2150 return; 2151 Py_DECREF(x); 2152 #endif 2153 #ifdef CL_MVC2_ERROR 2154 x = PyInt_FromLong(CL_MVC2_ERROR); 2155 if (x == NULL || PyDict_SetItemString(d, "MVC2_ERROR", x) < 0) 2156 return; 2157 Py_DECREF(x); 2158 #endif 2159 #ifdef CL_MVC2_LUMA_THRESHOLD 2160 x = PyInt_FromLong(CL_MVC2_LUMA_THRESHOLD); 2161 if (x == NULL || PyDict_SetItemString(d, "MVC2_LUMA_THRESHOLD", x) < 0) 2162 return; 2163 Py_DECREF(x); 2164 #endif 2165 #ifdef CL_MVC2_SOFTWARE 2166 x = PyInt_FromLong(CL_MVC2_SOFTWARE); 2167 if (x == NULL || PyDict_SetItemString(d, "MVC2_SOFTWARE", x) < 0) 2168 return; 2169 Py_DECREF(x); 2170 #endif 2171 #ifdef CL_MVC3_QUALITY_LEVEL 2172 x = PyInt_FromLong(CL_MVC3_QUALITY_LEVEL); 2173 if (x == NULL || PyDict_SetItemString(d, "MVC3_QUALITY_LEVEL", x) < 0) 2174 return; 2175 Py_DECREF(x); 2176 #endif 2177 #ifdef CL_MVC3_SOFTWARE 2178 x = PyInt_FromLong(CL_MVC3_SOFTWARE); 2179 if (x == NULL || PyDict_SetItemString(d, "MVC3_SOFTWARE", x) < 0) 2180 return; 2181 Py_DECREF(x); 2182 #endif 2183 #ifdef CL_NEXT_NOT_AVAILABLE 2184 x = PyInt_FromLong(CL_NEXT_NOT_AVAILABLE); 2185 if (x == NULL || PyDict_SetItemString(d, "NEXT_NOT_AVAILABLE", x) < 0) 2186 return; 2187 Py_DECREF(x); 2188 #endif 2189 #ifdef CL_NOISE_MARGIN 2190 x = PyInt_FromLong(CL_NOISE_MARGIN); 2191 if (x == NULL || PyDict_SetItemString(d, "NOISE_MARGIN", x) < 0) 2192 return; 2193 Py_DECREF(x); 2194 #endif 2195 #ifdef CL_NONE 2196 x = PyInt_FromLong(CL_NONE); 2197 if (x == NULL || PyDict_SetItemString(d, "NONE", x) < 0) 2198 return; 2199 Py_DECREF(x); 2200 #endif 2201 #ifdef CL_NUMBER_OF_FORMATS 2202 x = PyInt_FromLong(CL_NUMBER_OF_FORMATS); 2203 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FORMATS", x) < 0) 2204 return; 2205 Py_DECREF(x); 2206 #endif 2207 #ifdef CL_NUMBER_OF_FRAMES 2208 x = PyInt_FromLong(CL_NUMBER_OF_FRAMES); 2209 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FRAMES", x) < 0) 2210 return; 2211 Py_DECREF(x); 2212 #endif 2213 #ifdef CL_NUMBER_OF_PARAMS 2214 x = PyInt_FromLong(CL_NUMBER_OF_PARAMS); 2215 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS", x) < 0) 2216 return; 2217 Py_DECREF(x); 2218 #endif 2219 #ifdef CL_NUMBER_OF_PARAMS_FREEZE 2220 x = PyInt_FromLong(CL_NUMBER_OF_PARAMS_FREEZE); 2221 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS_FREEZE", x) < 0) 2222 return; 2223 Py_DECREF(x); 2224 #endif 2225 #ifdef CL_NUMBER_OF_VIDEO_FORMATS 2226 x = PyInt_FromLong(CL_NUMBER_OF_VIDEO_FORMATS); 2227 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_VIDEO_FORMATS", x) < 0) 2228 return; 2229 Py_DECREF(x); 2230 #endif 2231 #ifdef CL_ORIENTATION 2232 x = PyInt_FromLong(CL_ORIENTATION); 2233 if (x == NULL || PyDict_SetItemString(d, "ORIENTATION", x) < 0) 2234 return; 2235 Py_DECREF(x); 2236 #endif 2237 #ifdef CL_ORIGINAL_FORMAT 2238 x = PyInt_FromLong(CL_ORIGINAL_FORMAT); 2239 if (x == NULL || PyDict_SetItemString(d, "ORIGINAL_FORMAT", x) < 0) 2240 return; 2241 Py_DECREF(x); 2242 #endif 2243 #ifdef CL_PARAM_OUT_OF_RANGE 2244 x = PyInt_FromLong(CL_PARAM_OUT_OF_RANGE); 2245 if (x == NULL || PyDict_SetItemString(d, "PARAM_OUT_OF_RANGE", x) < 0) 2246 return; 2247 Py_DECREF(x); 2248 #endif 2249 #ifdef CL_PIXEL_ASPECT 2250 x = PyInt_FromLong(CL_PIXEL_ASPECT); 2251 if (x == NULL || PyDict_SetItemString(d, "PIXEL_ASPECT", x) < 0) 2252 return; 2253 Py_DECREF(x); 2254 #endif 2255 #ifdef CL_PREDICTED 2256 x = PyInt_FromLong(CL_PREDICTED); 2257 if (x == NULL || PyDict_SetItemString(d, "PREDICTED", x) < 0) 2258 return; 2259 Py_DECREF(x); 2260 #endif 2261 #ifdef CL_PREROLL 2262 x = PyInt_FromLong(CL_PREROLL); 2263 if (x == NULL || PyDict_SetItemString(d, "PREROLL", x) < 0) 2264 return; 2265 Py_DECREF(x); 2266 #endif 2267 #ifdef CL_QUALITY_FACTOR 2268 x = PyInt_FromLong(CL_QUALITY_FACTOR); 2269 if (x == NULL || PyDict_SetItemString(d, "QUALITY_FACTOR", x) < 0) 2270 return; 2271 Py_DECREF(x); 2272 #endif 2273 #ifdef CL_QUALITY_LEVEL 2274 x = PyInt_FromLong(CL_QUALITY_LEVEL); 2275 if (x == NULL || PyDict_SetItemString(d, "QUALITY_LEVEL", x) < 0) 2276 return; 2277 Py_DECREF(x); 2278 #endif 2279 #ifdef CL_QUALITY_SPATIAL 2280 x = PyInt_FromLong(CL_QUALITY_SPATIAL); 2281 if (x == NULL || PyDict_SetItemString(d, "QUALITY_SPATIAL", x) < 0) 2282 return; 2283 Py_DECREF(x); 2284 #endif 2285 #ifdef CL_QUALITY_TEMPORAL 2286 x = PyInt_FromLong(CL_QUALITY_TEMPORAL); 2287 if (x == NULL || PyDict_SetItemString(d, "QUALITY_TEMPORAL", x) < 0) 2288 return; 2289 Py_DECREF(x); 2290 #endif 2291 #ifdef CL_QUANTIZATION_TABLES 2292 x = PyInt_FromLong(CL_QUANTIZATION_TABLES); 2293 if (x == NULL || PyDict_SetItemString(d, "QUANTIZATION_TABLES", x) < 0) 2294 return; 2295 Py_DECREF(x); 2296 #endif 2297 #ifdef CL_RANGE_VALUE 2298 x = PyInt_FromLong(CL_RANGE_VALUE); 2299 if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0) 2300 return; 2301 Py_DECREF(x); 2302 #endif 2303 #ifdef CL_RGB 2304 x = PyInt_FromLong(CL_RGB); 2305 if (x == NULL || PyDict_SetItemString(d, "RGB", x) < 0) 2306 return; 2307 Py_DECREF(x); 2308 #endif 2309 #ifdef CL_RGB332 2310 x = PyInt_FromLong(CL_RGB332); 2311 if (x == NULL || PyDict_SetItemString(d, "RGB332", x) < 0) 2312 return; 2313 Py_DECREF(x); 2314 #endif 2315 #ifdef CL_RGB8 2316 x = PyInt_FromLong(CL_RGB8); 2317 if (x == NULL || PyDict_SetItemString(d, "RGB8", x) < 0) 2318 return; 2319 Py_DECREF(x); 2320 #endif 2321 #ifdef CL_RGBA 2322 x = PyInt_FromLong(CL_RGBA); 2323 if (x == NULL || PyDict_SetItemString(d, "RGBA", x) < 0) 2324 return; 2325 Py_DECREF(x); 2326 #endif 2327 #ifdef CL_RGBX 2328 x = PyInt_FromLong(CL_RGBX); 2329 if (x == NULL || PyDict_SetItemString(d, "RGBX", x) < 0) 2330 return; 2331 Py_DECREF(x); 2332 #endif 2333 #ifdef CL_RLE 2334 x = PyInt_FromLong(CL_RLE); 2335 if (x == NULL || PyDict_SetItemString(d, "RLE", x) < 0) 2336 return; 2337 Py_DECREF(x); 2338 #endif 2339 #ifdef CL_RLE24 2340 x = PyInt_FromLong(CL_RLE24); 2341 if (x == NULL || PyDict_SetItemString(d, "RLE24", x) < 0) 2342 return; 2343 Py_DECREF(x); 2344 #endif 2345 #ifdef CL_RLE24_SOFTWARE 2346 x = PyInt_FromLong(CL_RLE24_SOFTWARE); 2347 if (x == NULL || PyDict_SetItemString(d, "RLE24_SOFTWARE", x) < 0) 2348 return; 2349 Py_DECREF(x); 2350 #endif 2351 #ifdef CL_RLE_SOFTWARE 2352 x = PyInt_FromLong(CL_RLE_SOFTWARE); 2353 if (x == NULL || PyDict_SetItemString(d, "RLE_SOFTWARE", x) < 0) 2354 return; 2355 Py_DECREF(x); 2356 #endif 2357 #ifdef CL_RTR 2358 x = PyInt_FromLong(CL_RTR); 2359 if (x == NULL || PyDict_SetItemString(d, "RTR", x) < 0) 2360 return; 2361 Py_DECREF(x); 2362 #endif 2363 #ifdef CL_RTR1 2364 x = PyInt_FromLong(CL_RTR1); 2365 if (x == NULL || PyDict_SetItemString(d, "RTR1", x) < 0) 2366 return; 2367 Py_DECREF(x); 2368 #endif 2369 #ifdef CL_RTR_QUALITY_LEVEL 2370 x = PyInt_FromLong(CL_RTR_QUALITY_LEVEL); 2371 if (x == NULL || PyDict_SetItemString(d, "RTR_QUALITY_LEVEL", x) < 0) 2372 return; 2373 Py_DECREF(x); 2374 #endif 2375 #ifdef CL_SAMPLES_PER_TILE 2376 x = PyInt_FromLong(CL_SAMPLES_PER_TILE); 2377 if (x == NULL || PyDict_SetItemString(d, "SAMPLES_PER_TILE", x) < 0) 2378 return; 2379 Py_DECREF(x); 2380 #endif 2381 #ifdef CL_SCHEME_BUSY 2382 x = PyInt_FromLong(CL_SCHEME_BUSY); 2383 if (x == NULL || PyDict_SetItemString(d, "SCHEME_BUSY", x) < 0) 2384 return; 2385 Py_DECREF(x); 2386 #endif 2387 #ifdef CL_SCHEME_NOT_AVAILABLE 2388 x = PyInt_FromLong(CL_SCHEME_NOT_AVAILABLE); 2389 if (x == NULL || PyDict_SetItemString(d, "SCHEME_NOT_AVAILABLE", x) < 0) 2390 return; 2391 Py_DECREF(x); 2392 #endif 2393 #ifdef CL_SPEED 2394 x = PyInt_FromLong(CL_SPEED); 2395 if (x == NULL || PyDict_SetItemString(d, "SPEED", x) < 0) 2396 return; 2397 Py_DECREF(x); 2398 #endif 2399 #ifdef CL_STEREO_INTERLEAVED 2400 x = PyInt_FromLong(CL_STEREO_INTERLEAVED); 2401 if (x == NULL || PyDict_SetItemString(d, "STEREO_INTERLEAVED", x) < 0) 2402 return; 2403 Py_DECREF(x); 2404 #endif 2405 #ifdef CL_STREAM_HEADERS 2406 x = PyInt_FromLong(CL_STREAM_HEADERS); 2407 if (x == NULL || PyDict_SetItemString(d, "STREAM_HEADERS", x) < 0) 2408 return; 2409 Py_DECREF(x); 2410 #endif 2411 #ifdef CL_TILE_THRESHOLD 2412 x = PyInt_FromLong(CL_TILE_THRESHOLD); 2413 if (x == NULL || PyDict_SetItemString(d, "TILE_THRESHOLD", x) < 0) 2414 return; 2415 Py_DECREF(x); 2416 #endif 2417 #ifdef CL_TOP_DOWN 2418 x = PyInt_FromLong(CL_TOP_DOWN); 2419 if (x == NULL || PyDict_SetItemString(d, "TOP_DOWN", x) < 0) 2420 return; 2421 Py_DECREF(x); 2422 #endif 2423 #ifdef CL_ULAW 2424 x = PyInt_FromLong(CL_ULAW); 2425 if (x == NULL || PyDict_SetItemString(d, "ULAW", x) < 0) 2426 return; 2427 Py_DECREF(x); 2428 #endif 2429 #ifdef CL_UNCOMPRESSED 2430 x = PyInt_FromLong(CL_UNCOMPRESSED); 2431 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED", x) < 0) 2432 return; 2433 Py_DECREF(x); 2434 #endif 2435 #ifdef CL_UNCOMPRESSED_AUDIO 2436 x = PyInt_FromLong(CL_UNCOMPRESSED_AUDIO); 2437 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_AUDIO", x) < 0) 2438 return; 2439 Py_DECREF(x); 2440 #endif 2441 #ifdef CL_UNCOMPRESSED_VIDEO 2442 x = PyInt_FromLong(CL_UNCOMPRESSED_VIDEO); 2443 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_VIDEO", x) < 0) 2444 return; 2445 Py_DECREF(x); 2446 #endif 2447 #ifdef CL_UNKNOWN_SCHEME 2448 x = PyInt_FromLong(CL_UNKNOWN_SCHEME); 2449 if (x == NULL || PyDict_SetItemString(d, "UNKNOWN_SCHEME", x) < 0) 2450 return; 2451 Py_DECREF(x); 2452 #endif 2453 #ifdef CL_VIDEO 2454 x = PyInt_FromLong(CL_VIDEO); 2455 if (x == NULL || PyDict_SetItemString(d, "VIDEO", x) < 0) 2456 return; 2457 Py_DECREF(x); 2458 #endif 2459 #ifdef CL_Y 2460 x = PyInt_FromLong(CL_Y); 2461 if (x == NULL || PyDict_SetItemString(d, "Y", x) < 0) 2462 return; 2463 Py_DECREF(x); 2464 #endif 2465 #ifdef CL_YCbCr 2466 x = PyInt_FromLong(CL_YCbCr); 2467 if (x == NULL || PyDict_SetItemString(d, "YCbCr", x) < 0) 2468 return; 2469 Py_DECREF(x); 2470 #endif 2471 #ifdef CL_YCbCr422 2472 x = PyInt_FromLong(CL_YCbCr422); 2473 if (x == NULL || PyDict_SetItemString(d, "YCbCr422", x) < 0) 2474 return; 2475 Py_DECREF(x); 2476 #endif 2477 #ifdef CL_YCbCr422DC 2478 x = PyInt_FromLong(CL_YCbCr422DC); 2479 if (x == NULL || PyDict_SetItemString(d, "YCbCr422DC", x) < 0) 2480 return; 2481 Py_DECREF(x); 2482 #endif 2483 #ifdef CL_YCbCr422HC 2484 x = PyInt_FromLong(CL_YCbCr422HC); 2485 if (x == NULL || PyDict_SetItemString(d, "YCbCr422HC", x) < 0) 2486 return; 2487 Py_DECREF(x); 2488 #endif 2489 #ifdef CL_YUV 2490 x = PyInt_FromLong(CL_YUV); 2491 if (x == NULL || PyDict_SetItemString(d, "YUV", x) < 0) 2492 return; 2493 Py_DECREF(x); 2494 #endif 2495 #ifdef CL_YUV422 2496 x = PyInt_FromLong(CL_YUV422); 2497 if (x == NULL || PyDict_SetItemString(d, "YUV422", x) < 0) 2498 return; 2499 Py_DECREF(x); 2500 #endif 2501 #ifdef CL_YUV422DC 2502 x = PyInt_FromLong(CL_YUV422DC); 2503 if (x == NULL || PyDict_SetItemString(d, "YUV422DC", x) < 0) 2504 return; 2505 Py_DECREF(x); 2506 #endif 2507 #ifdef CL_YUV422HC 2508 x = PyInt_FromLong(CL_YUV422HC); 2509 if (x == NULL || PyDict_SetItemString(d, "YUV422HC", x) < 0) 2510 return; 2511 Py_DECREF(x); 2512 #endif 2513 #ifdef AWCMP_STEREO 2514 x = PyInt_FromLong(AWCMP_STEREO); 2515 if (x == NULL || PyDict_SetItemString(d, "AWCMP_STEREO", x) < 0) 2516 return; 2517 Py_DECREF(x); 2518 #endif 2519 #ifdef AWCMP_JOINT_STEREO 2520 x = PyInt_FromLong(AWCMP_JOINT_STEREO); 2521 if (x == NULL || PyDict_SetItemString(d, "AWCMP_JOINT_STEREO", x) < 0) 2522 return; 2523 Py_DECREF(x); 2524 #endif 2525 #ifdef AWCMP_INDEPENDENT 2526 x = PyInt_FromLong(AWCMP_INDEPENDENT); 2527 if (x == NULL || PyDict_SetItemString(d, "AWCMP_INDEPENDENT", x) < 0) 2528 return; 2529 Py_DECREF(x); 2530 #endif 2531 #ifdef AWCMP_FIXED_RATE 2532 x = PyInt_FromLong(AWCMP_FIXED_RATE); 2533 if (x == NULL || PyDict_SetItemString(d, "AWCMP_FIXED_RATE", x) < 0) 2534 return; 2535 Py_DECREF(x); 2536 #endif 2537 #ifdef AWCMP_CONST_QUAL 2538 x = PyInt_FromLong(AWCMP_CONST_QUAL); 2539 if (x == NULL || PyDict_SetItemString(d, "AWCMP_CONST_QUAL", x) < 0) 2540 return; 2541 Py_DECREF(x); 2542 #endif 2543 #ifdef AWCMP_LOSSLESS 2544 x = PyInt_FromLong(AWCMP_LOSSLESS); 2545 if (x == NULL || PyDict_SetItemString(d, "AWCMP_LOSSLESS", x) < 0) 2546 return; 2547 Py_DECREF(x); 2548 #endif 2549 #ifdef AWCMP_MPEG_LAYER_I 2550 x = PyInt_FromLong(AWCMP_MPEG_LAYER_I); 2551 if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_I", x) < 0) 2552 return; 2553 Py_DECREF(x); 2554 #endif 2555 #ifdef AWCMP_MPEG_LAYER_II 2556 x = PyInt_FromLong(AWCMP_MPEG_LAYER_II); 2557 if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_II", x) < 0) 2558 return; 2559 Py_DECREF(x); 2560 #endif 2561 2562 (void) clSetErrorHandler(cl_ErrorHandler); 2563 } 2564
