Modules/imageop.c

   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 }