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 14typedef 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 22static PyObject *ClError; /* exception cl.error */ 23 24static 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********************************************************************/ 38static void 39cl_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 */ 60static int 61param_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********************************************************************/ 98static PyObject * 99cl_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 143static PyObject * 144cl_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 184static PyObject * 185doClose(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 207static PyObject * 208clm_CloseCompressor(PyObject *self) 209{ 210 return doClose(SELF, clCloseCompressor); 211} 212 213static PyObject * 214clm_CloseDecompressor(PyObject *self) 215{ 216 return doClose(SELF, clCloseDecompressor); 217} 218 219static PyObject * 220clm_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 269static PyObject * 270clm_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 306static PyObject * 307doParams(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 372static PyObject * 373clm_GetParams(PyObject *self, PyObject *args) 374{ 375 return doParams(SELF, args, clGetParams, 1); 376} 377 378static PyObject * 379clm_SetParams(PyObject *self, PyObject *args) 380{ 381 return doParams(SELF, args, clSetParams, 0); 382} 383 384static PyObject * 385do_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 408static PyObject * 409clm_GetParam(PyObject *self, PyObject *args) 410{ 411 return do_get(SELF, args, clGetParam); 412} 413 414static PyObject * 415clm_GetDefault(PyObject *self, PyObject *args) 416{ 417 return do_get(SELF, args, clGetDefault); 418} 419 420static PyObject * 421clm_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 455static PyObject * 456clm_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 477static PyObject * 478clm_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 525static PyObject * 526clm_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 547static PyObject * 548clm_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 569static PyObject * 570clm_QuerySchemeFromHandle(PyObject *self) 571{ 572 CheckCompressor(SELF); 573 return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl)); 574} 575 576static PyObject * 577clm_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 591static 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 608static 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 626static void 627cl_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 638static PyObject * 639cl_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 647static 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 665static PyObject * 666doOpen(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 694static PyObject * 695cl_OpenCompressor(PyObject *self, PyObject *args) 696{ 697 return doOpen(self, args, clOpenCompressor, 1); 698} 699 700static PyObject * 701cl_OpenDecompressor(PyObject *self, PyObject *args) 702{ 703 return doOpen(self, args, clOpenDecompressor, 0); 704} 705 706static PyObject * 707cl_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 725static PyObject * 726cl_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 736static PyObject * 737cl_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 786static PyObject * 787cl_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 806static PyObject * 807cl_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 824static PyObject * 825do_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 864static PyObject * 865cl_SetDefault(PyObject *self, PyObject *args) 866{ 867 return do_set(self, args, clSetDefault); 868} 869 870static PyObject * 871cl_SetMin(PyObject *self, PyObject *args) 872{ 873 return do_set(self, args, clSetMin); 874} 875 876static PyObject * 877cl_SetMax(PyObject *self, PyObject *args) 878{ 879 return do_set(self, args, clSetMax); 880} 881 882#define func(name, handler) \ 883static 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) \ 891static 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 898func(BytesPerSample, Int_FromLong) 899func(BytesPerPixel, Int_FromLong) 900func(AudioFormatName, String_FromString) 901func(VideoFormatName, String_FromString) 902func(AlgorithmNumber, Int_FromLong) 903func(AlgorithmType, Int_FromLong) 904func2(Algorithm, Int_FromLong) 905func(ParamNumber, Int_FromLong) 906func(ParamType, Int_FromLong) 907func2(ParamID, Int_FromLong) 908 909#ifdef CLDEBUG 910 static PyObject * 911cvt_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 927static 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 960void 961initcl(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