| /* imageopmodule - Various operations on pictures */ | |
| #ifdef sun | |
| #define signed | |
| #endif | |
| #include "Python.h" | |
| #if SIZEOF_INT == 4 | |
| typedef int Py_Int32; | |
| typedef unsigned int Py_UInt32; | |
| #else | |
| #if SIZEOF_LONG == 4 | |
| typedef long Py_Int32; | |
| typedef unsigned long Py_UInt32; | |
| #else | |
| #error "No 4-byte integral type" | |
| #endif | |
| #endif | |
| #define CHARP(cp, xmax, x, y) ((char *)(cp+y*xmax+x)) | |
| #define SHORTP(cp, xmax, x, y) ((short *)(cp+2*(y*xmax+x))) | |
| #define LONGP(cp, xmax, x, y) ((Py_Int32 *)(cp+4*(y*xmax+x))) | |
| static PyObject *ImageopError; | |
| static PyObject *ImageopDict; | |
| /** | |
| * Check a coordonnate, make sure that (0 < value). | |
| * Return 0 on error. | |
| */ | |
| static int | |
| check_coordonnate(int value, const char* name) | |
| { | |
| if ( 0 < value) | |
| return 1; | |
| PyErr_Format(PyExc_ValueError, "%s value is negative or nul", name); | |
| return 0; | |
| } | |
| /** | |
| * Check integer overflow to make sure that product == x*y*size. | |
| * Return 0 on error. | |
| */ | |
| static int | |
| check_multiply_size(int product, int x, const char* xname, int y, const char* yname, int size) | |
| { | |
| if ( !check_coordonnate(x, xname) ) | |
| return 0; | |
| if ( !check_coordonnate(y, yname) ) | |
| return 0; | |
| if ( size == (product / y) / x ) | |
| return 1; | |
| PyErr_SetString(ImageopError, "String has incorrect length"); | |
| return 0; | |
| } | |
| /** | |
| * Check integer overflow to make sure that product == x*y. | |
| * Return 0 on error. | |
| */ | |
| static int | |
| check_multiply(int product, int x, int y) | |
| { | |
| return check_multiply_size(product, x, "x", y, "y", 1); | |
| } | |
| /* If this function returns true (the default if anything goes wrong), we're | |
| behaving in a backward-compatible way with respect to how multi-byte pixels | |
| are stored in the strings. The code in this module was originally written | |
| for an SGI which is a big-endian system, and so the old code assumed that | |
| 4-byte integers hold the R, G, and B values in a particular order. | |
| However, on little-endian systems the order is reversed, and so not | |
| actually compatible with what gl.lrectwrite and imgfile expect. | |
| (gl.lrectwrite and imgfile are also SGI-specific, however, it is | |
| conceivable that the data handled here comes from or goes to an SGI or that | |
| it is otherwise used in the expectation that the byte order in the strings | |
| is as specified.) | |
| The function returns the value of the module variable | |
| "backward_compatible", or 1 if the variable does not exist or is not an | |
| int. | |
| */ | |
| static int | |
| imageop_backward_compatible(void) | |
| { | |
| static PyObject *bcos; | |
| PyObject *bco; | |
| long rc; | |
| if (ImageopDict == NULL) /* "cannot happen" */ | |
| return 1; | |
| if (bcos == NULL) { | |
| /* cache string object for future use */ | |
| bcos = PyString_FromString("backward_compatible"); | |
| if (bcos == NULL) | |
| return 1; | |
| } | |
| bco = PyDict_GetItem(ImageopDict, bcos); | |
| if (bco == NULL) | |
| return 1; | |
| if (!PyInt_Check(bco)) | |
| return 1; | |
| rc = PyInt_AsLong(bco); | |
| if (PyErr_Occurred()) { | |
| /* not an integer, or too large, or something */ | |
| PyErr_Clear(); | |
| rc = 1; | |
| } | |
| return rc != 0; /* convert to values 0, 1 */ | |
| } | |
| static PyObject * | |
| imageop_crop(PyObject *self, PyObject *args) | |
| { | |
| char *cp, *ncp; | |
| short *nsp; | |
| Py_Int32 *nlp; | |
| int len, size, x, y, newx1, newx2, newy1, newy2, nlen; | |
| int ix, iy, xstep, ystep; | |
| PyObject *rv; | |
| if ( !PyArg_ParseTuple(args, "s#iiiiiii", &cp, &len, &size, &x, &y, | |
| &newx1, &newy1, &newx2, &newy2) ) | |
| return 0; | |
| if ( size != 1 && size != 2 && size != 4 ) { | |
| PyErr_SetString(ImageopError, "Size should be 1, 2 or 4"); | |
| return 0; | |
| } | |
| if ( !check_multiply_size(len, x, "x", y, "y", size) ) | |
| return 0; | |
| xstep = (newx1 < newx2)? 1 : -1; | |
| ystep = (newy1 < newy2)? 1 : -1; | |
| nlen = (abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size; | |
| if ( !check_multiply_size(nlen, abs(newx2-newx1)+1, "abs(newx2-newx1)+1", abs(newy2-newy1)+1, "abs(newy2-newy1)+1", size) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (char *)PyString_AsString(rv); | |
| nsp = (short *)ncp; | |
| nlp = (Py_Int32 *)ncp; | |
| newy2 += ystep; | |
| newx2 += xstep; | |
| for( iy = newy1; iy != newy2; iy+=ystep ) { | |
| for ( ix = newx1; ix != newx2; ix+=xstep ) { | |
| if ( iy < 0 || iy >= y || ix < 0 || ix >= x ) { | |
| if ( size == 1 ) | |
| *ncp++ = 0; | |
| else | |
| *nlp++ = 0; | |
| } else { | |
| if ( size == 1 ) | |
| *ncp++ = *CHARP(cp, x, ix, iy); | |
| else if ( size == 2 ) | |
| *nsp++ = *SHORTP(cp, x, ix, iy); | |
| else | |
| *nlp++ = *LONGP(cp, x, ix, iy); | |
| } | |
| } | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_scale(PyObject *self, PyObject *args) | |
| { | |
| char *cp, *ncp; | |
| short *nsp; | |
| Py_Int32 *nlp; | |
| int len, size, x, y, newx, newy, nlen; | |
| int ix, iy; | |
| int oix, oiy; | |
| PyObject *rv; | |
| if ( !PyArg_ParseTuple(args, "s#iiiii", | |
| &cp, &len, &size, &x, &y, &newx, &newy) ) | |
| return 0; | |
| if ( size != 1 && size != 2 && size != 4 ) { | |
| PyErr_SetString(ImageopError, "Size should be 1, 2 or 4"); | |
| return 0; | |
| } | |
| if ( !check_multiply_size(len, x, "x", y, "y", size) ) | |
| return 0; | |
| nlen = newx*newy*size; | |
| if ( !check_multiply_size(nlen, newx, "newx", newy, "newy", size) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (char *)PyString_AsString(rv); | |
| nsp = (short *)ncp; | |
| nlp = (Py_Int32 *)ncp; | |
| for( iy = 0; iy < newy; iy++ ) { | |
| for ( ix = 0; ix < newx; ix++ ) { | |
| oix = ix * x / newx; | |
| oiy = iy * y / newy; | |
| if ( size == 1 ) | |
| *ncp++ = *CHARP(cp, x, oix, oiy); | |
| else if ( size == 2 ) | |
| *nsp++ = *SHORTP(cp, x, oix, oiy); | |
| else | |
| *nlp++ = *LONGP(cp, x, oix, oiy); | |
| } | |
| } | |
| return rv; | |
| } | |
| /* Note: this routine can use a bit of optimizing */ | |
| static PyObject * | |
| imageop_tovideo(PyObject *self, PyObject *args) | |
| { | |
| int maxx, maxy, x, y, len; | |
| int i; | |
| unsigned char *cp, *ncp; | |
| int width; | |
| PyObject *rv; | |
| if ( !PyArg_ParseTuple(args, "s#iii", &cp, &len, &width, &maxx, &maxy) ) | |
| return 0; | |
| if ( width != 1 && width != 4 ) { | |
| PyErr_SetString(ImageopError, "Size should be 1 or 4"); | |
| return 0; | |
| } | |
| if ( !check_multiply_size(len, maxx, "max", maxy, "maxy", width) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, len); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| if ( width == 1 ) { | |
| memcpy(ncp, cp, maxx); /* Copy first line */ | |
| ncp += maxx; | |
| for (y=1; y<maxy; y++) { /* Interpolate other lines */ | |
| for(x=0; x<maxx; x++) { | |
| i = y*maxx + x; | |
| *ncp++ = ((int)cp[i] + (int)cp[i-maxx]) >> 1; | |
| } | |
| } | |
| } else { | |
| memcpy(ncp, cp, maxx*4); /* Copy first line */ | |
| ncp += maxx*4; | |
| for (y=1; y<maxy; y++) { /* Interpolate other lines */ | |
| for(x=0; x<maxx; x++) { | |
| i = (y*maxx + x)*4 + 1; | |
| *ncp++ = 0; /* Skip alfa comp */ | |
| *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1; | |
| i++; | |
| *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1; | |
| i++; | |
| *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1; | |
| } | |
| } | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_grey2mono(PyObject *self, PyObject *args) | |
| { | |
| int tres, x, y, len; | |
| unsigned char *cp, *ncp; | |
| unsigned char ovalue; | |
| PyObject *rv; | |
| int i, bit; | |
| if ( !PyArg_ParseTuple(args, "s#iii", &cp, &len, &x, &y, &tres) ) | |
| return 0; | |
| if ( !check_multiply(len, x, y) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, (len+7)/8); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| bit = 0x80; | |
| ovalue = 0; | |
| for ( i=0; i < len; i++ ) { | |
| if ( (int)cp[i] > tres ) | |
| ovalue |= bit; | |
| bit >>= 1; | |
| if ( bit == 0 ) { | |
| *ncp++ = ovalue; | |
| bit = 0x80; | |
| ovalue = 0; | |
| } | |
| } | |
| if ( bit != 0x80 ) | |
| *ncp++ = ovalue; | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_grey2grey4(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len; | |
| unsigned char *cp, *ncp; | |
| unsigned char ovalue; | |
| PyObject *rv; | |
| int i; | |
| int pos; | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply(len, x, y) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, (len+1)/2); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| pos = 0; | |
| ovalue = 0; | |
| for ( i=0; i < len; i++ ) { | |
| ovalue |= ((int)cp[i] & 0xf0) >> pos; | |
| pos += 4; | |
| if ( pos == 8 ) { | |
| *ncp++ = ovalue; | |
| ovalue = 0; | |
| pos = 0; | |
| } | |
| } | |
| if ( pos != 0 ) | |
| *ncp++ = ovalue; | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_grey2grey2(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len; | |
| unsigned char *cp, *ncp; | |
| unsigned char ovalue; | |
| PyObject *rv; | |
| int i; | |
| int pos; | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply(len, x, y) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, (len+3)/4); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| pos = 0; | |
| ovalue = 0; | |
| for ( i=0; i < len; i++ ) { | |
| ovalue |= ((int)cp[i] & 0xc0) >> pos; | |
| pos += 2; | |
| if ( pos == 8 ) { | |
| *ncp++ = ovalue; | |
| ovalue = 0; | |
| pos = 0; | |
| } | |
| } | |
| if ( pos != 0 ) | |
| *ncp++ = ovalue; | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_dither2mono(PyObject *self, PyObject *args) | |
| { | |
| int sum, x, y, len; | |
| unsigned char *cp, *ncp; | |
| unsigned char ovalue; | |
| PyObject *rv; | |
| int i, bit; | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply(len, x, y) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, (len+7)/8); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| bit = 0x80; | |
| ovalue = 0; | |
| sum = 0; | |
| for ( i=0; i < len; i++ ) { | |
| sum += cp[i]; | |
| if ( sum >= 256 ) { | |
| sum -= 256; | |
| ovalue |= bit; | |
| } | |
| bit >>= 1; | |
| if ( bit == 0 ) { | |
| *ncp++ = ovalue; | |
| bit = 0x80; | |
| ovalue = 0; | |
| } | |
| } | |
| if ( bit != 0x80 ) | |
| *ncp++ = ovalue; | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_dither2grey2(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len; | |
| unsigned char *cp, *ncp; | |
| unsigned char ovalue; | |
| PyObject *rv; | |
| int i; | |
| int pos; | |
| int sum = 0, nvalue; | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply(len, x, y) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, (len+3)/4); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| pos = 1; | |
| ovalue = 0; | |
| for ( i=0; i < len; i++ ) { | |
| sum += cp[i]; | |
| nvalue = sum & 0x180; | |
| sum -= nvalue; | |
| ovalue |= nvalue >> pos; | |
| pos += 2; | |
| if ( pos == 9 ) { | |
| *ncp++ = ovalue; | |
| ovalue = 0; | |
| pos = 1; | |
| } | |
| } | |
| if ( pos != 0 ) | |
| *ncp++ = ovalue; | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_mono2grey(PyObject *self, PyObject *args) | |
| { | |
| int v0, v1, x, y, len, nlen; | |
| unsigned char *cp, *ncp; | |
| PyObject *rv; | |
| int i, bit; | |
| if ( !PyArg_ParseTuple(args, "s#iiii", &cp, &len, &x, &y, &v0, &v1) ) | |
| return 0; | |
| nlen = x*y; | |
| if ( !check_multiply(nlen, x, y) ) | |
| return 0; | |
| if ( (nlen+7)/8 != len ) { | |
| PyErr_SetString(ImageopError, "String has incorrect length"); | |
| return 0; | |
| } | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| bit = 0x80; | |
| for ( i=0; i < nlen; i++ ) { | |
| if ( *cp & bit ) | |
| *ncp++ = v1; | |
| else | |
| *ncp++ = v0; | |
| bit >>= 1; | |
| if ( bit == 0 ) { | |
| bit = 0x80; | |
| cp++; | |
| } | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_grey22grey(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len, nlen; | |
| unsigned char *cp, *ncp; | |
| PyObject *rv; | |
| int i, pos, value = 0, nvalue; | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| nlen = x*y; | |
| if ( !check_multiply(nlen, x, y) ) { | |
| return 0; | |
| } | |
| if ( (nlen+3)/4 != len ) { | |
| PyErr_SetString(ImageopError, "String has incorrect length"); | |
| return 0; | |
| } | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| pos = 0; | |
| for ( i=0; i < nlen; i++ ) { | |
| if ( pos == 0 ) { | |
| value = *cp++; | |
| pos = 8; | |
| } | |
| pos -= 2; | |
| nvalue = (value >> pos) & 0x03; | |
| *ncp++ = nvalue | (nvalue << 2) | | |
| (nvalue << 4) | (nvalue << 6); | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_grey42grey(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len, nlen; | |
| unsigned char *cp, *ncp; | |
| PyObject *rv; | |
| int i, pos, value = 0, nvalue; | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| nlen = x*y; | |
| if ( !check_multiply(nlen, x, y) ) | |
| return 0; | |
| if ( (nlen+1)/2 != len ) { | |
| PyErr_SetString(ImageopError, "String has incorrect length"); | |
| return 0; | |
| } | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| pos = 0; | |
| for ( i=0; i < nlen; i++ ) { | |
| if ( pos == 0 ) { | |
| value = *cp++; | |
| pos = 8; | |
| } | |
| pos -= 4; | |
| nvalue = (value >> pos) & 0x0f; | |
| *ncp++ = nvalue | (nvalue << 4); | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_rgb2rgb8(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len, nlen; | |
| unsigned char *cp; | |
| unsigned char *ncp; | |
| PyObject *rv; | |
| int i, r, g, b; | |
| int backward_compatible = imageop_backward_compatible(); | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply_size(len, x, "x", y, "y", 4) ) | |
| return 0; | |
| nlen = x*y; | |
| if ( !check_multiply(nlen, x, y) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| for ( i=0; i < nlen; i++ ) { | |
| /* Bits in source: aaaaaaaa BBbbbbbb GGGggggg RRRrrrrr */ | |
| if (backward_compatible) { | |
| Py_UInt32 value = * (Py_UInt32 *) cp; | |
| cp += 4; | |
| r = (int) ((value & 0xff) / 255. * 7. + .5); | |
| g = (int) (((value >> 8) & 0xff) / 255. * 7. + .5); | |
| b = (int) (((value >> 16) & 0xff) / 255. * 3. + .5); | |
| } else { | |
| cp++; /* skip alpha channel */ | |
| b = (int) (*cp++ / 255. * 3. + .5); | |
| g = (int) (*cp++ / 255. * 7. + .5); | |
| r = (int) (*cp++ / 255. * 7. + .5); | |
| } | |
| *ncp++ = (unsigned char)((r<<5) | (b<<3) | g); | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_rgb82rgb(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len, nlen; | |
| unsigned char *cp; | |
| unsigned char *ncp; | |
| PyObject *rv; | |
| int i, r, g, b; | |
| unsigned char value; | |
| int backward_compatible = imageop_backward_compatible(); | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply(len, x, y) ) | |
| return 0; | |
| nlen = x*y*4; | |
| if ( !check_multiply_size(nlen, x, "x", y, "y", 4) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| for ( i=0; i < len; i++ ) { | |
| /* Bits in source: RRRBBGGG | |
| ** Red and Green are multiplied by 36.5, Blue by 85 | |
| */ | |
| value = *cp++; | |
| r = (value >> 5) & 7; | |
| g = (value ) & 7; | |
| b = (value >> 3) & 3; | |
| r = (r<<5) | (r<<3) | (r>>1); | |
| g = (g<<5) | (g<<3) | (g>>1); | |
| b = (b<<6) | (b<<4) | (b<<2) | b; | |
| if (backward_compatible) { | |
| Py_UInt32 nvalue = r | (g<<8) | (b<<16); | |
| * (Py_UInt32 *) ncp = nvalue; | |
| ncp += 4; | |
| } else { | |
| *ncp++ = 0; | |
| *ncp++ = b; | |
| *ncp++ = g; | |
| *ncp++ = r; | |
| } | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_rgb2grey(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len, nlen; | |
| unsigned char *cp; | |
| unsigned char *ncp; | |
| PyObject *rv; | |
| int i, r, g, b; | |
| int nvalue; | |
| int backward_compatible = imageop_backward_compatible(); | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply_size(len, x, "x", y, "y", 4) ) | |
| return 0; | |
| nlen = x*y; | |
| if ( !check_multiply(nlen, x, y) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| for ( i=0; i < nlen; i++ ) { | |
| if (backward_compatible) { | |
| Py_UInt32 value = * (Py_UInt32 *) cp; | |
| cp += 4; | |
| r = (int) ((value & 0xff) / 255. * 7. + .5); | |
| g = (int) (((value >> 8) & 0xff) / 255. * 7. + .5); | |
| b = (int) (((value >> 16) & 0xff) / 255. * 3. + .5); | |
| } else { | |
| cp++; /* skip alpha channel */ | |
| b = *cp++; | |
| g = *cp++; | |
| r = *cp++; | |
| } | |
| nvalue = (int)(0.30*r + 0.59*g + 0.11*b); | |
| if ( nvalue > 255 ) nvalue = 255; | |
| *ncp++ = (unsigned char)nvalue; | |
| } | |
| return rv; | |
| } | |
| static PyObject * | |
| imageop_grey2rgb(PyObject *self, PyObject *args) | |
| { | |
| int x, y, len, nlen; | |
| unsigned char *cp; | |
| unsigned char *ncp; | |
| PyObject *rv; | |
| int i; | |
| unsigned char value; | |
| int backward_compatible = imageop_backward_compatible(); | |
| if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) ) | |
| return 0; | |
| if ( !check_multiply(len, x, y) ) | |
| return 0; | |
| nlen = x*y*4; | |
| if ( !check_multiply_size(nlen, x, "x", y, "y", 4) ) | |
| return 0; | |
| rv = PyString_FromStringAndSize(NULL, nlen); | |
| if ( rv == 0 ) | |
| return 0; | |
| ncp = (unsigned char *)PyString_AsString(rv); | |
| for ( i=0; i < len; i++ ) { | |
| value = *cp++; | |
| if (backward_compatible) { | |
| * (Py_UInt32 *) ncp = (Py_UInt32) value | ((Py_UInt32) value << 8 ) | ((Py_UInt32) value << 16); | |
| ncp += 4; | |
| } else { | |
| *ncp++ = 0; | |
| *ncp++ = value; | |
| *ncp++ = value; | |
| *ncp++ = value; | |
| } | |
| } | |
| return rv; | |
| } | |
| static PyMethodDef imageop_methods[] = { | |
| { "crop", imageop_crop, METH_VARARGS }, | |
| { "scale", imageop_scale, METH_VARARGS }, | |
| { "grey2mono", imageop_grey2mono, METH_VARARGS }, | |
| { "grey2grey2", imageop_grey2grey2, METH_VARARGS }, | |
| { "grey2grey4", imageop_grey2grey4, METH_VARARGS }, | |
| { "dither2mono", imageop_dither2mono, METH_VARARGS }, | |
| { "dither2grey2", imageop_dither2grey2, METH_VARARGS }, | |
| { "mono2grey", imageop_mono2grey, METH_VARARGS }, | |
| { "grey22grey", imageop_grey22grey, METH_VARARGS }, | |
| { "grey42grey", imageop_grey42grey, METH_VARARGS }, | |
| { "tovideo", imageop_tovideo, METH_VARARGS }, | |
| { "rgb2rgb8", imageop_rgb2rgb8, METH_VARARGS }, | |
| { "rgb82rgb", imageop_rgb82rgb, METH_VARARGS }, | |
| { "rgb2grey", imageop_rgb2grey, METH_VARARGS }, | |
| { "grey2rgb", imageop_grey2rgb, METH_VARARGS }, | |
| { 0, 0 } | |
| }; | |
| PyMODINIT_FUNC | |
| initimageop(void) | |
| { | |
| PyObject *m; | |
| if (PyErr_WarnPy3k("the imageop module has been removed in " | |
| "Python 3.0", 2) < 0) | |
| return; | |
| m = Py_InitModule("imageop", imageop_methods); | |
| if (m == NULL) | |
| return; | |
| ImageopDict = PyModule_GetDict(m); | |
| ImageopError = PyErr_NewException("imageop.error", NULL, NULL); | |
| if (ImageopError != NULL) | |
| PyDict_SetItemString(ImageopDict, "error", ImageopError); | |
| } |