1 2 /* imageopmodule - Various operations on pictures */ 3 4 #ifdef sun 5 #define signed 6 #endif 7 8 #include "Python.h" 9 10 #if SIZEOF_INT == 4 11 typedef int Py_Int32; 12 typedef unsigned int Py_UInt32; 13 #else 14 #if SIZEOF_LONG == 4 15 typedef long Py_Int32; 16 typedef unsigned long Py_UInt32; 17 #else 18 #error "No 4-byte integral type" 19 #endif 20 #endif 21 22 #define CHARP(cp, xmax, x, y) ((char *)(cp+y*xmax+x)) 23 #define SHORTP(cp, xmax, x, y) ((short *)(cp+2*(y*xmax+x))) 24 #define LONGP(cp, xmax, x, y) ((Py_Int32 *)(cp+4*(y*xmax+x))) 25 26 static PyObject *ImageopError; 27 static PyObject *ImageopDict; 28 29 /** 30 * Check a coordonnate, make sure that (0 < value). 31 * Return 0 on error. 32 */ 33 static int 34 check_coordonnate(int value, const char* name) 35 { 36 if ( 0 < value) 37 return 1; 38 PyErr_Format(PyExc_ValueError, "%s value is negative or nul", name); 39 return 0; 40 } 41 42 /** 43 * Check integer overflow to make sure that product == x*y*size. 44 * Return 0 on error. 45 */ 46 static int 47 check_multiply_size(int product, int x, const char* xname, int y, const char* yname, int size) 48 { 49 if ( !check_coordonnate(x, xname) ) 50 return 0; 51 if ( !check_coordonnate(y, yname) ) 52 return 0; 53 if ( size == (product / y) / x ) 54 return 1; 55 PyErr_SetString(ImageopError, "String has incorrect length"); 56 return 0; 57 } 58 59 /** 60 * Check integer overflow to make sure that product == x*y. 61 * Return 0 on error. 62 */ 63 static int 64 check_multiply(int product, int x, int y) 65 { 66 return check_multiply_size(product, x, "x", y, "y", 1); 67 } 68 69 /* If this function returns true (the default if anything goes wrong), we're 70 behaving in a backward-compatible way with respect to how multi-byte pixels 71 are stored in the strings. The code in this module was originally written 72 for an SGI which is a big-endian system, and so the old code assumed that 73 4-byte integers hold the R, G, and B values in a particular order. 74 However, on little-endian systems the order is reversed, and so not 75 actually compatible with what gl.lrectwrite and imgfile expect. 76 (gl.lrectwrite and imgfile are also SGI-specific, however, it is 77 conceivable that the data handled here comes from or goes to an SGI or that 78 it is otherwise used in the expectation that the byte order in the strings 79 is as specified.) 80 81 The function returns the value of the module variable 82 "backward_compatible", or 1 if the variable does not exist or is not an 83 int. 84 */ 85 86 static int 87 imageop_backward_compatible(void) 88 { 89 static PyObject *bcos; 90 PyObject *bco; 91 long rc; 92 93 if (ImageopDict == NULL) /* "cannot happen" */ 94 return 1; 95 if (bcos == NULL) { 96 /* cache string object for future use */ 97 bcos = PyString_FromString("backward_compatible"); 98 if (bcos == NULL) 99 return 1; 100 } 101 bco = PyDict_GetItem(ImageopDict, bcos); 102 if (bco == NULL) 103 return 1; 104 if (!PyInt_Check(bco)) 105 return 1; 106 rc = PyInt_AsLong(bco); 107 if (PyErr_Occurred()) { 108 /* not an integer, or too large, or something */ 109 PyErr_Clear(); 110 rc = 1; 111 } 112 return rc != 0; /* convert to values 0, 1 */ 113 } 114 115 static PyObject * 116 imageop_crop(PyObject *self, PyObject *args) 117 { 118 char *cp, *ncp; 119 short *nsp; 120 Py_Int32 *nlp; 121 int len, size, x, y, newx1, newx2, newy1, newy2, nlen; 122 int ix, iy, xstep, ystep; 123 PyObject *rv; 124 125 if ( !PyArg_ParseTuple(args, "s#iiiiiii", &cp, &len, &size, &x, &y, 126 &newx1, &newy1, &newx2, &newy2) ) 127 return 0; 128 129 if ( size != 1 && size != 2 && size != 4 ) { 130 PyErr_SetString(ImageopError, "Size should be 1, 2 or 4"); 131 return 0; 132 } 133 if ( !check_multiply_size(len, x, "x", y, "y", size) ) 134 return 0; 135 136 xstep = (newx1 < newx2)? 1 : -1; 137 ystep = (newy1 < newy2)? 1 : -1; 138 139 nlen = (abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size; 140 if ( !check_multiply_size(nlen, abs(newx2-newx1)+1, "abs(newx2-newx1)+1", abs(newy2-newy1)+1, "abs(newy2-newy1)+1", size) ) 141 return 0; 142 rv = PyString_FromStringAndSize(NULL, nlen); 143 if ( rv == 0 ) 144 return 0; 145 ncp = (char *)PyString_AsString(rv); 146 nsp = (short *)ncp; 147 nlp = (Py_Int32 *)ncp; 148 newy2 += ystep; 149 newx2 += xstep; 150 for( iy = newy1; iy != newy2; iy+=ystep ) { 151 for ( ix = newx1; ix != newx2; ix+=xstep ) { 152 if ( iy < 0 || iy >= y || ix < 0 || ix >= x ) { 153 if ( size == 1 ) 154 *ncp++ = 0; 155 else 156 *nlp++ = 0; 157 } else { 158 if ( size == 1 ) 159 *ncp++ = *CHARP(cp, x, ix, iy); 160 else if ( size == 2 ) 161 *nsp++ = *SHORTP(cp, x, ix, iy); 162 else 163 *nlp++ = *LONGP(cp, x, ix, iy); 164 } 165 } 166 } 167 return rv; 168 } 169 170 static PyObject * 171 imageop_scale(PyObject *self, PyObject *args) 172 { 173 char *cp, *ncp; 174 short *nsp; 175 Py_Int32 *nlp; 176 int len, size, x, y, newx, newy, nlen; 177 int ix, iy; 178 int oix, oiy; 179 PyObject *rv; 180 181 if ( !PyArg_ParseTuple(args, "s#iiiii", 182 &cp, &len, &size, &x, &y, &newx, &newy) ) 183 return 0; 184 185 if ( size != 1 && size != 2 && size != 4 ) { 186 PyErr_SetString(ImageopError, "Size should be 1, 2 or 4"); 187 return 0; 188 } 189 if ( !check_multiply_size(len, x, "x", y, "y", size) ) 190 return 0; 191 nlen = newx*newy*size; 192 if ( !check_multiply_size(nlen, newx, "newx", newy, "newy", size) ) 193 return 0; 194 195 rv = PyString_FromStringAndSize(NULL, nlen); 196 if ( rv == 0 ) 197 return 0; 198 ncp = (char *)PyString_AsString(rv); 199 nsp = (short *)ncp; 200 nlp = (Py_Int32 *)ncp; 201 for( iy = 0; iy < newy; iy++ ) { 202 for ( ix = 0; ix < newx; ix++ ) { 203 oix = ix * x / newx; 204 oiy = iy * y / newy; 205 if ( size == 1 ) 206 *ncp++ = *CHARP(cp, x, oix, oiy); 207 else if ( size == 2 ) 208 *nsp++ = *SHORTP(cp, x, oix, oiy); 209 else 210 *nlp++ = *LONGP(cp, x, oix, oiy); 211 } 212 } 213 return rv; 214 } 215 216 /* Note: this routine can use a bit of optimizing */ 217 218 static PyObject * 219 imageop_tovideo(PyObject *self, PyObject *args) 220 { 221 int maxx, maxy, x, y, len; 222 int i; 223 unsigned char *cp, *ncp; 224 int width; 225 PyObject *rv; 226 227 228 if ( !PyArg_ParseTuple(args, "s#iii", &cp, &len, &width, &maxx, &maxy) ) 229 return 0; 230 231 if ( width != 1 && width != 4 ) { 232 PyErr_SetString(ImageopError, "Size should be 1 or 4"); 233 return 0; 234 } 235 if ( !check_multiply_size(len, maxx, "max", maxy, "maxy", width) ) 236 return 0; 237 238 rv = PyString_FromStringAndSize(NULL, len); 239 if ( rv == 0 ) 240 return 0; 241 ncp = (unsigned char *)PyString_AsString(rv); 242 243 if ( width == 1 ) { 244 memcpy(ncp, cp, maxx); /* Copy first line */ 245 ncp += maxx; 246 for (y=1; y<maxy; y++) { /* Interpolate other lines */ 247 for(x=0; x<maxx; x++) { 248 i = y*maxx + x; 249 *ncp++ = ((int)cp[i] + (int)cp[i-maxx]) >> 1; 250 } 251 } 252 } else { 253 memcpy(ncp, cp, maxx*4); /* Copy first line */ 254 ncp += maxx*4; 255 for (y=1; y<maxy; y++) { /* Interpolate other lines */ 256 for(x=0; x<maxx; x++) { 257 i = (y*maxx + x)*4 + 1; 258 *ncp++ = 0; /* Skip alfa comp */ 259 *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1; 260 i++; 261 *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1; 262 i++; 263 *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1; 264 } 265 } 266 } 267 return rv; 268 } 269 270 static PyObject * 271 imageop_grey2mono(PyObject *self, PyObject *args) 272 { 273 int tres, x, y, len; 274 unsigned char *cp, *ncp; 275 unsigned char ovalue; 276 PyObject *rv; 277 int i, bit; 278 279 280 if ( !PyArg_ParseTuple(args, "s#iii", &cp, &len, &x, &y, &tres) ) 281 return 0; 282 283 if ( !check_multiply(len, x, y) ) 284 return 0; 285 286 rv = PyString_FromStringAndSize(NULL, (len+7)/8); 287 if ( rv == 0 ) 288 return 0; 289 ncp = (unsigned char *)PyString_AsString(rv); 290 291 bit = 0x80; 292 ovalue = 0; 293 for ( i=0; i < len; i++ ) { 294 if ( (int)cp[i] > tres ) 295 ovalue |= bit; 296 bit >>= 1; 297 if ( bit == 0 ) { 298 *ncp++ = ovalue; 299 bit = 0x80; 300 ovalue = 0; 301 } 302 } 303 if ( bit != 0x80 ) 304 *ncp++ = ovalue; 305 return rv; 306 } 307 308 static PyObject * 309 imageop_grey2grey4(PyObject *self, PyObject *args) 310 { 311 int x, y, len; 312 unsigned char *cp, *ncp; 313 unsigned char ovalue; 314 PyObject *rv; 315 int i; 316 int pos; 317 318 319 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 320 return 0; 321 322 if ( !check_multiply(len, x, y) ) 323 return 0; 324 325 rv = PyString_FromStringAndSize(NULL, (len+1)/2); 326 if ( rv == 0 ) 327 return 0; 328 ncp = (unsigned char *)PyString_AsString(rv); 329 pos = 0; 330 ovalue = 0; 331 for ( i=0; i < len; i++ ) { 332 ovalue |= ((int)cp[i] & 0xf0) >> pos; 333 pos += 4; 334 if ( pos == 8 ) { 335 *ncp++ = ovalue; 336 ovalue = 0; 337 pos = 0; 338 } 339 } 340 if ( pos != 0 ) 341 *ncp++ = ovalue; 342 return rv; 343 } 344 345 static PyObject * 346 imageop_grey2grey2(PyObject *self, PyObject *args) 347 { 348 int x, y, len; 349 unsigned char *cp, *ncp; 350 unsigned char ovalue; 351 PyObject *rv; 352 int i; 353 int pos; 354 355 356 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 357 return 0; 358 359 if ( !check_multiply(len, x, y) ) 360 return 0; 361 362 rv = PyString_FromStringAndSize(NULL, (len+3)/4); 363 if ( rv == 0 ) 364 return 0; 365 ncp = (unsigned char *)PyString_AsString(rv); 366 pos = 0; 367 ovalue = 0; 368 for ( i=0; i < len; i++ ) { 369 ovalue |= ((int)cp[i] & 0xc0) >> pos; 370 pos += 2; 371 if ( pos == 8 ) { 372 *ncp++ = ovalue; 373 ovalue = 0; 374 pos = 0; 375 } 376 } 377 if ( pos != 0 ) 378 *ncp++ = ovalue; 379 return rv; 380 } 381 382 static PyObject * 383 imageop_dither2mono(PyObject *self, PyObject *args) 384 { 385 int sum, x, y, len; 386 unsigned char *cp, *ncp; 387 unsigned char ovalue; 388 PyObject *rv; 389 int i, bit; 390 391 392 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 393 return 0; 394 395 if ( !check_multiply(len, x, y) ) 396 return 0; 397 398 rv = PyString_FromStringAndSize(NULL, (len+7)/8); 399 if ( rv == 0 ) 400 return 0; 401 ncp = (unsigned char *)PyString_AsString(rv); 402 403 bit = 0x80; 404 ovalue = 0; 405 sum = 0; 406 for ( i=0; i < len; i++ ) { 407 sum += cp[i]; 408 if ( sum >= 256 ) { 409 sum -= 256; 410 ovalue |= bit; 411 } 412 bit >>= 1; 413 if ( bit == 0 ) { 414 *ncp++ = ovalue; 415 bit = 0x80; 416 ovalue = 0; 417 } 418 } 419 if ( bit != 0x80 ) 420 *ncp++ = ovalue; 421 return rv; 422 } 423 424 static PyObject * 425 imageop_dither2grey2(PyObject *self, PyObject *args) 426 { 427 int x, y, len; 428 unsigned char *cp, *ncp; 429 unsigned char ovalue; 430 PyObject *rv; 431 int i; 432 int pos; 433 int sum = 0, nvalue; 434 435 436 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 437 return 0; 438 439 if ( !check_multiply(len, x, y) ) 440 return 0; 441 442 rv = PyString_FromStringAndSize(NULL, (len+3)/4); 443 if ( rv == 0 ) 444 return 0; 445 ncp = (unsigned char *)PyString_AsString(rv); 446 pos = 1; 447 ovalue = 0; 448 for ( i=0; i < len; i++ ) { 449 sum += cp[i]; 450 nvalue = sum & 0x180; 451 sum -= nvalue; 452 ovalue |= nvalue >> pos; 453 pos += 2; 454 if ( pos == 9 ) { 455 *ncp++ = ovalue; 456 ovalue = 0; 457 pos = 1; 458 } 459 } 460 if ( pos != 0 ) 461 *ncp++ = ovalue; 462 return rv; 463 } 464 465 static PyObject * 466 imageop_mono2grey(PyObject *self, PyObject *args) 467 { 468 int v0, v1, x, y, len, nlen; 469 unsigned char *cp, *ncp; 470 PyObject *rv; 471 int i, bit; 472 473 if ( !PyArg_ParseTuple(args, "s#iiii", &cp, &len, &x, &y, &v0, &v1) ) 474 return 0; 475 476 nlen = x*y; 477 if ( !check_multiply(nlen, x, y) ) 478 return 0; 479 if ( (nlen+7)/8 != len ) { 480 PyErr_SetString(ImageopError, "String has incorrect length"); 481 return 0; 482 } 483 484 rv = PyString_FromStringAndSize(NULL, nlen); 485 if ( rv == 0 ) 486 return 0; 487 ncp = (unsigned char *)PyString_AsString(rv); 488 489 bit = 0x80; 490 for ( i=0; i < nlen; i++ ) { 491 if ( *cp & bit ) 492 *ncp++ = v1; 493 else 494 *ncp++ = v0; 495 bit >>= 1; 496 if ( bit == 0 ) { 497 bit = 0x80; 498 cp++; 499 } 500 } 501 return rv; 502 } 503 504 static PyObject * 505 imageop_grey22grey(PyObject *self, PyObject *args) 506 { 507 int x, y, len, nlen; 508 unsigned char *cp, *ncp; 509 PyObject *rv; 510 int i, pos, value = 0, nvalue; 511 512 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 513 return 0; 514 515 nlen = x*y; 516 if ( !check_multiply(nlen, x, y) ) { 517 return 0; 518 } 519 if ( (nlen+3)/4 != len ) { 520 PyErr_SetString(ImageopError, "String has incorrect length"); 521 return 0; 522 } 523 524 rv = PyString_FromStringAndSize(NULL, nlen); 525 if ( rv == 0 ) 526 return 0; 527 ncp = (unsigned char *)PyString_AsString(rv); 528 529 pos = 0; 530 for ( i=0; i < nlen; i++ ) { 531 if ( pos == 0 ) { 532 value = *cp++; 533 pos = 8; 534 } 535 pos -= 2; 536 nvalue = (value >> pos) & 0x03; 537 *ncp++ = nvalue | (nvalue << 2) | 538 (nvalue << 4) | (nvalue << 6); 539 } 540 return rv; 541 } 542 543 static PyObject * 544 imageop_grey42grey(PyObject *self, PyObject *args) 545 { 546 int x, y, len, nlen; 547 unsigned char *cp, *ncp; 548 PyObject *rv; 549 int i, pos, value = 0, nvalue; 550 551 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 552 return 0; 553 554 nlen = x*y; 555 if ( !check_multiply(nlen, x, y) ) 556 return 0; 557 if ( (nlen+1)/2 != len ) { 558 PyErr_SetString(ImageopError, "String has incorrect length"); 559 return 0; 560 } 561 562 rv = PyString_FromStringAndSize(NULL, nlen); 563 if ( rv == 0 ) 564 return 0; 565 ncp = (unsigned char *)PyString_AsString(rv); 566 567 pos = 0; 568 for ( i=0; i < nlen; i++ ) { 569 if ( pos == 0 ) { 570 value = *cp++; 571 pos = 8; 572 } 573 pos -= 4; 574 nvalue = (value >> pos) & 0x0f; 575 *ncp++ = nvalue | (nvalue << 4); 576 } 577 return rv; 578 } 579 580 static PyObject * 581 imageop_rgb2rgb8(PyObject *self, PyObject *args) 582 { 583 int x, y, len, nlen; 584 unsigned char *cp; 585 unsigned char *ncp; 586 PyObject *rv; 587 int i, r, g, b; 588 int backward_compatible = imageop_backward_compatible(); 589 590 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 591 return 0; 592 593 if ( !check_multiply_size(len, x, "x", y, "y", 4) ) 594 return 0; 595 nlen = x*y; 596 if ( !check_multiply(nlen, x, y) ) 597 return 0; 598 599 rv = PyString_FromStringAndSize(NULL, nlen); 600 if ( rv == 0 ) 601 return 0; 602 ncp = (unsigned char *)PyString_AsString(rv); 603 604 for ( i=0; i < nlen; i++ ) { 605 /* Bits in source: aaaaaaaa BBbbbbbb GGGggggg RRRrrrrr */ 606 if (backward_compatible) { 607 Py_UInt32 value = * (Py_UInt32 *) cp; 608 cp += 4; 609 r = (int) ((value & 0xff) / 255. * 7. + .5); 610 g = (int) (((value >> 8) & 0xff) / 255. * 7. + .5); 611 b = (int) (((value >> 16) & 0xff) / 255. * 3. + .5); 612 } else { 613 cp++; /* skip alpha channel */ 614 b = (int) (*cp++ / 255. * 3. + .5); 615 g = (int) (*cp++ / 255. * 7. + .5); 616 r = (int) (*cp++ / 255. * 7. + .5); 617 } 618 *ncp++ = (unsigned char)((r<<5) | (b<<3) | g); 619 } 620 return rv; 621 } 622 623 static PyObject * 624 imageop_rgb82rgb(PyObject *self, PyObject *args) 625 { 626 int x, y, len, nlen; 627 unsigned char *cp; 628 unsigned char *ncp; 629 PyObject *rv; 630 int i, r, g, b; 631 unsigned char value; 632 int backward_compatible = imageop_backward_compatible(); 633 634 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 635 return 0; 636 637 if ( !check_multiply(len, x, y) ) 638 return 0; 639 nlen = x*y*4; 640 if ( !check_multiply_size(nlen, x, "x", y, "y", 4) ) 641 return 0; 642 643 rv = PyString_FromStringAndSize(NULL, nlen); 644 if ( rv == 0 ) 645 return 0; 646 ncp = (unsigned char *)PyString_AsString(rv); 647 648 for ( i=0; i < len; i++ ) { 649 /* Bits in source: RRRBBGGG 650 ** Red and Green are multiplied by 36.5, Blue by 85 651 */ 652 value = *cp++; 653 r = (value >> 5) & 7; 654 g = (value ) & 7; 655 b = (value >> 3) & 3; 656 r = (r<<5) | (r<<3) | (r>>1); 657 g = (g<<5) | (g<<3) | (g>>1); 658 b = (b<<6) | (b<<4) | (b<<2) | b; 659 if (backward_compatible) { 660 Py_UInt32 nvalue = r | (g<<8) | (b<<16); 661 * (Py_UInt32 *) ncp = nvalue; 662 ncp += 4; 663 } else { 664 *ncp++ = 0; 665 *ncp++ = b; 666 *ncp++ = g; 667 *ncp++ = r; 668 } 669 } 670 return rv; 671 } 672 673 static PyObject * 674 imageop_rgb2grey(PyObject *self, PyObject *args) 675 { 676 int x, y, len, nlen; 677 unsigned char *cp; 678 unsigned char *ncp; 679 PyObject *rv; 680 int i, r, g, b; 681 int nvalue; 682 int backward_compatible = imageop_backward_compatible(); 683 684 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 685 return 0; 686 687 if ( !check_multiply_size(len, x, "x", y, "y", 4) ) 688 return 0; 689 nlen = x*y; 690 if ( !check_multiply(nlen, x, y) ) 691 return 0; 692 693 rv = PyString_FromStringAndSize(NULL, nlen); 694 if ( rv == 0 ) 695 return 0; 696 ncp = (unsigned char *)PyString_AsString(rv); 697 698 for ( i=0; i < nlen; i++ ) { 699 if (backward_compatible) { 700 Py_UInt32 value = * (Py_UInt32 *) cp; 701 cp += 4; 702 r = (int) ((value & 0xff) / 255. * 7. + .5); 703 g = (int) (((value >> 8) & 0xff) / 255. * 7. + .5); 704 b = (int) (((value >> 16) & 0xff) / 255. * 3. + .5); 705 } else { 706 cp++; /* skip alpha channel */ 707 b = *cp++; 708 g = *cp++; 709 r = *cp++; 710 } 711 nvalue = (int)(0.30*r + 0.59*g + 0.11*b); 712 if ( nvalue > 255 ) nvalue = 255; 713 *ncp++ = (unsigned char)nvalue; 714 } 715 return rv; 716 } 717 718 static PyObject * 719 imageop_grey2rgb(PyObject *self, PyObject *args) 720 { 721 int x, y, len, nlen; 722 unsigned char *cp; 723 unsigned char *ncp; 724 PyObject *rv; 725 int i; 726 unsigned char value; 727 int backward_compatible = imageop_backward_compatible(); 728 729 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) 730 return 0; 731 732 if ( !check_multiply(len, x, y) ) 733 return 0; 734 nlen = x*y*4; 735 if ( !check_multiply_size(nlen, x, "x", y, "y", 4) ) 736 return 0; 737 738 rv = PyString_FromStringAndSize(NULL, nlen); 739 if ( rv == 0 ) 740 return 0; 741 ncp = (unsigned char *)PyString_AsString(rv); 742 743 for ( i=0; i < len; i++ ) { 744 value = *cp++; 745 if (backward_compatible) { 746 * (Py_UInt32 *) ncp = (Py_UInt32) value | ((Py_UInt32) value << 8 ) | ((Py_UInt32) value << 16); 747 ncp += 4; 748 } else { 749 *ncp++ = 0; 750 *ncp++ = value; 751 *ncp++ = value; 752 *ncp++ = value; 753 } 754 } 755 return rv; 756 } 757 758 static PyMethodDef imageop_methods[] = { 759 { "crop", imageop_crop, METH_VARARGS }, 760 { "scale", imageop_scale, METH_VARARGS }, 761 { "grey2mono", imageop_grey2mono, METH_VARARGS }, 762 { "grey2grey2", imageop_grey2grey2, METH_VARARGS }, 763 { "grey2grey4", imageop_grey2grey4, METH_VARARGS }, 764 { "dither2mono", imageop_dither2mono, METH_VARARGS }, 765 { "dither2grey2", imageop_dither2grey2, METH_VARARGS }, 766 { "mono2grey", imageop_mono2grey, METH_VARARGS }, 767 { "grey22grey", imageop_grey22grey, METH_VARARGS }, 768 { "grey42grey", imageop_grey42grey, METH_VARARGS }, 769 { "tovideo", imageop_tovideo, METH_VARARGS }, 770 { "rgb2rgb8", imageop_rgb2rgb8, METH_VARARGS }, 771 { "rgb82rgb", imageop_rgb82rgb, METH_VARARGS }, 772 { "rgb2grey", imageop_rgb2grey, METH_VARARGS }, 773 { "grey2rgb", imageop_grey2rgb, METH_VARARGS }, 774 { 0, 0 } 775 }; 776 777 778 PyMODINIT_FUNC 779 initimageop(void) 780 { 781 PyObject *m; 782 783 if (PyErr_WarnPy3k("the imageop module has been removed in " 784 "Python 3.0", 2) < 0) 785 return; 786 787 m = Py_InitModule("imageop", imageop_methods); 788 if (m == NULL) 789 return; 790 ImageopDict = PyModule_GetDict(m); 791 ImageopError = PyErr_NewException("imageop.error", NULL, NULL); 792 if (ImageopError != NULL) 793 PyDict_SetItemString(ImageopDict, "error", ImageopError); 794 } 795
