python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-11-04 09:57:43 +03:00
Code Issues Packages Projects Releases Wiki Activity

Use enums for Modes and RawModes in C (#9256)

Browse Source
This commit is contained in:
mergify[bot] 2025-10-15 10:58:36 +00:00 committed by GitHub
commit 5dddb2ce94
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
48 changed files with 1713 additions and 1120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
setup.py
View File

@ -21,6 +21,10 @@ from pybind11.setup_helpers import ParallelCompile
from setuptools import Extension, setup from setuptools import Extension, setup
from setuptools.command.build_ext import build_ext from setuptools.command.build_ext import build_ext
TYPE_CHECKING = False
if TYPE_CHECKING:
from setuptools import _BuildInfo
configuration: dict[str, list[str]] = {} configuration: dict[str, list[str]] = {}
# parse configuration from _custom_build/backend.py # parse configuration from _custom_build/backend.py
@ -1072,16 +1076,20 @@ def debug_build() -> bool:
return hasattr(sys, "gettotalrefcount") or FUZZING_BUILD return hasattr(sys, "gettotalrefcount") or FUZZING_BUILD
libraries: list[tuple[str, _BuildInfo]] = [
("pil_imaging_mode", {"sources": ["src/libImaging/Mode.c"]}),
]
files: list[str | os.PathLike[str]] = ["src/_imaging.c"] files: list[str | os.PathLike[str]] = ["src/_imaging.c"]
for src_file in _IMAGING: for src_file in _IMAGING:
files.append("src/" + src_file + ".c") files.append("src/" + src_file + ".c")
for src_file in _LIB_IMAGING: for src_file in _LIB_IMAGING:
files.append(os.path.join("src/libImaging", src_file + ".c")) files.append(os.path.join("src/libImaging", src_file + ".c"))
ext_modules = [ ext_modules = [
Extension("PIL._imaging", files), Extension("PIL._imaging", files, libraries=["pil_imaging_mode"]),
Extension("PIL._imagingft", ["src/_imagingft.c"]), Extension("PIL._imagingft", ["src/_imagingft.c"], libraries=["pil_imaging_mode"]),
Extension("PIL._imagingcms", ["src/_imagingcms.c"]), Extension("PIL._imagingcms", ["src/_imagingcms.c"], libraries=["pil_imaging_mode"]),
Extension("PIL._webp", ["src/_webp.c"]), Extension("PIL._webp", ["src/_webp.c"], libraries=["pil_imaging_mode"]),
Extension("PIL._avif", ["src/_avif.c"]), Extension("PIL._avif", ["src/_avif.c"]),
Extension("PIL._imagingtk", ["src/_imagingtk.c", "src/Tk/tkImaging.c"]), Extension("PIL._imagingtk", ["src/_imagingtk.c", "src/Tk/tkImaging.c"]),
Extension("PIL._imagingmath", ["src/_imagingmath.c"]), Extension("PIL._imagingmath", ["src/_imagingmath.c"]),
@ -1093,6 +1101,7 @@ try:
setup( setup(
cmdclass={"build_ext": pil_build_ext}, cmdclass={"build_ext": pil_build_ext},
ext_modules=ext_modules, ext_modules=ext_modules,
libraries=libraries,
zip_safe=not (debug_build() or PLATFORM_MINGW), zip_safe=not (debug_build() or PLATFORM_MINGW),
) )
except RequiredDependencyException as err: except RequiredDependencyException as err:

7
src/Tk/tkImaging.c
View File

@ -121,15 +121,16 @@ PyImagingPhotoPut(
/* Mode */ /* Mode */
if (strcmp(im->mode, "1") == 0 || strcmp(im->mode, "L") == 0) { if (im->mode == IMAGING_MODE_1 || im->mode == IMAGING_MODE_L) {
block.pixelSize = 1; block.pixelSize = 1;
block.offset[0] = block.offset[1] = block.offset[2] = block.offset[3] = 0; block.offset[0] = block.offset[1] = block.offset[2] = block.offset[3] = 0;
} else if (strncmp(im->mode, "RGB", 3) == 0) { } else if (im->mode == IMAGING_MODE_RGB || im->mode == IMAGING_MODE_RGBA ||
im->mode == IMAGING_MODE_RGBX || im->mode == IMAGING_MODE_RGBa) {
block.pixelSize = 4; block.pixelSize = 4;
block.offset[0] = 0; block.offset[0] = 0;
block.offset[1] = 1; block.offset[1] = 1;
block.offset[2] = 2; block.offset[2] = 2;
if (strcmp(im->mode, "RGBA") == 0) { if (im->mode == IMAGING_MODE_RGBA) {
block.offset[3] = 3; /* alpha (or reserved, under Tk 8.2) */ block.offset[3] = 3; /* alpha (or reserved, under Tk 8.2) */
} else { } else {
block.offset[3] = 0; /* no alpha */ block.offset[3] = 0; /* no alpha */

165
src/_imaging.c
View File

@ -297,6 +297,7 @@ ExportArrowArrayPyCapsule(ImagingObject *self) {
static PyObject * static PyObject *
_new_arrow(PyObject *self, PyObject *args) { _new_arrow(PyObject *self, PyObject *args) {
char *mode; char *mode;
ModeID mode_id;
int xsize, ysize; int xsize, ysize;
PyObject *schema_capsule, *array_capsule; PyObject *schema_capsule, *array_capsule;
PyObject *ret; PyObject *ret;
@ -307,9 +308,11 @@ _new_arrow(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
mode_id = findModeID(mode);
// ImagingBorrowArrow is responsible for retaining the array_capsule // ImagingBorrowArrow is responsible for retaining the array_capsule
ret = PyImagingNew( ret = PyImagingNew(
ImagingNewArrow(mode, xsize, ysize, schema_capsule, array_capsule) ImagingNewArrow(mode_id, xsize, ysize, schema_capsule, array_capsule)
); );
if (!ret) { if (!ret) {
return ImagingError_ValueError("Invalid Arrow array mode or size mismatch"); return ImagingError_ValueError("Invalid Arrow array mode or size mismatch");
@ -368,7 +371,7 @@ ImagingError_ValueError(const char *message) {
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
static int static int
getbands(const char *mode) { getbands(const ModeID mode) {
Imaging im; Imaging im;
int bands; int bands;
@ -662,7 +665,7 @@ getink(PyObject *color, Imaging im, char *ink) {
memcpy(ink, &ftmp, sizeof(ftmp)); memcpy(ink, &ftmp, sizeof(ftmp));
return ink; return ink;
case IMAGING_TYPE_SPECIAL: case IMAGING_TYPE_SPECIAL:
if (strncmp(im->mode, "I;16", 4) == 0) { if (isModeI16(im->mode)) {
ink[0] = (UINT8)r; ink[0] = (UINT8)r;
ink[1] = (UINT8)(r >> 8); ink[1] = (UINT8)(r >> 8);
ink[2] = ink[3] = 0; ink[2] = ink[3] = 0;
@ -694,7 +697,7 @@ getink(PyObject *color, Imaging im, char *ink) {
static PyObject * static PyObject *
_fill(PyObject *self, PyObject *args) { _fill(PyObject *self, PyObject *args) {
char *mode; char *mode_name;
int xsize, ysize; int xsize, ysize;
PyObject *color; PyObject *color;
char buffer[4]; char buffer[4];
@ -703,10 +706,12 @@ _fill(PyObject *self, PyObject *args) {
xsize = ysize = 256; xsize = ysize = 256;
color = NULL; color = NULL;
if (!PyArg_ParseTuple(args, "s|(ii)O", &mode, &xsize, &ysize, &color)) { if (!PyArg_ParseTuple(args, "s|(ii)O", &mode_name, &xsize, &ysize, &color)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
im = ImagingNewDirty(mode, xsize, ysize); im = ImagingNewDirty(mode, xsize, ysize);
if (!im) { if (!im) {
return NULL; return NULL;
@ -727,47 +732,55 @@ _fill(PyObject *self, PyObject *args) {
static PyObject * static PyObject *
_new(PyObject *self, PyObject *args) { _new(PyObject *self, PyObject *args) {
char *mode; char *mode_name;
int xsize, ysize; int xsize, ysize;
if (!PyArg_ParseTuple(args, "s(ii)", &mode, &xsize, &ysize)) { if (!PyArg_ParseTuple(args, "s(ii)", &mode_name, &xsize, &ysize)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingNew(mode, xsize, ysize)); return PyImagingNew(ImagingNew(mode, xsize, ysize));
} }
static PyObject * static PyObject *
_new_block(PyObject *self, PyObject *args) { _new_block(PyObject *self, PyObject *args) {
char *mode; char *mode_name;
int xsize, ysize; int xsize, ysize;
if (!PyArg_ParseTuple(args, "s(ii)", &mode, &xsize, &ysize)) { if (!PyArg_ParseTuple(args, "s(ii)", &mode_name, &xsize, &ysize)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingNewBlock(mode, xsize, ysize)); return PyImagingNew(ImagingNewBlock(mode, xsize, ysize));
} }
static PyObject * static PyObject *
_linear_gradient(PyObject *self, PyObject *args) { _linear_gradient(PyObject *self, PyObject *args) {
char *mode; char *mode_name;
if (!PyArg_ParseTuple(args, "s", &mode)) { if (!PyArg_ParseTuple(args, "s", &mode_name)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingFillLinearGradient(mode)); return PyImagingNew(ImagingFillLinearGradient(mode));
} }
static PyObject * static PyObject *
_radial_gradient(PyObject *self, PyObject *args) { _radial_gradient(PyObject *self, PyObject *args) {
char *mode; char *mode_name;
if (!PyArg_ParseTuple(args, "s", &mode)) { if (!PyArg_ParseTuple(args, "s", &mode_name)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingFillRadialGradient(mode)); return PyImagingNew(ImagingFillRadialGradient(mode));
} }
@ -907,7 +920,7 @@ _prepare_lut_table(PyObject *table, Py_ssize_t table_size) {
static PyObject * static PyObject *
_color_lut_3d(ImagingObject *self, PyObject *args) { _color_lut_3d(ImagingObject *self, PyObject *args) {
char *mode; char *mode_name;
int filter; int filter;
int table_channels; int table_channels;
int size1D, size2D, size3D; int size1D, size2D, size3D;
@ -919,7 +932,7 @@ _color_lut_3d(ImagingObject *self, PyObject *args) {
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, args,
"sii(iii)O:color_lut_3d", "sii(iii)O:color_lut_3d",
&mode, &mode_name,
&filter, &filter,
&table_channels, &table_channels,
&size1D, &size1D,
@ -930,6 +943,8 @@ _color_lut_3d(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
/* actually, it is trilinear */ /* actually, it is trilinear */
if (filter != IMAGING_TRANSFORM_BILINEAR) { if (filter != IMAGING_TRANSFORM_BILINEAR) {
PyErr_SetString(PyExc_ValueError, "Only LINEAR filter is supported."); PyErr_SetString(PyExc_ValueError, "Only LINEAR filter is supported.");
@ -976,11 +991,11 @@ _color_lut_3d(ImagingObject *self, PyObject *args) {
static PyObject * static PyObject *
_convert(ImagingObject *self, PyObject *args) { _convert(ImagingObject *self, PyObject *args) {
char *mode; char *mode_name;
int dither = 0; int dither = 0;
ImagingObject *paletteimage = NULL; ImagingObject *paletteimage = NULL;
if (!PyArg_ParseTuple(args, "s|iO", &mode, &dither, &paletteimage)) { if (!PyArg_ParseTuple(args, "s|iO", &mode_name, &dither, &paletteimage)) {
return NULL; return NULL;
} }
if (paletteimage != NULL) { if (paletteimage != NULL) {
@ -997,6 +1012,8 @@ _convert(ImagingObject *self, PyObject *args) {
} }
} }
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingConvert( return PyImagingNew(ImagingConvert(
self->image, mode, paletteimage ? paletteimage->image->palette : NULL, dither self->image, mode, paletteimage ? paletteimage->image->palette : NULL, dither
)); ));
@ -1021,14 +1038,14 @@ _convert2(ImagingObject *self, PyObject *args) {
static PyObject * static PyObject *
_convert_matrix(ImagingObject *self, PyObject *args) { _convert_matrix(ImagingObject *self, PyObject *args) {
char *mode; char *mode_name;
float m[12]; float m[12];
if (!PyArg_ParseTuple(args, "s(ffff)", &mode, m + 0, m + 1, m + 2, m + 3)) { if (!PyArg_ParseTuple(args, "s(ffff)", &mode_name, m + 0, m + 1, m + 2, m + 3)) {
PyErr_Clear(); PyErr_Clear();
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, args,
"s(ffffffffffff)", "s(ffffffffffff)",
&mode, &mode_name,
m + 0, m + 0,
m + 1, m + 1,
m + 2, m + 2,
@ -1046,18 +1063,22 @@ _convert_matrix(ImagingObject *self, PyObject *args) {
} }
} }
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingConvertMatrix(self->image, mode, m)); return PyImagingNew(ImagingConvertMatrix(self->image, mode, m));
} }
static PyObject * static PyObject *
_convert_transparent(ImagingObject *self, PyObject *args) { _convert_transparent(ImagingObject *self, PyObject *args) {
char *mode; char *mode_name;
int r, g, b; int r, g, b;
if (PyArg_ParseTuple(args, "s(iii)", &mode, &r, &g, &b)) { if (PyArg_ParseTuple(args, "s(iii)", &mode_name, &r, &g, &b)) {
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingConvertTransparent(self->image, mode, r, g, b)); return PyImagingNew(ImagingConvertTransparent(self->image, mode, r, g, b));
} }
PyErr_Clear(); PyErr_Clear();
if (PyArg_ParseTuple(args, "si", &mode, &r)) { if (PyArg_ParseTuple(args, "si", &mode_name, &r)) {
const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingConvertTransparent(self->image, mode, r, 0, 0)); return PyImagingNew(ImagingConvertTransparent(self->image, mode, r, 0, 0));
} }
return NULL; return NULL;
@ -1156,9 +1177,9 @@ _getpalette(ImagingObject *self, PyObject *args) {
int bits; int bits;
ImagingShuffler pack; ImagingShuffler pack;
char *mode = "RGB"; char *mode_name = "RGB";
char *rawmode = "RGB"; char *rawmode_name = "RGB";
if (!PyArg_ParseTuple(args, "|ss", &mode, &rawmode)) { if (!PyArg_ParseTuple(args, "|ss", &mode_name, &rawmode_name)) {
return NULL; return NULL;
} }
@ -1167,6 +1188,9 @@ _getpalette(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
pack = ImagingFindPacker(mode, rawmode, &bits); pack = ImagingFindPacker(mode, rawmode, &bits);
if (!pack) { if (!pack) {
PyErr_SetString(PyExc_ValueError, wrong_raw_mode); PyErr_SetString(PyExc_ValueError, wrong_raw_mode);
@ -1193,7 +1217,7 @@ _getpalettemode(ImagingObject *self) {
return NULL; return NULL;
} }
return PyUnicode_FromString(self->image->palette->mode); return PyUnicode_FromString(getModeData(self->image->palette->mode)->name);
} }
static inline int static inline int
@ -1474,12 +1498,14 @@ _point(ImagingObject *self, PyObject *args) {
Imaging im; Imaging im;
PyObject *list; PyObject *list;
char *mode; char *mode_name;
if (!PyArg_ParseTuple(args, "Oz", &list, &mode)) { if (!PyArg_ParseTuple(args, "Oz", &list, &mode_name)) {
return NULL; return NULL;
} }
if (mode && !strcmp(mode, "F")) { const ModeID mode = findModeID(mode_name);
if (mode == IMAGING_MODE_F) {
FLOAT32 *data; FLOAT32 *data;
/* map from 8-bit data to floating point */ /* map from 8-bit data to floating point */
@ -1490,8 +1516,7 @@ _point(ImagingObject *self, PyObject *args) {
} }
im = ImagingPoint(self->image, mode, (void *)data); im = ImagingPoint(self->image, mode, (void *)data);
free(data); free(data);
} else if (self->image->mode == IMAGING_MODE_I && mode == IMAGING_MODE_L) {
} else if (!strcmp(self->image->mode, "I") && mode && !strcmp(mode, "L")) {
UINT8 *data; UINT8 *data;
/* map from 16-bit subset of 32-bit data to 8-bit */ /* map from 16-bit subset of 32-bit data to 8-bit */
@ -1503,7 +1528,6 @@ _point(ImagingObject *self, PyObject *args) {
} }
im = ImagingPoint(self->image, mode, (void *)data); im = ImagingPoint(self->image, mode, (void *)data);
free(data); free(data);
} else { } else {
INT32 *data; INT32 *data;
UINT8 lut[1024]; UINT8 lut[1024];
@ -1524,7 +1548,7 @@ _point(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
if (mode && !strcmp(mode, "I")) { if (mode == IMAGING_MODE_I) {
im = ImagingPoint(self->image, mode, (void *)data); im = ImagingPoint(self->image, mode, (void *)data);
} else if (mode && bands > 1) { } else if (mode && bands > 1) {
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
@ -1630,9 +1654,9 @@ _putdata(ImagingObject *self, PyObject *args) {
if (image->type == IMAGING_TYPE_SPECIAL) { if (image->type == IMAGING_TYPE_SPECIAL) {
// I;16* // I;16*
if ( if (
strcmp(image->mode, "I;16B") == 0 image->mode == IMAGING_MODE_I_16B
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
|| strcmp(image->mode, "I;16N") == 0 || image->mode == IMAGING_MODE_I_16N
#endif #endif
) { ) {
bigendian = 1; bigendian = 1;
@ -1729,7 +1753,9 @@ _quantize(ImagingObject *self, PyObject *args) {
if (!self->image->xsize || !self->image->ysize) { if (!self->image->xsize || !self->image->ysize) {
/* no content; return an empty image */ /* no content; return an empty image */
return PyImagingNew(ImagingNew("P", self->image->xsize, self->image->ysize)); return PyImagingNew(
ImagingNew(IMAGING_MODE_P, self->image->xsize, self->image->ysize)
);
} }
return PyImagingNew(ImagingQuantize(self->image, colours, method, kmeans)); return PyImagingNew(ImagingQuantize(self->image, colours, method, kmeans));
@ -1740,21 +1766,33 @@ _putpalette(ImagingObject *self, PyObject *args) {
ImagingShuffler unpack; ImagingShuffler unpack;
int bits; int bits;
char *palette_mode, *rawmode; char *palette_mode_name, *rawmode_name;
UINT8 *palette; UINT8 *palette;
Py_ssize_t palettesize; Py_ssize_t palettesize;
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, "ssy#", &palette_mode, &rawmode, &palette, &palettesize args, "ssy#", &palette_mode_name, &rawmode_name, &palette, &palettesize
)) { )) {
return NULL; return NULL;
} }
if (strcmp(self->image->mode, "L") && strcmp(self->image->mode, "LA") && if (self->image->mode != IMAGING_MODE_L && self->image->mode != IMAGING_MODE_LA &&
strcmp(self->image->mode, "P") && strcmp(self->image->mode, "PA")) { self->image->mode != IMAGING_MODE_P && self->image->mode != IMAGING_MODE_PA) {
PyErr_SetString(PyExc_ValueError, wrong_mode); PyErr_SetString(PyExc_ValueError, wrong_mode);
return NULL; return NULL;
} }
const ModeID palette_mode = findModeID(palette_mode_name);
if (palette_mode == IMAGING_MODE_UNKNOWN) {
PyErr_SetString(PyExc_ValueError, wrong_mode);
return NULL;
}
const RawModeID rawmode = findRawModeID(rawmode_name);
if (rawmode == IMAGING_RAWMODE_UNKNOWN) {
PyErr_SetString(PyExc_ValueError, wrong_raw_mode);
return NULL;
}
unpack = ImagingFindUnpacker(palette_mode, rawmode, &bits); unpack = ImagingFindUnpacker(palette_mode, rawmode, &bits);
if (!unpack) { if (!unpack) {
PyErr_SetString(PyExc_ValueError, wrong_raw_mode); PyErr_SetString(PyExc_ValueError, wrong_raw_mode);
@ -1768,7 +1806,13 @@ _putpalette(ImagingObject *self, PyObject *args) {
ImagingPaletteDelete(self->image->palette); ImagingPaletteDelete(self->image->palette);
strcpy(self->image->mode, strlen(self->image->mode) == 2 ? "PA" : "P"); if (self->image->mode == IMAGING_MODE_LA) {
self->image->mode = IMAGING_MODE_PA;
} else if (self->image->mode == IMAGING_MODE_L) {
self->image->mode = IMAGING_MODE_P;
} else {
// The image already has a palette mode so we don't need to change it.
}
self->image->palette = ImagingPaletteNew(palette_mode); self->image->palette = ImagingPaletteNew(palette_mode);
@ -1796,7 +1840,7 @@ _putpalettealpha(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
strcpy(self->image->palette->mode, "RGBA"); self->image->palette->mode = IMAGING_MODE_RGBA;
self->image->palette->palette[index * 4 + 3] = (UINT8)alpha; self->image->palette->palette[index * 4 + 3] = (UINT8)alpha;
Py_RETURN_NONE; Py_RETURN_NONE;
@ -1821,7 +1865,7 @@ _putpalettealphas(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
strcpy(self->image->palette->mode, "RGBA"); self->image->palette->mode = IMAGING_MODE_RGBA;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
self->image->palette->palette[i * 4 + 3] = (UINT8)values[i]; self->image->palette->palette[i * 4 + 3] = (UINT8)values[i];
} }
@ -1989,8 +2033,11 @@ _reduce(ImagingObject *self, PyObject *args) {
return PyImagingNew(imOut); return PyImagingNew(imOut);
} }
#define IS_RGB(mode) \ static int
(!strcmp(mode, "RGB") || !strcmp(mode, "RGBA") || !strcmp(mode, "RGBX")) isRGB(const ModeID mode) {
return mode == IMAGING_MODE_RGB || mode == IMAGING_MODE_RGBA ||
mode == IMAGING_MODE_RGBX;
}
static PyObject * static PyObject *
im_setmode(ImagingObject *self, PyObject *args) { im_setmode(ImagingObject *self, PyObject *args) {
@ -1998,23 +2045,25 @@ im_setmode(ImagingObject *self, PyObject *args) {
Imaging im; Imaging im;
char *mode; char *mode_name;
Py_ssize_t modelen; Py_ssize_t modelen;
if (!PyArg_ParseTuple(args, "s#:setmode", &mode, &modelen)) { if (!PyArg_ParseTuple(args, "s#:setmode", &mode_name, &modelen)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
im = self->image; im = self->image;
/* move all logic in here to the libImaging primitive */ /* move all logic in here to the libImaging primitive */
if (!strcmp(im->mode, mode)) { if (im->mode == mode) {
; /* same mode; always succeeds */ ; /* same mode; always succeeds */
} else if (IS_RGB(im->mode) && IS_RGB(mode)) { } else if (isRGB(im->mode) && isRGB(mode)) {
/* color to color */ /* color to color */
strcpy(im->mode, mode); im->mode = mode;
im->bands = modelen; im->bands = modelen;
if (!strcmp(mode, "RGBA")) { if (mode == IMAGING_MODE_RGBA) {
(void)ImagingFillBand(im, 3, 255); (void)ImagingFillBand(im, 3, 255);
} }
} else { } else {
@ -2294,7 +2343,7 @@ _getextrema(ImagingObject *self) {
case IMAGING_TYPE_FLOAT32: case IMAGING_TYPE_FLOAT32:
return Py_BuildValue("dd", extrema.f[0], extrema.f[1]); return Py_BuildValue("dd", extrema.f[0], extrema.f[1]);
case IMAGING_TYPE_SPECIAL: case IMAGING_TYPE_SPECIAL:
if (strcmp(self->image->mode, "I;16") == 0) { if (self->image->mode == IMAGING_MODE_I_16) {
return Py_BuildValue("HH", extrema.s[0], extrema.s[1]); return Py_BuildValue("HH", extrema.s[0], extrema.s[1]);
} }
} }
@ -2383,7 +2432,7 @@ _putband(ImagingObject *self, PyObject *args) {
static PyObject * static PyObject *
_merge(PyObject *self, PyObject *args) { _merge(PyObject *self, PyObject *args) {
char *mode; char *mode_name;
ImagingObject *band0 = NULL; ImagingObject *band0 = NULL;
ImagingObject *band1 = NULL; ImagingObject *band1 = NULL;
ImagingObject *band2 = NULL; ImagingObject *band2 = NULL;
@ -2393,7 +2442,7 @@ _merge(PyObject *self, PyObject *args) {
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, args,
"sO!|O!O!O!", "sO!|O!O!O!",
&mode, &mode_name,
&Imaging_Type, &Imaging_Type,
&band0, &band0,
&Imaging_Type, &Imaging_Type,
@ -2406,6 +2455,8 @@ _merge(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
if (band0) { if (band0) {
bands[0] = band0->image; bands[0] = band0->image;
} }
@ -3716,7 +3767,7 @@ static struct PyMethodDef methods[] = {
static PyObject * static PyObject *
_getattr_mode(ImagingObject *self, void *closure) { _getattr_mode(ImagingObject *self, void *closure) {
return PyUnicode_FromString(self->image->mode); return PyUnicode_FromString(getModeData(self->image->mode)->name);
} }
static PyObject * static PyObject *
@ -4260,8 +4311,6 @@ setup_module(PyObject *m) {
return -1; return -1;
} }
ImagingAccessInit();
#ifdef HAVE_LIBJPEG #ifdef HAVE_LIBJPEG
{ {
extern const char *ImagingJpegVersion(void); extern const char *ImagingJpegVersion(void);

44
src/_imagingcms.c
View File

@ -212,32 +212,44 @@ cms_transform_dealloc(CmsTransformObject *self) {
/* internal functions */ /* internal functions */
static cmsUInt32Number static cmsUInt32Number
findLCMStype(char *PILmode) { findLCMStype(const char *const mode_name) {
if (strcmp(PILmode, "RGB") == 0 || strcmp(PILmode, "RGBA") == 0 || const ModeID mode = findModeID(mode_name);
strcmp(PILmode, "RGBX") == 0) { switch (mode) {
case IMAGING_MODE_RGB:
case IMAGING_MODE_RGBA:
case IMAGING_MODE_RGBX:
return TYPE_RGBA_8; return TYPE_RGBA_8;
case IMAGING_MODE_CMYK:
return TYPE_CMYK_8;
case IMAGING_MODE_I_16:
case IMAGING_MODE_I_16L:
return TYPE_GRAY_16;
case IMAGING_MODE_I_16B:
return TYPE_GRAY_16_SE;
case IMAGING_MODE_YCbCr:
return TYPE_YCbCr_8;
case IMAGING_MODE_LAB:
// LabX equivalent like ALab, but not reversed -- no #define in lcms2
return (
COLORSPACE_SH(PT_LabV2) | CHANNELS_SH(3) | BYTES_SH(1) | EXTRA_SH(1)
);
default:
// This function only accepts a subset of the imaging modes Pillow has.
break;
} }
if (strcmp(PILmode, "RGBA;16B") == 0) { // The following modes are not valid PIL Image modes.
if (strcmp(mode_name, "RGBA;16B") == 0) {
return TYPE_RGBA_16; return TYPE_RGBA_16;
} }
if (strcmp(PILmode, "CMYK") == 0) { if (strcmp(mode_name, "L;16") == 0) {
return TYPE_CMYK_8;
}
if (strcmp(PILmode, "I;16") == 0 || strcmp(PILmode, "I;16L") == 0 ||
strcmp(PILmode, "L;16") == 0) {
return TYPE_GRAY_16; return TYPE_GRAY_16;
} }
if (strcmp(PILmode, "I;16B") == 0 || strcmp(PILmode, "L;16B") == 0) { if (strcmp(mode_name, "L;16B") == 0) {
return TYPE_GRAY_16_SE; return TYPE_GRAY_16_SE;
} }
if (strcmp(PILmode, "YCbCr") == 0 || strcmp(PILmode, "YCCA") == 0 || if (strcmp(mode_name, "YCCA") == 0 || strcmp(mode_name, "YCC") == 0) {
strcmp(PILmode, "YCC") == 0) {
return TYPE_YCbCr_8; return TYPE_YCbCr_8;
} }
if (strcmp(PILmode, "LAB") == 0) {
// LabX equivalent like ALab, but not reversed -- no #define in lcms2
return (COLORSPACE_SH(PT_LabV2) | CHANNELS_SH(3) | BYTES_SH(1) | EXTRA_SH(1));
}
/* presume "1" or "L" by default */ /* presume "1" or "L" by default */
return TYPE_GRAY_8; return TYPE_GRAY_8;
} }

34
src/_imagingft.c
View File

@ -525,7 +525,7 @@ font_getlength(FontObject *self, PyObject *args) {
int horizontal_dir; /* is primary axis horizontal? */ int horizontal_dir; /* is primary axis horizontal? */
int mask = 0; /* is FT_LOAD_TARGET_MONO enabled? */ int mask = 0; /* is FT_LOAD_TARGET_MONO enabled? */
int color = 0; /* is FT_LOAD_COLOR enabled? */ int color = 0; /* is FT_LOAD_COLOR enabled? */
const char *mode = NULL; const char *mode_name = NULL;
const char *dir = NULL; const char *dir = NULL;
const char *lang = NULL; const char *lang = NULL;
PyObject *features = Py_None; PyObject *features = Py_None;
@ -534,15 +534,16 @@ font_getlength(FontObject *self, PyObject *args) {
/* calculate size and bearing for a given string */ /* calculate size and bearing for a given string */
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, "O|zzOz:getlength", &string, &mode, &dir, &features, &lang args, "O|zzOz:getlength", &string, &mode_name, &dir, &features, &lang
)) { )) {
return NULL; return NULL;
} }
horizontal_dir = dir && strcmp(dir, "ttb") == 0 ? 0 : 1; horizontal_dir = dir && strcmp(dir, "ttb") == 0 ? 0 : 1;
mask = mode && strcmp(mode, "1") == 0; const ModeID mode = findModeID(mode_name);
color = mode && strcmp(mode, "RGBA") == 0; mask = mode == IMAGING_MODE_1;
color = mode == IMAGING_MODE_RGBA;
count = text_layout(string, self, dir, features, lang, &glyph_info, mask, color); count = text_layout(string, self, dir, features, lang, &glyph_info, mask, color);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
@ -754,7 +755,7 @@ font_getsize(FontObject *self, PyObject *args) {
int horizontal_dir; /* is primary axis horizontal? */ int horizontal_dir; /* is primary axis horizontal? */
int mask = 0; /* is FT_LOAD_TARGET_MONO enabled? */ int mask = 0; /* is FT_LOAD_TARGET_MONO enabled? */
int color = 0; /* is FT_LOAD_COLOR enabled? */ int color = 0; /* is FT_LOAD_COLOR enabled? */
const char *mode = NULL; const char *mode_name = NULL;
const char *dir = NULL; const char *dir = NULL;
const char *lang = NULL; const char *lang = NULL;
const char *anchor = NULL; const char *anchor = NULL;
@ -764,15 +765,23 @@ font_getsize(FontObject *self, PyObject *args) {
/* calculate size and bearing for a given string */ /* calculate size and bearing for a given string */
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, "O|zzOzz:getsize", &string, &mode, &dir, &features, &lang, &anchor args,
"O|zzOzz:getsize",
&string,
&mode_name,
&dir,
&features,
&lang,
&anchor
)) { )) {
return NULL; return NULL;
} }
horizontal_dir = dir && strcmp(dir, "ttb") == 0 ? 0 : 1; horizontal_dir = dir && strcmp(dir, "ttb") == 0 ? 0 : 1;
mask = mode && strcmp(mode, "1") == 0; const ModeID mode = findModeID(mode_name);
color = mode && strcmp(mode, "RGBA") == 0; mask = mode == IMAGING_MODE_1;
color = mode == IMAGING_MODE_RGBA;
count = text_layout(string, self, dir, features, lang, &glyph_info, mask, color); count = text_layout(string, self, dir, features, lang, &glyph_info, mask, color);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
@ -839,7 +848,7 @@ font_render(FontObject *self, PyObject *args) {
int stroke_filled = 0; int stroke_filled = 0;
PY_LONG_LONG foreground_ink_long = 0; PY_LONG_LONG foreground_ink_long = 0;
unsigned int foreground_ink; unsigned int foreground_ink;
const char *mode = NULL; const char *mode_name = NULL;
const char *dir = NULL; const char *dir = NULL;
const char *lang = NULL; const char *lang = NULL;
const char *anchor = NULL; const char *anchor = NULL;
@ -859,7 +868,7 @@ font_render(FontObject *self, PyObject *args) {
"OO|zzOzfpzL(ff):render", "OO|zzOzfpzL(ff):render",
&string, &string,
&fill, &fill,
&mode, &mode_name,
&dir, &dir,
&features, &features,
&lang, &lang,
@ -873,8 +882,9 @@ font_render(FontObject *self, PyObject *args) {
return NULL; return NULL;
} }
mask = mode && strcmp(mode, "1") == 0; const ModeID mode = findModeID(mode_name);
color = mode && strcmp(mode, "RGBA") == 0; mask = mode == IMAGING_MODE_1;
color = mode == IMAGING_MODE_RGBA;
foreground_ink = foreground_ink_long; foreground_ink = foreground_ink_long;

16
src/_webp.c
View File

@ -89,8 +89,8 @@ HandleMuxError(WebPMuxError err, char *chunk) {
static int static int
import_frame_libwebp(WebPPicture *frame, Imaging im) { import_frame_libwebp(WebPPicture *frame, Imaging im) {
if (strcmp(im->mode, "RGBA") && strcmp(im->mode, "RGB") && if (im->mode != IMAGING_MODE_RGBA && im->mode != IMAGING_MODE_RGB &&
strcmp(im->mode, "RGBX")) { im->mode != IMAGING_MODE_RGBX) {
PyErr_SetString(PyExc_ValueError, "unsupported image mode"); PyErr_SetString(PyExc_ValueError, "unsupported image mode");
return -1; return -1;
} }
@ -104,7 +104,7 @@ import_frame_libwebp(WebPPicture *frame, Imaging im) {
return -2; return -2;
} }
int ignore_fourth_channel = strcmp(im->mode, "RGBA"); int ignore_fourth_channel = im->mode != IMAGING_MODE_RGBA;
for (int y = 0; y < im->ysize; ++y) { for (int y = 0; y < im->ysize; ++y) {
UINT8 *src = (UINT8 *)im->image32[y]; UINT8 *src = (UINT8 *)im->image32[y];
UINT32 *dst = frame->argb + frame->argb_stride * y; UINT32 *dst = frame->argb + frame->argb_stride * y;
@ -143,7 +143,7 @@ typedef struct {
PyObject_HEAD WebPAnimDecoder *dec; PyObject_HEAD WebPAnimDecoder *dec;
WebPAnimInfo info; WebPAnimInfo info;
WebPData data; WebPData data;
char *mode; ModeID mode;
} WebPAnimDecoderObject; } WebPAnimDecoderObject;
static PyTypeObject WebPAnimDecoder_Type; static PyTypeObject WebPAnimDecoder_Type;
@ -396,7 +396,7 @@ _anim_decoder_new(PyObject *self, PyObject *args) {
const uint8_t *webp; const uint8_t *webp;
Py_ssize_t size; Py_ssize_t size;
WebPData webp_src; WebPData webp_src;
char *mode; ModeID mode;
WebPDecoderConfig config; WebPDecoderConfig config;
WebPAnimDecoderObject *decp = NULL; WebPAnimDecoderObject *decp = NULL;
WebPAnimDecoder *dec = NULL; WebPAnimDecoder *dec = NULL;
@ -409,10 +409,10 @@ _anim_decoder_new(PyObject *self, PyObject *args) {
webp_src.size = size; webp_src.size = size;
// Sniff the mode, since the decoder API doesn't tell us // Sniff the mode, since the decoder API doesn't tell us
mode = "RGBA"; mode = IMAGING_MODE_RGBA;
if (WebPGetFeatures(webp, size, &config.input) == VP8_STATUS_OK) { if (WebPGetFeatures(webp, size, &config.input) == VP8_STATUS_OK) {
if (!config.input.has_alpha) { if (!config.input.has_alpha) {
mode = "RGBX"; mode = IMAGING_MODE_RGBX;
} }
} }
@ -455,7 +455,7 @@ _anim_decoder_get_info(PyObject *self) {
info->loop_count, info->loop_count,
info->bgcolor, info->bgcolor,
info->frame_count, info->frame_count,
decp->mode getModeData(decp->mode)->name
); );
} }

148
src/decode.c
View File

@ -266,7 +266,9 @@ static PyTypeObject ImagingDecoderType = {
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
int int
get_unpacker(ImagingDecoderObject *decoder, const char *mode, const char *rawmode) { get_unpacker(
ImagingDecoderObject *decoder, const ModeID mode, const RawModeID rawmode
) {
int bits; int bits;
ImagingShuffler unpack; ImagingShuffler unpack;
@ -291,17 +293,20 @@ PyObject *
PyImaging_BitDecoderNew(PyObject *self, PyObject *args) { PyImaging_BitDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; const char *mode_name;
int bits = 8; int bits = 8;
int pad = 8; int pad = 8;
int fill = 0; int fill = 0;
int sign = 0; int sign = 0;
int ystep = 1; int ystep = 1;
if (!PyArg_ParseTuple(args, "s|iiiii", &mode, &bits, &pad, &fill, &sign, &ystep)) { if (!PyArg_ParseTuple(
args, "s|iiiii", &mode_name, &bits, &pad, &fill, &sign, &ystep
)) {
return NULL; return NULL;
} }
if (strcmp(mode, "F") != 0) { const ModeID mode = findModeID(mode_name);
if (mode != IMAGING_MODE_F) {
PyErr_SetString(PyExc_ValueError, "bad image mode"); PyErr_SetString(PyExc_ValueError, "bad image mode");
return NULL; return NULL;
} }
@ -331,34 +336,36 @@ PyObject *
PyImaging_BcnDecoderNew(PyObject *self, PyObject *args) { PyImaging_BcnDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name;
char *actual;
int n = 0; int n = 0;
char *pixel_format = ""; char *pixel_format = "";
if (!PyArg_ParseTuple(args, "si|s", &mode, &n, &pixel_format)) { if (!PyArg_ParseTuple(args, "si|s", &mode_name, &n, &pixel_format)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
ModeID actual;
switch (n) { switch (n) {
case 1: /* BC1: 565 color, 1-bit alpha */ case 1: /* BC1: 565 color, 1-bit alpha */
case 2: /* BC2: 565 color, 4-bit alpha */ case 2: /* BC2: 565 color, 4-bit alpha */
case 3: /* BC3: 565 color, 2-endpoint 8-bit interpolated alpha */ case 3: /* BC3: 565 color, 2-endpoint 8-bit interpolated alpha */
case 7: /* BC7: 4-channel 8-bit via everything */ case 7: /* BC7: 4-channel 8-bit via everything */
actual = "RGBA"; actual = IMAGING_MODE_RGBA;
break; break;
case 4: /* BC4: 1-channel 8-bit via 1 BC3 alpha block */ case 4: /* BC4: 1-channel 8-bit via 1 BC3 alpha block */
actual = "L"; actual = IMAGING_MODE_L;
break; break;
case 5: /* BC5: 2-channel 8-bit via 2 BC3 alpha blocks */ case 5: /* BC5: 2-channel 8-bit via 2 BC3 alpha blocks */
case 6: /* BC6: 3-channel 16-bit float */ case 6: /* BC6: 3-channel 16-bit float */
actual = "RGB"; actual = IMAGING_MODE_RGB;
break; break;
default: default:
PyErr_SetString(PyExc_ValueError, "block compression type unknown"); PyErr_SetString(PyExc_ValueError, "block compression type unknown");
return NULL; return NULL;
} }
if (strcmp(mode, actual) != 0) { if (mode != actual) {
PyErr_SetString(PyExc_ValueError, "bad image mode"); PyErr_SetString(PyExc_ValueError, "bad image mode");
return NULL; return NULL;
} }
@ -401,15 +408,18 @@ PyObject *
PyImaging_GifDecoderNew(PyObject *self, PyObject *args) { PyImaging_GifDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; const char *mode_name;
int bits = 8; int bits = 8;
int interlace = 0; int interlace = 0;
int transparency = -1; int transparency = -1;
if (!PyArg_ParseTuple(args, "s|iii", &mode, &bits, &interlace, &transparency)) { if (!PyArg_ParseTuple(
args, "s|iii", &mode_name, &bits, &interlace, &transparency
)) {
return NULL; return NULL;
} }
if (strcmp(mode, "L") != 0 && strcmp(mode, "P") != 0) { const ModeID mode = findModeID(mode_name);
if (mode != IMAGING_MODE_L && mode != IMAGING_MODE_P) {
PyErr_SetString(PyExc_ValueError, "bad image mode"); PyErr_SetString(PyExc_ValueError, "bad image mode");
return NULL; return NULL;
} }
@ -436,12 +446,14 @@ PyObject *
PyImaging_HexDecoderNew(PyObject *self, PyObject *args) { PyImaging_HexDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name, *rawmode_name;
char *rawmode; if (!PyArg_ParseTuple(args, "ss", &mode_name, &rawmode_name)) {
if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -469,16 +481,21 @@ PyImaging_HexDecoderNew(PyObject *self, PyObject *args) {
PyObject * PyObject *
PyImaging_LibTiffDecoderNew(PyObject *self, PyObject *args) { PyImaging_LibTiffDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
char *compname; char *compname;
int fp; int fp;
uint32_t ifdoffset; uint32_t ifdoffset;
if (!PyArg_ParseTuple(args, "sssiI", &mode, &rawmode, &compname, &fp, &ifdoffset)) { if (!PyArg_ParseTuple(
args, "sssiI", &mode_name, &rawmode_name, &compname, &fp, &ifdoffset
)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
TRACE(("new tiff decoder %s\n", compname)); TRACE(("new tiff decoder %s\n", compname));
decoder = PyImaging_DecoderNew(sizeof(TIFFSTATE)); decoder = PyImaging_DecoderNew(sizeof(TIFFSTATE));
@ -511,12 +528,15 @@ PyObject *
PyImaging_PackbitsDecoderNew(PyObject *self, PyObject *args) { PyImaging_PackbitsDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode)) { if (!PyArg_ParseTuple(args, "ss", &mode_name, &rawmode_name)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -545,7 +565,7 @@ PyImaging_PcdDecoderNew(PyObject *self, PyObject *args) {
} }
/* Unpack from PhotoYCC to RGB */ /* Unpack from PhotoYCC to RGB */
if (get_unpacker(decoder, "RGB", "YCC;P") < 0) { if (get_unpacker(decoder, IMAGING_MODE_RGB, IMAGING_RAWMODE_YCC_P) < 0) {
return NULL; return NULL;
} }
@ -562,13 +582,15 @@ PyObject *
PyImaging_PcxDecoderNew(PyObject *self, PyObject *args) { PyImaging_PcxDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name, *rawmode_name;
char *rawmode;
int stride; int stride;
if (!PyArg_ParseTuple(args, "ssi", &mode, &rawmode, &stride)) { if (!PyArg_ParseTuple(args, "ssi", &mode_name, &rawmode_name, &stride)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -593,14 +615,16 @@ PyObject *
PyImaging_RawDecoderNew(PyObject *self, PyObject *args) { PyImaging_RawDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name, *rawmode_name;
char *rawmode;
int stride = 0; int stride = 0;
int ystep = 1; int ystep = 1;
if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &stride, &ystep)) { if (!PyArg_ParseTuple(args, "ss|ii", &mode_name, &rawmode_name, &stride, &ystep)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(sizeof(RAWSTATE)); decoder = PyImaging_DecoderNew(sizeof(RAWSTATE));
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -627,14 +651,16 @@ PyObject *
PyImaging_SgiRleDecoderNew(PyObject *self, PyObject *args) { PyImaging_SgiRleDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name, *rawmode_name;
char *rawmode;
int ystep = 1; int ystep = 1;
int bpc = 1; int bpc = 1;
if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &bpc)) { if (!PyArg_ParseTuple(args, "ss|ii", &mode_name, &rawmode_name, &ystep, &bpc)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(sizeof(SGISTATE)); decoder = PyImaging_DecoderNew(sizeof(SGISTATE));
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -661,12 +687,14 @@ PyObject *
PyImaging_SunRleDecoderNew(PyObject *self, PyObject *args) { PyImaging_SunRleDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name, *rawmode_name;
char *rawmode; if (!PyArg_ParseTuple(args, "ss", &mode_name, &rawmode_name)) {
if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -689,14 +717,16 @@ PyObject *
PyImaging_TgaRleDecoderNew(PyObject *self, PyObject *args) { PyImaging_TgaRleDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name, *rawmode_name;
char *rawmode;
int ystep = 1; int ystep = 1;
int depth = 8; int depth = 8;
if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &depth)) { if (!PyArg_ParseTuple(args, "ss|ii", &mode_name, &rawmode_name, &ystep, &depth)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -727,7 +757,7 @@ PyImaging_XbmDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
if (get_unpacker(decoder, "1", "1;R") < 0) { if (get_unpacker(decoder, IMAGING_MODE_1, IMAGING_RAWMODE_1_R) < 0) {
return NULL; return NULL;
} }
@ -748,13 +778,15 @@ PyObject *
PyImaging_ZipDecoderNew(PyObject *self, PyObject *args) { PyImaging_ZipDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name, *rawmode_name;
char *rawmode;
int interlaced = 0; int interlaced = 0;
if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &interlaced)) { if (!PyArg_ParseTuple(args, "ss|i", &mode_name, &rawmode_name, &interlaced)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE)); decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE));
if (decoder == NULL) { if (decoder == NULL) {
return NULL; return NULL;
@ -798,19 +830,21 @@ PyObject *
PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) { PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder; ImagingDecoderObject *decoder;
char *mode; char *mode_name;
char *rawmode; /* what we want from the decoder */ char *rawmode_name; /* what we want from the decoder */
char *jpegmode; /* what's in the file */ char *jpegmode_name; /* what's in the file */
int scale = 1; int scale = 1;
int draft = 0; int draft = 0;
if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode, &scale, &draft)) { if (!PyArg_ParseTuple(
args, "ssz|ii", &mode_name, &rawmode_name, &jpegmode_name, &scale, &draft
)) {
return NULL; return NULL;
} }
if (!jpegmode) { const ModeID mode = findModeID(mode_name);
jpegmode = ""; RawModeID rawmode = findRawModeID(rawmode_name);
} const RawModeID jpegmode = findRawModeID(jpegmode_name);
decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE)); decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE));
if (decoder == NULL) { if (decoder == NULL) {
@ -820,8 +854,8 @@ PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) {
// libjpeg-turbo supports different output formats. // libjpeg-turbo supports different output formats.
// We are choosing Pillow's native format (3 color bytes + 1 padding) // We are choosing Pillow's native format (3 color bytes + 1 padding)
// to avoid extra conversion in Unpack.c. // to avoid extra conversion in Unpack.c.
if (ImagingJpegUseJCSExtensions() && strcmp(rawmode, "RGB") == 0) { if (ImagingJpegUseJCSExtensions() && rawmode == IMAGING_RAWMODE_RGB) {
rawmode = "RGBX"; rawmode = IMAGING_RAWMODE_RGBX;
} }
if (get_unpacker(decoder, mode, rawmode) < 0) { if (get_unpacker(decoder, mode, rawmode) < 0) {
@ -831,11 +865,13 @@ PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) {
decoder->decode = ImagingJpegDecode; decoder->decode = ImagingJpegDecode;
decoder->cleanup = ImagingJpegDecodeCleanup; decoder->cleanup = ImagingJpegDecodeCleanup;
strncpy(((JPEGSTATE *)decoder->state.context)->rawmode, rawmode, 8); JPEGSTATE *jpeg_decoder_state_context = (JPEGSTATE *)decoder->state.context;
strncpy(((JPEGSTATE *)decoder->state.context)->jpegmode, jpegmode, 8);
((JPEGSTATE *)decoder->state.context)->scale = scale; jpeg_decoder_state_context->rawmode = rawmode;
((JPEGSTATE *)decoder->state.context)->draft = draft; jpeg_decoder_state_context->jpegmode = jpegmode;
jpeg_decoder_state_context->scale = scale;
jpeg_decoder_state_context->draft = draft;
return (PyObject *)decoder; return (PyObject *)decoder;
} }

16
src/display.c
View File

@ -47,7 +47,7 @@ typedef struct {
static PyTypeObject ImagingDisplayType; static PyTypeObject ImagingDisplayType;
static ImagingDisplayObject * static ImagingDisplayObject *
_new(const char *mode, int xsize, int ysize) { _new(const ModeID mode, int xsize, int ysize) {
ImagingDisplayObject *display; ImagingDisplayObject *display;
if (PyType_Ready(&ImagingDisplayType) < 0) { if (PyType_Ready(&ImagingDisplayType) < 0) {
@ -235,7 +235,7 @@ static struct PyMethodDef methods[] = {
static PyObject * static PyObject *
_getattr_mode(ImagingDisplayObject *self, void *closure) { _getattr_mode(ImagingDisplayObject *self, void *closure) {
return Py_BuildValue("s", self->dib->mode); return Py_BuildValue("s", getModeData(self->dib->mode)->name);
} }
static PyObject * static PyObject *
@ -258,13 +258,14 @@ static PyTypeObject ImagingDisplayType = {
PyObject * PyObject *
PyImaging_DisplayWin32(PyObject *self, PyObject *args) { PyImaging_DisplayWin32(PyObject *self, PyObject *args) {
ImagingDisplayObject *display; ImagingDisplayObject *display;
char *mode; char *mode_name;
int xsize, ysize; int xsize, ysize;
if (!PyArg_ParseTuple(args, "s(ii)", &mode, &xsize, &ysize)) { if (!PyArg_ParseTuple(args, "s(ii)", &mode_name, &xsize, &ysize)) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
display = _new(mode, xsize, ysize); display = _new(mode, xsize, ysize);
if (display == NULL) { if (display == NULL) {
return NULL; return NULL;
@ -275,12 +276,9 @@ PyImaging_DisplayWin32(PyObject *self, PyObject *args) {
PyObject * PyObject *
PyImaging_DisplayModeWin32(PyObject *self, PyObject *args) { PyImaging_DisplayModeWin32(PyObject *self, PyObject *args) {
char *mode;
int size[2]; int size[2];
const ModeID mode = ImagingGetModeDIB(size);
mode = ImagingGetModeDIB(size); return Py_BuildValue("s(ii)", getModeData(mode)->name, size[0], size[1]);
return Py_BuildValue("s(ii)", mode, size[0], size[1]);
} }
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */

96
src/encode.c
View File

@ -334,14 +334,19 @@ static PyTypeObject ImagingEncoderType = {
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
int int
get_packer(ImagingEncoderObject *encoder, const char *mode, const char *rawmode) { get_packer(ImagingEncoderObject *encoder, const ModeID mode, const RawModeID rawmode) {
int bits; int bits;
ImagingShuffler pack; ImagingShuffler pack;
pack = ImagingFindPacker(mode, rawmode, &bits); pack = ImagingFindPacker(mode, rawmode, &bits);
if (!pack) { if (!pack) {
Py_DECREF(encoder); Py_DECREF(encoder);
PyErr_Format(PyExc_ValueError, "No packer found from %s to %s", mode, rawmode); PyErr_Format(
PyExc_ValueError,
"No packer found from %s to %s",
getModeData(mode)->name,
getRawModeData(rawmode)->name
);
return -1; return -1;
} }
@ -402,11 +407,13 @@ PyObject *
PyImaging_GifEncoderNew(PyObject *self, PyObject *args) { PyImaging_GifEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder; ImagingEncoderObject *encoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
Py_ssize_t bits = 8; Py_ssize_t bits = 8;
Py_ssize_t interlace = 0; Py_ssize_t interlace = 0;
if (!PyArg_ParseTuple(args, "ss|nn", &mode, &rawmode, &bits, &interlace)) { if (!PyArg_ParseTuple(
args, "ss|nn", &mode_name, &rawmode_name, &bits, &interlace
)) {
return NULL; return NULL;
} }
@ -415,6 +422,9 @@ PyImaging_GifEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
if (get_packer(encoder, mode, rawmode) < 0) { if (get_packer(encoder, mode, rawmode) < 0) {
return NULL; return NULL;
} }
@ -435,11 +445,11 @@ PyObject *
PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) { PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder; ImagingEncoderObject *encoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
Py_ssize_t bits = 8; Py_ssize_t bits = 8;
if (!PyArg_ParseTuple(args, "ss|n", &mode, &rawmode, &bits)) { if (!PyArg_ParseTuple(args, "ss|n", &mode_name, &rawmode_name, &bits)) {
return NULL; return NULL;
} }
@ -448,6 +458,9 @@ PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
if (get_packer(encoder, mode, rawmode) < 0) { if (get_packer(encoder, mode, rawmode) < 0) {
return NULL; return NULL;
} }
@ -465,12 +478,12 @@ PyObject *
PyImaging_RawEncoderNew(PyObject *self, PyObject *args) { PyImaging_RawEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder; ImagingEncoderObject *encoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
Py_ssize_t stride = 0; Py_ssize_t stride = 0;
Py_ssize_t ystep = 1; Py_ssize_t ystep = 1;
if (!PyArg_ParseTuple(args, "ss|nn", &mode, &rawmode, &stride, &ystep)) { if (!PyArg_ParseTuple(args, "ss|nn", &mode_name, &rawmode_name, &stride, &ystep)) {
return NULL; return NULL;
} }
@ -479,6 +492,9 @@ PyImaging_RawEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
if (get_packer(encoder, mode, rawmode) < 0) { if (get_packer(encoder, mode, rawmode) < 0) {
return NULL; return NULL;
} }
@ -499,11 +515,11 @@ PyObject *
PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) { PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder; ImagingEncoderObject *encoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
Py_ssize_t ystep = 1; Py_ssize_t ystep = 1;
if (!PyArg_ParseTuple(args, "ss|n", &mode, &rawmode, &ystep)) { if (!PyArg_ParseTuple(args, "ss|n", &mode_name, &rawmode_name, &ystep)) {
return NULL; return NULL;
} }
@ -512,6 +528,9 @@ PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
if (get_packer(encoder, mode, rawmode) < 0) { if (get_packer(encoder, mode, rawmode) < 0) {
return NULL; return NULL;
} }
@ -536,7 +555,7 @@ PyImaging_XbmEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
if (get_packer(encoder, "1", "1;R") < 0) { if (get_packer(encoder, IMAGING_MODE_1, IMAGING_RAWMODE_1_R) < 0) {
return NULL; return NULL;
} }
@ -557,8 +576,8 @@ PyObject *
PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) { PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder; ImagingEncoderObject *encoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
Py_ssize_t optimize = 0; Py_ssize_t optimize = 0;
Py_ssize_t compress_level = -1; Py_ssize_t compress_level = -1;
Py_ssize_t compress_type = -1; Py_ssize_t compress_type = -1;
@ -567,8 +586,8 @@ PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, args,
"ss|nnny#", "ss|nnny#",
&mode, &mode_name,
&rawmode, &rawmode_name,
&optimize, &optimize,
&compress_level, &compress_level,
&compress_type, &compress_type,
@ -597,6 +616,9 @@ PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
if (get_packer(encoder, mode, rawmode) < 0) { if (get_packer(encoder, mode, rawmode) < 0) {
free(dictionary); free(dictionary);
return NULL; return NULL;
@ -605,7 +627,7 @@ PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
encoder->encode = ImagingZipEncode; encoder->encode = ImagingZipEncode;
encoder->cleanup = ImagingZipEncodeCleanup; encoder->cleanup = ImagingZipEncodeCleanup;
if (rawmode[0] == 'P') { if (rawmode == IMAGING_RAWMODE_P || rawmode == IMAGING_RAWMODE_PA) {
/* disable filtering */ /* disable filtering */
((ZIPSTATE *)encoder->state.context)->mode = ZIP_PNG_PALETTE; ((ZIPSTATE *)encoder->state.context)->mode = ZIP_PNG_PALETTE;
} }
@ -634,8 +656,8 @@ PyObject *
PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) { PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder; ImagingEncoderObject *encoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
char *compname; char *compname;
char *filename; char *filename;
Py_ssize_t fp; Py_ssize_t fp;
@ -655,7 +677,15 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
PyObject *item; PyObject *item;
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, "sssnsOO", &mode, &rawmode, &compname, &fp, &filename, &tags, &types args,
"sssnsOO",
&mode_name,
&rawmode_name,
&compname,
&fp,
&filename,
&tags,
&types
)) { )) {
return NULL; return NULL;
} }
@ -693,6 +723,9 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
const RawModeID rawmode = findRawModeID(rawmode_name);
if (get_packer(encoder, mode, rawmode) < 0) { if (get_packer(encoder, mode, rawmode) < 0) {
return NULL; return NULL;
} }
@ -1088,8 +1121,8 @@ PyObject *
PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) { PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder; ImagingEncoderObject *encoder;
char *mode; char *mode_name;
char *rawmode; char *rawmode_name;
Py_ssize_t quality = 0; Py_ssize_t quality = 0;
Py_ssize_t progressive = 0; Py_ssize_t progressive = 0;
Py_ssize_t smooth = 0; Py_ssize_t smooth = 0;
@ -1113,8 +1146,8 @@ PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, args,
"ss|nnnnpn(nn)nnnOz#y#y#", "ss|nnnnpn(nn)nnnOz#y#y#",
&mode, &mode_name,
&rawmode, &rawmode_name,
&quality, &quality,
&progressive, &progressive,
&smooth, &smooth,
@ -1142,11 +1175,14 @@ PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
RawModeID rawmode = findRawModeID(rawmode_name);
// libjpeg-turbo supports different output formats. // libjpeg-turbo supports different output formats.
// We are choosing Pillow's native format (3 color bytes + 1 padding) // We are choosing Pillow's native format (3 color bytes + 1 padding)
// to avoid extra conversion in Pack.c. // to avoid extra conversion in Pack.c.
if (ImagingJpegUseJCSExtensions() && strcmp(rawmode, "RGB") == 0) { if (ImagingJpegUseJCSExtensions() && rawmode == IMAGING_RAWMODE_RGB) {
rawmode = "RGBX"; rawmode = IMAGING_RAWMODE_RGBX;
} }
if (get_packer(encoder, mode, rawmode) < 0) { if (get_packer(encoder, mode, rawmode) < 0) {
@ -1204,7 +1240,7 @@ PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
encoder->encode = ImagingJpegEncode; encoder->encode = ImagingJpegEncode;
JPEGENCODERSTATE *jpeg_encoder_state = (JPEGENCODERSTATE *)encoder->state.context; JPEGENCODERSTATE *jpeg_encoder_state = (JPEGENCODERSTATE *)encoder->state.context;
strncpy(jpeg_encoder_state->rawmode, rawmode, 8); jpeg_encoder_state->rawmode = rawmode;
jpeg_encoder_state->keep_rgb = keep_rgb; jpeg_encoder_state->keep_rgb = keep_rgb;
jpeg_encoder_state->quality = quality; jpeg_encoder_state->quality = quality;
jpeg_encoder_state->qtables = qarrays; jpeg_encoder_state->qtables = qarrays;

99
src/libImaging/Access.c
View File

@ -11,39 +11,6 @@
#include "Imaging.h" #include "Imaging.h"
/* use make_hash.py from the pillow-scripts repository to calculate these values */
#define ACCESS_TABLE_SIZE 23
#define ACCESS_TABLE_HASH 28677
static struct ImagingAccessInstance access_table[ACCESS_TABLE_SIZE];
static inline UINT32
hash(const char *mode) {
UINT32 i = ACCESS_TABLE_HASH;
while (*mode) {
i = ((i << 5) + i) ^ (UINT8)*mode++;
}
return i % ACCESS_TABLE_SIZE;
}
static ImagingAccess
add_item(const char *mode) {
UINT32 i = hash(mode);
/* printf("hash %s => %d\n", mode, i); */
if (access_table[i].mode && strcmp(access_table[i].mode, mode) != 0) {
fprintf(
stderr,
"AccessInit: hash collision: %d for both %s and %s\n",
i,
mode,
access_table[i].mode
);
exit(1);
}
access_table[i].mode = mode;
return &access_table[i];
}
/* fetch individual pixel */ /* fetch individual pixel */
static void static void
@ -112,49 +79,41 @@ put_pixel_32(Imaging im, int x, int y, const void *color) {
memcpy(&im->image32[y][x], color, sizeof(INT32)); memcpy(&im->image32[y][x], color, sizeof(INT32));
} }
void static struct ImagingAccessInstance accessors[] = {
ImagingAccessInit(void) { {IMAGING_MODE_1, get_pixel_8, put_pixel_8},
#define ADD(mode_, get_pixel_, put_pixel_) \ {IMAGING_MODE_L, get_pixel_8, put_pixel_8},
{ \ {IMAGING_MODE_LA, get_pixel_32_2bands, put_pixel_32},
ImagingAccess access = add_item(mode_); \ {IMAGING_MODE_La, get_pixel_32_2bands, put_pixel_32},
access->get_pixel = get_pixel_; \ {IMAGING_MODE_I, get_pixel_32, put_pixel_32},
access->put_pixel = put_pixel_; \ {IMAGING_MODE_I_16, get_pixel_16L, put_pixel_16L},
} {IMAGING_MODE_I_16L, get_pixel_16L, put_pixel_16L},
{IMAGING_MODE_I_16B, get_pixel_16B, put_pixel_16B},
/* populate access table */
ADD("1", get_pixel_8, put_pixel_8);
ADD("L", get_pixel_8, put_pixel_8);
ADD("LA", get_pixel_32_2bands, put_pixel_32);
ADD("La", get_pixel_32_2bands, put_pixel_32);
ADD("I", get_pixel_32, put_pixel_32);
ADD("I;16", get_pixel_16L, put_pixel_16L);
ADD("I;16L", get_pixel_16L, put_pixel_16L);
ADD("I;16B", get_pixel_16B, put_pixel_16B);
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
ADD("I;16N", get_pixel_16B, put_pixel_16B); {IMAGING_MODE_I_16N, get_pixel_16B, put_pixel_16B},
#else #else
ADD("I;16N", get_pixel_16L, put_pixel_16L); {IMAGING_MODE_I_16N, get_pixel_16L, put_pixel_16L},
#endif #endif
ADD("F", get_pixel_32, put_pixel_32); {IMAGING_MODE_F, get_pixel_32, put_pixel_32},
ADD("P", get_pixel_8, put_pixel_8); {IMAGING_MODE_P, get_pixel_8, put_pixel_8},
ADD("PA", get_pixel_32_2bands, put_pixel_32); {IMAGING_MODE_PA, get_pixel_32_2bands, put_pixel_32},
ADD("RGB", get_pixel_32, put_pixel_32); {IMAGING_MODE_RGB, get_pixel_32, put_pixel_32},
ADD("RGBA", get_pixel_32, put_pixel_32); {IMAGING_MODE_RGBA, get_pixel_32, put_pixel_32},
ADD("RGBa", get_pixel_32, put_pixel_32); {IMAGING_MODE_RGBa, get_pixel_32, put_pixel_32},
ADD("RGBX", get_pixel_32, put_pixel_32); {IMAGING_MODE_RGBX, get_pixel_32, put_pixel_32},
ADD("CMYK", get_pixel_32, put_pixel_32); {IMAGING_MODE_CMYK, get_pixel_32, put_pixel_32},
ADD("YCbCr", get_pixel_32, put_pixel_32); {IMAGING_MODE_YCbCr, get_pixel_32, put_pixel_32},
ADD("LAB", get_pixel_32, put_pixel_32); {IMAGING_MODE_LAB, get_pixel_32, put_pixel_32},
ADD("HSV", get_pixel_32, put_pixel_32); {IMAGING_MODE_HSV, get_pixel_32, put_pixel_32},
} };
ImagingAccess ImagingAccess
ImagingAccessNew(Imaging im) { ImagingAccessNew(const Imaging im) {
ImagingAccess access = &access_table[hash(im->mode)]; for (size_t i = 0; i < sizeof(accessors) / sizeof(*accessors); i++) {
if (im->mode[0] != access->mode[0] || strcmp(im->mode, access->mode) != 0) { if (im->mode == accessors[i].mode) {
return NULL; return &accessors[i];
} }
return access; }
return NULL;
} }
void void

4
src/libImaging/AlphaComposite.c
View File

@ -26,11 +26,11 @@ ImagingAlphaComposite(Imaging imDst, Imaging imSrc) {
/* Check arguments */ /* Check arguments */
if (!imDst || !imSrc || if (!imDst || !imSrc ||
(strcmp(imDst->mode, "RGBA") && strcmp(imDst->mode, "LA"))) { (imDst->mode != IMAGING_MODE_RGBA && imDst->mode != IMAGING_MODE_LA)) {
return ImagingError_ModeError(); return ImagingError_ModeError();
} }
if (strcmp(imDst->mode, imSrc->mode) || imDst->xsize != imSrc->xsize || if (imDst->mode != imSrc->mode || imDst->xsize != imSrc->xsize ||
imDst->ysize != imSrc->ysize) { imDst->ysize != imSrc->ysize) {
return ImagingError_Mismatch(); return ImagingError_Mismatch();
} }

5
src/libImaging/Arrow.c
View File

@ -187,7 +187,6 @@ export_named_type(struct ArrowSchema *schema, char *format, char *name) {
int int
export_imaging_schema(Imaging im, struct ArrowSchema *schema) { export_imaging_schema(Imaging im, struct ArrowSchema *schema) {
int retval = 0; int retval = 0;
char *metadata;
char *band_json; char *band_json;
if (strcmp(im->arrow_band_format, "") == 0) { if (strcmp(im->arrow_band_format, "") == 0) {
@ -221,7 +220,9 @@ export_imaging_schema(Imaging im, struct ArrowSchema *schema) {
schema->n_children = 1; schema->n_children = 1;
schema->children = calloc(1, sizeof(struct ArrowSchema *)); schema->children = calloc(1, sizeof(struct ArrowSchema *));
schema->children[0] = (struct ArrowSchema *)calloc(1, sizeof(struct ArrowSchema)); schema->children[0] = (struct ArrowSchema *)calloc(1, sizeof(struct ArrowSchema));
retval = export_named_type(schema->children[0], im->arrow_band_format, im->mode); retval = export_named_type(
schema->children[0], im->arrow_band_format, getModeData(im->mode)->name
);
if (retval != 0) { if (retval != 0) {
free(schema->children[0]); free(schema->children[0]);
free(schema->children); free(schema->children);

6
src/libImaging/Bands.c
View File

@ -41,7 +41,7 @@ ImagingGetBand(Imaging imIn, int band) {
band = 3; band = 3;
} }
imOut = ImagingNewDirty("L", imIn->xsize, imIn->ysize); imOut = ImagingNewDirty(IMAGING_MODE_L, imIn->xsize, imIn->ysize);
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -82,7 +82,7 @@ ImagingSplit(Imaging imIn, Imaging bands[4]) {
} }
for (i = 0; i < imIn->bands; i++) { for (i = 0; i < imIn->bands; i++) {
bands[i] = ImagingNewDirty("L", imIn->xsize, imIn->ysize); bands[i] = ImagingNewDirty(IMAGING_MODE_L, imIn->xsize, imIn->ysize);
if (!bands[i]) { if (!bands[i]) {
for (j = 0; j < i; ++j) { for (j = 0; j < i; ++j) {
ImagingDelete(bands[j]); ImagingDelete(bands[j]);
@ -240,7 +240,7 @@ ImagingFillBand(Imaging imOut, int band, int color) {
} }
Imaging Imaging
ImagingMerge(const char *mode, Imaging bands[4]) { ImagingMerge(const ModeID mode, Imaging bands[4]) {
int i, x, y; int i, x, y;
int bandsCount = 0; int bandsCount = 0;
Imaging imOut; Imaging imOut;

2
src/libImaging/BcnEncode.c
View File

@ -253,7 +253,7 @@ int
ImagingBcnEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) { ImagingBcnEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
int n = state->state; int n = state->state;
int has_alpha_channel = int has_alpha_channel =
strcmp(im->mode, "RGBA") == 0 || strcmp(im->mode, "LA") == 0; im->mode == IMAGING_MODE_RGBA || im->mode == IMAGING_MODE_LA;
UINT8 *dst = buf; UINT8 *dst = buf;

4
src/libImaging/Blend.c
View File

@ -24,8 +24,8 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha) {
/* Check arguments */ /* Check arguments */
if (!imIn1 || !imIn2 || imIn1->type != IMAGING_TYPE_UINT8 || imIn1->palette || if (!imIn1 || !imIn2 || imIn1->type != IMAGING_TYPE_UINT8 || imIn1->palette ||
strcmp(imIn1->mode, "1") == 0 || imIn2->palette || imIn1->mode == IMAGING_MODE_1 || imIn2->palette ||
strcmp(imIn2->mode, "1") == 0) { imIn2->mode == IMAGING_MODE_1) {
return ImagingError_ModeError(); return ImagingError_ModeError();
} }

10
src/libImaging/BoxBlur.c
View File

@ -248,7 +248,7 @@ ImagingBoxBlur(Imaging imOut, Imaging imIn, float xradius, float yradius, int n)
return ImagingError_ValueError("radius must be >= 0"); return ImagingError_ValueError("radius must be >= 0");
} }
if (strcmp(imIn->mode, imOut->mode) || imIn->type != imOut->type || if (imIn->mode != imOut->mode || imIn->type != imOut->type ||
imIn->bands != imOut->bands || imIn->xsize != imOut->xsize || imIn->bands != imOut->bands || imIn->xsize != imOut->xsize ||
imIn->ysize != imOut->ysize) { imIn->ysize != imOut->ysize) {
return ImagingError_Mismatch(); return ImagingError_Mismatch();
@ -258,10 +258,10 @@ ImagingBoxBlur(Imaging imOut, Imaging imIn, float xradius, float yradius, int n)
return ImagingError_ModeError(); return ImagingError_ModeError();
} }
if (!(strcmp(imIn->mode, "RGB") == 0 || strcmp(imIn->mode, "RGBA") == 0 || if (imIn->mode != IMAGING_MODE_RGB && imIn->mode != IMAGING_MODE_RGBA &&
strcmp(imIn->mode, "RGBa") == 0 || strcmp(imIn->mode, "RGBX") == 0 || imIn->mode != IMAGING_MODE_RGBa && imIn->mode != IMAGING_MODE_RGBX &&
strcmp(imIn->mode, "CMYK") == 0 || strcmp(imIn->mode, "L") == 0 || imIn->mode != IMAGING_MODE_CMYK && imIn->mode != IMAGING_MODE_L &&
strcmp(imIn->mode, "LA") == 0 || strcmp(imIn->mode, "La") == 0)) { imIn->mode != IMAGING_MODE_LA && imIn->mode != IMAGING_MODE_La) {
return ImagingError_ModeError(); return ImagingError_ModeError();
} }

23
src/libImaging/Chops.c
View File

@ -21,7 +21,7 @@
#define CHOP(operation) \ #define CHOP(operation) \
int x, y; \ int x, y; \
Imaging imOut; \ Imaging imOut; \
imOut = create(imIn1, imIn2, NULL); \ imOut = create(imIn1, imIn2, IMAGING_MODE_UNKNOWN); \
if (!imOut) { \ if (!imOut) { \
return NULL; \ return NULL; \
} \ } \
@ -60,11 +60,12 @@
return imOut; return imOut;
static Imaging static Imaging
create(Imaging im1, Imaging im2, char *mode) { create(Imaging im1, Imaging im2, const ModeID mode) {
int xsize, ysize; int xsize, ysize;
if (!im1 || !im2 || im1->type != IMAGING_TYPE_UINT8 || if (!im1 || !im2 || im1->type != IMAGING_TYPE_UINT8 ||
(mode != NULL && (strcmp(im1->mode, "1") || strcmp(im2->mode, "1")))) { (mode != IMAGING_MODE_UNKNOWN &&
(im1->mode != IMAGING_MODE_1 || im2->mode != IMAGING_MODE_1))) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (im1->type != im2->type || im1->bands != im2->bands) { if (im1->type != im2->type || im1->bands != im2->bands) {
@ -114,27 +115,27 @@ ImagingChopSubtract(Imaging imIn1, Imaging imIn2, float scale, int offset) {
Imaging Imaging
ImagingChopAnd(Imaging imIn1, Imaging imIn2) { ImagingChopAnd(Imaging imIn1, Imaging imIn2) {
CHOP2((in1[x] && in2[x]) ? 255 : 0, "1"); CHOP2((in1[x] && in2[x]) ? 255 : 0, IMAGING_MODE_1);
} }
Imaging Imaging
ImagingChopOr(Imaging imIn1, Imaging imIn2) { ImagingChopOr(Imaging imIn1, Imaging imIn2) {
CHOP2((in1[x] || in2[x]) ? 255 : 0, "1"); CHOP2((in1[x] || in2[x]) ? 255 : 0, IMAGING_MODE_1);
} }
Imaging Imaging
ImagingChopXor(Imaging imIn1, Imaging imIn2) { ImagingChopXor(Imaging imIn1, Imaging imIn2) {
CHOP2(((in1[x] != 0) ^ (in2[x] != 0)) ? 255 : 0, "1"); CHOP2(((in1[x] != 0) ^ (in2[x] != 0)) ? 255 : 0, IMAGING_MODE_1);
} }
Imaging Imaging
ImagingChopAddModulo(Imaging imIn1, Imaging imIn2) { ImagingChopAddModulo(Imaging imIn1, Imaging imIn2) {
CHOP2(in1[x] + in2[x], NULL); CHOP2(in1[x] + in2[x], IMAGING_MODE_UNKNOWN);
} }
Imaging Imaging
ImagingChopSubtractModulo(Imaging imIn1, Imaging imIn2) { ImagingChopSubtractModulo(Imaging imIn1, Imaging imIn2) {
CHOP2(in1[x] - in2[x], NULL); CHOP2(in1[x] - in2[x], IMAGING_MODE_UNKNOWN);
} }
Imaging Imaging
@ -142,7 +143,7 @@ ImagingChopSoftLight(Imaging imIn1, Imaging imIn2) {
CHOP2( CHOP2(
(((255 - in1[x]) * (in1[x] * in2[x])) / 65536) + (((255 - in1[x]) * (in1[x] * in2[x])) / 65536) +
(in1[x] * (255 - ((255 - in1[x]) * (255 - in2[x]) / 255))) / 255, (in1[x] * (255 - ((255 - in1[x]) * (255 - in2[x]) / 255))) / 255,
NULL IMAGING_MODE_UNKNOWN
); );
} }
@ -151,7 +152,7 @@ ImagingChopHardLight(Imaging imIn1, Imaging imIn2) {
CHOP2( CHOP2(
(in2[x] < 128) ? ((in1[x] * in2[x]) / 127) (in2[x] < 128) ? ((in1[x] * in2[x]) / 127)
: 255 - (((255 - in2[x]) * (255 - in1[x])) / 127), : 255 - (((255 - in2[x]) * (255 - in1[x])) / 127),
NULL IMAGING_MODE_UNKNOWN
); );
} }
@ -160,6 +161,6 @@ ImagingOverlay(Imaging imIn1, Imaging imIn2) {
CHOP2( CHOP2(
(in1[x] < 128) ? ((in1[x] * in2[x]) / 127) (in1[x] < 128) ? ((in1[x] * in2[x]) / 127)
: 255 - (((255 - in1[x]) * (255 - in2[x])) / 127), : 255 - (((255 - in1[x]) * (255 - in2[x])) / 127),
NULL IMAGING_MODE_UNKNOWN
); );
} }

394
src/libImaging/Convert.c
View File

@ -877,147 +877,12 @@ I16_RGB(UINT8 *out, const UINT8 *in, int xsize) {
} }
} }
static struct {
const char *from;
const char *to;
ImagingShuffler convert;
} converters[] = {
{"1", "L", bit2l},
{"1", "I", bit2i},
{"1", "F", bit2f},
{"1", "RGB", bit2rgb},
{"1", "RGBA", bit2rgb},
{"1", "RGBX", bit2rgb},
{"1", "CMYK", bit2cmyk},
{"1", "YCbCr", bit2ycbcr},
{"1", "HSV", bit2hsv},
{"L", "1", l2bit},
{"L", "LA", l2la},
{"L", "I", l2i},
{"L", "F", l2f},
{"L", "RGB", l2rgb},
{"L", "RGBA", l2rgb},
{"L", "RGBX", l2rgb},
{"L", "CMYK", l2cmyk},
{"L", "YCbCr", l2ycbcr},
{"L", "HSV", l2hsv},
{"LA", "L", la2l},
{"LA", "La", lA2la},
{"LA", "RGB", la2rgb},
{"LA", "RGBA", la2rgb},
{"LA", "RGBX", la2rgb},
{"LA", "CMYK", la2cmyk},
{"LA", "YCbCr", la2ycbcr},
{"LA", "HSV", la2hsv},
{"La", "LA", la2lA},
{"I", "L", i2l},
{"I", "F", i2f},
{"I", "RGB", i2rgb},
{"I", "RGBA", i2rgb},
{"I", "RGBX", i2rgb},
{"I", "HSV", i2hsv},
{"F", "L", f2l},
{"F", "I", f2i},
{"RGB", "1", rgb2bit},
{"RGB", "L", rgb2l},
{"RGB", "LA", rgb2la},
{"RGB", "La", rgb2la},
{"RGB", "I", rgb2i},
{"RGB", "I;16", rgb2i16l},
{"RGB", "I;16L", rgb2i16l},
{"RGB", "I;16B", rgb2i16b},
#ifdef WORDS_BIGENDIAN
{"RGB", "I;16N", rgb2i16b},
#else
{"RGB", "I;16N", rgb2i16l},
#endif
{"RGB", "F", rgb2f},
{"RGB", "RGBA", rgb2rgba},
{"RGB", "RGBa", rgb2rgba},
{"RGB", "RGBX", rgb2rgba},
{"RGB", "CMYK", rgb2cmyk},
{"RGB", "YCbCr", ImagingConvertRGB2YCbCr},
{"RGB", "HSV", rgb2hsv},
{"RGBA", "1", rgb2bit},
{"RGBA", "L", rgb2l},
{"RGBA", "LA", rgba2la},
{"RGBA", "I", rgb2i},
{"RGBA", "F", rgb2f},
{"RGBA", "RGB", rgba2rgb},
{"RGBA", "RGBa", rgbA2rgba},
{"RGBA", "RGBX", rgb2rgba},
{"RGBA", "CMYK", rgb2cmyk},
{"RGBA", "YCbCr", ImagingConvertRGB2YCbCr},
{"RGBA", "HSV", rgb2hsv},
{"RGBa", "RGBA", rgba2rgbA},
{"RGBa", "RGB", rgba2rgb_},
{"RGBX", "1", rgb2bit},
{"RGBX", "L", rgb2l},
{"RGBX", "LA", rgb2la},
{"RGBX", "I", rgb2i},
{"RGBX", "F", rgb2f},
{"RGBX", "RGB", rgba2rgb},
{"RGBX", "CMYK", rgb2cmyk},
{"RGBX", "YCbCr", ImagingConvertRGB2YCbCr},
{"RGBX", "HSV", rgb2hsv},
{"CMYK", "RGB", cmyk2rgb},
{"CMYK", "RGBA", cmyk2rgb},
{"CMYK", "RGBX", cmyk2rgb},
{"CMYK", "HSV", cmyk2hsv},
{"YCbCr", "L", ycbcr2l},
{"YCbCr", "LA", ycbcr2la},
{"YCbCr", "RGB", ImagingConvertYCbCr2RGB},
{"HSV", "RGB", hsv2rgb},
{"I", "I;16", I_I16L},
{"I;16", "I", I16L_I},
{"I;16", "RGB", I16_RGB},
{"L", "I;16", L_I16L},
{"I;16", "L", I16L_L},
{"I", "I;16L", I_I16L},
{"I;16L", "I", I16L_I},
{"I", "I;16B", I_I16B},
{"I;16B", "I", I16B_I},
{"L", "I;16L", L_I16L},
{"I;16L", "L", I16L_L},
{"L", "I;16B", L_I16B},
{"I;16B", "L", I16B_L},
#ifdef WORDS_BIGENDIAN
{"L", "I;16N", L_I16B},
{"I;16N", "L", I16B_L},
#else
{"L", "I;16N", L_I16L},
{"I;16N", "L", I16L_L},
#endif
{"I;16", "F", I16L_F},
{"I;16L", "F", I16L_F},
{"I;16B", "F", I16B_F},
{NULL}
};
/* FIXME: translate indexed versions to pointer versions below this line */
/* ------------------- */ /* ------------------- */
/* Palette conversions */ /* Palette conversions */
/* ------------------- */ /* ------------------- */
/* FIXME: translate indexed versions to pointer versions below this line */
static void static void
p2bit(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) { p2bit(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) {
int x; int x;
@ -1065,13 +930,13 @@ pa2p(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) {
static void static void
p2pa(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) { p2pa(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) {
int x; int x;
int rgb = strcmp(palette->mode, "RGB"); const int rgb = palette->mode == IMAGING_MODE_RGB;
for (x = 0; x < xsize; x++, in++) { for (x = 0; x < xsize; x++, in++) {
const UINT8 *rgba = &palette->palette[in[0] * 4]; const UINT8 *rgba = &palette->palette[in[0] * 4];
*out++ = in[0]; *out++ = in[0];
*out++ = in[0]; *out++ = in[0];
*out++ = in[0]; *out++ = in[0];
*out++ = rgb == 0 ? 255 : rgba[3]; *out++ = rgb ? 255 : rgba[3];
} }
} }
@ -1225,7 +1090,7 @@ pa2ycbcr(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) {
} }
static Imaging static Imaging
frompalette(Imaging imOut, Imaging imIn, const char *mode) { frompalette(Imaging imOut, Imaging imIn, const ModeID mode) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
int alpha; int alpha;
int y; int y;
@ -1237,31 +1102,31 @@ frompalette(Imaging imOut, Imaging imIn, const char *mode) {
return (Imaging)ImagingError_ValueError("no palette"); return (Imaging)ImagingError_ValueError("no palette");
} }
alpha = !strcmp(imIn->mode, "PA"); alpha = imIn->mode == IMAGING_MODE_PA;
if (strcmp(mode, "1") == 0) { if (mode == IMAGING_MODE_1) {
convert = alpha ? pa2bit : p2bit; convert = alpha ? pa2bit : p2bit;
} else if (strcmp(mode, "L") == 0) { } else if (mode == IMAGING_MODE_L) {
convert = alpha ? pa2l : p2l; convert = alpha ? pa2l : p2l;
} else if (strcmp(mode, "LA") == 0) { } else if (mode == IMAGING_MODE_LA) {
convert = alpha ? pa2la : p2la; convert = alpha ? pa2la : p2la;
} else if (strcmp(mode, "P") == 0) { } else if (mode == IMAGING_MODE_P) {
convert = pa2p; convert = pa2p;
} else if (strcmp(mode, "PA") == 0) { } else if (mode == IMAGING_MODE_PA) {
convert = p2pa; convert = p2pa;
} else if (strcmp(mode, "I") == 0) { } else if (mode == IMAGING_MODE_I) {
convert = alpha ? pa2i : p2i; convert = alpha ? pa2i : p2i;
} else if (strcmp(mode, "F") == 0) { } else if (mode == IMAGING_MODE_F) {
convert = alpha ? pa2f : p2f; convert = alpha ? pa2f : p2f;
} else if (strcmp(mode, "RGB") == 0) { } else if (mode == IMAGING_MODE_RGB) {
convert = alpha ? pa2rgb : p2rgb; convert = alpha ? pa2rgb : p2rgb;
} else if (strcmp(mode, "RGBA") == 0 || strcmp(mode, "RGBX") == 0) { } else if (mode == IMAGING_MODE_RGBA || mode == IMAGING_MODE_RGBX) {
convert = alpha ? pa2rgba : p2rgba; convert = alpha ? pa2rgba : p2rgba;
} else if (strcmp(mode, "CMYK") == 0) { } else if (mode == IMAGING_MODE_CMYK) {
convert = alpha ? pa2cmyk : p2cmyk; convert = alpha ? pa2cmyk : p2cmyk;
} else if (strcmp(mode, "YCbCr") == 0) { } else if (mode == IMAGING_MODE_YCbCr) {
convert = alpha ? pa2ycbcr : p2ycbcr; convert = alpha ? pa2ycbcr : p2ycbcr;
} else if (strcmp(mode, "HSV") == 0) { } else if (mode == IMAGING_MODE_HSV) {
convert = alpha ? pa2hsv : p2hsv; convert = alpha ? pa2hsv : p2hsv;
} else { } else {
return (Imaging)ImagingError_ValueError("conversion not supported"); return (Imaging)ImagingError_ValueError("conversion not supported");
@ -1271,7 +1136,7 @@ frompalette(Imaging imOut, Imaging imIn, const char *mode) {
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
if (strcmp(mode, "P") == 0 || strcmp(mode, "PA") == 0) { if (mode == IMAGING_MODE_P || mode == IMAGING_MODE_PA) {
ImagingPaletteDelete(imOut->palette); ImagingPaletteDelete(imOut->palette);
imOut->palette = ImagingPaletteDuplicate(imIn->palette); imOut->palette = ImagingPaletteDuplicate(imIn->palette);
} }
@ -1295,24 +1160,26 @@ frompalette(Imaging imOut, Imaging imIn, const char *mode) {
#endif #endif
static Imaging static Imaging
topalette( topalette(
Imaging imOut, Imaging imIn, const char *mode, ImagingPalette inpalette, int dither Imaging imOut, Imaging imIn, const ModeID mode, ImagingPalette inpalette, int dither
) { ) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
int alpha; int alpha;
int x, y; int x, y;
ImagingPalette palette = inpalette; ImagingPalette palette = inpalette;
/* Map L or RGB/RGBX/RGBA to palette image */ /* Map L or RGB/RGBX/RGBA/RGBa to palette image */
if (strcmp(imIn->mode, "L") != 0 && strncmp(imIn->mode, "RGB", 3) != 0) { if (imIn->mode != IMAGING_MODE_L && imIn->mode != IMAGING_MODE_RGB &&
imIn->mode != IMAGING_MODE_RGBX && imIn->mode != IMAGING_MODE_RGBA &&
imIn->mode != IMAGING_MODE_RGBa) {
return (Imaging)ImagingError_ValueError("conversion not supported"); return (Imaging)ImagingError_ValueError("conversion not supported");
} }
alpha = !strcmp(mode, "PA"); alpha = mode == IMAGING_MODE_PA;
if (palette == NULL) { if (palette == NULL) {
/* FIXME: make user configurable */ /* FIXME: make user configurable */
if (imIn->bands == 1) { if (imIn->bands == 1) {
palette = ImagingPaletteNew("RGB"); palette = ImagingPaletteNew(IMAGING_MODE_RGB);
palette->size = 256; palette->size = 256;
int i; int i;
@ -1499,11 +1366,11 @@ tobilevel(Imaging imOut, Imaging imIn) {
int *errors; int *errors;
/* Map L or RGB to dithered 1 image */ /* Map L or RGB to dithered 1 image */
if (strcmp(imIn->mode, "L") != 0 && strcmp(imIn->mode, "RGB") != 0) { if (imIn->mode != IMAGING_MODE_L && imIn->mode != IMAGING_MODE_RGB) {
return (Imaging)ImagingError_ValueError("conversion not supported"); return (Imaging)ImagingError_ValueError("conversion not supported");
} }
imOut = ImagingNew2Dirty("1", imOut, imIn); imOut = ImagingNew2Dirty(IMAGING_MODE_1, imOut, imIn);
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -1585,19 +1452,152 @@ tobilevel(Imaging imOut, Imaging imIn) {
#pragma optimize("", on) #pragma optimize("", on)
#endif #endif
/* ------------------- */
/* Conversion handlers */
/* ------------------- */
static struct {
const ModeID from;
const ModeID to;
ImagingShuffler convert;
} converters[] = {
{IMAGING_MODE_1, IMAGING_MODE_L, bit2l},
{IMAGING_MODE_1, IMAGING_MODE_I, bit2i},
{IMAGING_MODE_1, IMAGING_MODE_F, bit2f},
{IMAGING_MODE_1, IMAGING_MODE_RGB, bit2rgb},
{IMAGING_MODE_1, IMAGING_MODE_RGBA, bit2rgb},
{IMAGING_MODE_1, IMAGING_MODE_RGBX, bit2rgb},
{IMAGING_MODE_1, IMAGING_MODE_CMYK, bit2cmyk},
{IMAGING_MODE_1, IMAGING_MODE_YCbCr, bit2ycbcr},
{IMAGING_MODE_1, IMAGING_MODE_HSV, bit2hsv},
{IMAGING_MODE_L, IMAGING_MODE_1, l2bit},
{IMAGING_MODE_L, IMAGING_MODE_LA, l2la},
{IMAGING_MODE_L, IMAGING_MODE_I, l2i},
{IMAGING_MODE_L, IMAGING_MODE_F, l2f},
{IMAGING_MODE_L, IMAGING_MODE_RGB, l2rgb},
{IMAGING_MODE_L, IMAGING_MODE_RGBA, l2rgb},
{IMAGING_MODE_L, IMAGING_MODE_RGBX, l2rgb},
{IMAGING_MODE_L, IMAGING_MODE_CMYK, l2cmyk},
{IMAGING_MODE_L, IMAGING_MODE_YCbCr, l2ycbcr},
{IMAGING_MODE_L, IMAGING_MODE_HSV, l2hsv},
{IMAGING_MODE_LA, IMAGING_MODE_L, la2l},
{IMAGING_MODE_LA, IMAGING_MODE_La, lA2la},
{IMAGING_MODE_LA, IMAGING_MODE_RGB, la2rgb},
{IMAGING_MODE_LA, IMAGING_MODE_RGBA, la2rgb},
{IMAGING_MODE_LA, IMAGING_MODE_RGBX, la2rgb},
{IMAGING_MODE_LA, IMAGING_MODE_CMYK, la2cmyk},
{IMAGING_MODE_LA, IMAGING_MODE_YCbCr, la2ycbcr},
{IMAGING_MODE_LA, IMAGING_MODE_HSV, la2hsv},
{IMAGING_MODE_La, IMAGING_MODE_LA, la2lA},
{IMAGING_MODE_I, IMAGING_MODE_L, i2l},
{IMAGING_MODE_I, IMAGING_MODE_F, i2f},
{IMAGING_MODE_I, IMAGING_MODE_RGB, i2rgb},
{IMAGING_MODE_I, IMAGING_MODE_RGBA, i2rgb},
{IMAGING_MODE_I, IMAGING_MODE_RGBX, i2rgb},
{IMAGING_MODE_I, IMAGING_MODE_HSV, i2hsv},
{IMAGING_MODE_F, IMAGING_MODE_L, f2l},
{IMAGING_MODE_F, IMAGING_MODE_I, f2i},
{IMAGING_MODE_RGB, IMAGING_MODE_1, rgb2bit},
{IMAGING_MODE_RGB, IMAGING_MODE_L, rgb2l},
{IMAGING_MODE_RGB, IMAGING_MODE_LA, rgb2la},
{IMAGING_MODE_RGB, IMAGING_MODE_La, rgb2la},
{IMAGING_MODE_RGB, IMAGING_MODE_I, rgb2i},
{IMAGING_MODE_RGB, IMAGING_MODE_I_16, rgb2i16l},
{IMAGING_MODE_RGB, IMAGING_MODE_I_16L, rgb2i16l},
{IMAGING_MODE_RGB, IMAGING_MODE_I_16B, rgb2i16b},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_RGB, IMAGING_MODE_I_16N, rgb2i16b},
#else
{IMAGING_MODE_RGB, IMAGING_MODE_I_16N, rgb2i16l},
#endif
{IMAGING_MODE_RGB, IMAGING_MODE_F, rgb2f},
{IMAGING_MODE_RGB, IMAGING_MODE_RGBA, rgb2rgba},
{IMAGING_MODE_RGB, IMAGING_MODE_RGBa, rgb2rgba},
{IMAGING_MODE_RGB, IMAGING_MODE_RGBX, rgb2rgba},
{IMAGING_MODE_RGB, IMAGING_MODE_CMYK, rgb2cmyk},
{IMAGING_MODE_RGB, IMAGING_MODE_YCbCr, ImagingConvertRGB2YCbCr},
{IMAGING_MODE_RGB, IMAGING_MODE_HSV, rgb2hsv},
{IMAGING_MODE_RGBA, IMAGING_MODE_1, rgb2bit},
{IMAGING_MODE_RGBA, IMAGING_MODE_L, rgb2l},
{IMAGING_MODE_RGBA, IMAGING_MODE_LA, rgba2la},
{IMAGING_MODE_RGBA, IMAGING_MODE_I, rgb2i},
{IMAGING_MODE_RGBA, IMAGING_MODE_F, rgb2f},
{IMAGING_MODE_RGBA, IMAGING_MODE_RGB, rgba2rgb},
{IMAGING_MODE_RGBA, IMAGING_MODE_RGBa, rgbA2rgba},
{IMAGING_MODE_RGBA, IMAGING_MODE_RGBX, rgb2rgba},
{IMAGING_MODE_RGBA, IMAGING_MODE_CMYK, rgb2cmyk},
{IMAGING_MODE_RGBA, IMAGING_MODE_YCbCr, ImagingConvertRGB2YCbCr},
{IMAGING_MODE_RGBA, IMAGING_MODE_HSV, rgb2hsv},
{IMAGING_MODE_RGBa, IMAGING_MODE_RGBA, rgba2rgbA},
{IMAGING_MODE_RGBa, IMAGING_MODE_RGB, rgba2rgb_},
{IMAGING_MODE_RGBX, IMAGING_MODE_1, rgb2bit},
{IMAGING_MODE_RGBX, IMAGING_MODE_L, rgb2l},
{IMAGING_MODE_RGBX, IMAGING_MODE_LA, rgb2la},
{IMAGING_MODE_RGBX, IMAGING_MODE_I, rgb2i},
{IMAGING_MODE_RGBX, IMAGING_MODE_F, rgb2f},
{IMAGING_MODE_RGBX, IMAGING_MODE_RGB, rgba2rgb},
{IMAGING_MODE_RGBX, IMAGING_MODE_CMYK, rgb2cmyk},
{IMAGING_MODE_RGBX, IMAGING_MODE_YCbCr, ImagingConvertRGB2YCbCr},
{IMAGING_MODE_RGBX, IMAGING_MODE_HSV, rgb2hsv},
{IMAGING_MODE_CMYK, IMAGING_MODE_RGB, cmyk2rgb},
{IMAGING_MODE_CMYK, IMAGING_MODE_RGBA, cmyk2rgb},
{IMAGING_MODE_CMYK, IMAGING_MODE_RGBX, cmyk2rgb},
{IMAGING_MODE_CMYK, IMAGING_MODE_HSV, cmyk2hsv},
{IMAGING_MODE_YCbCr, IMAGING_MODE_L, ycbcr2l},
{IMAGING_MODE_YCbCr, IMAGING_MODE_LA, ycbcr2la},
{IMAGING_MODE_YCbCr, IMAGING_MODE_RGB, ImagingConvertYCbCr2RGB},
{IMAGING_MODE_HSV, IMAGING_MODE_RGB, hsv2rgb},
{IMAGING_MODE_I, IMAGING_MODE_I_16, I_I16L},
{IMAGING_MODE_I_16, IMAGING_MODE_I, I16L_I},
{IMAGING_MODE_I_16, IMAGING_MODE_RGB, I16_RGB},
{IMAGING_MODE_L, IMAGING_MODE_I_16, L_I16L},
{IMAGING_MODE_I_16, IMAGING_MODE_L, I16L_L},
{IMAGING_MODE_I, IMAGING_MODE_I_16L, I_I16L},
{IMAGING_MODE_I_16L, IMAGING_MODE_I, I16L_I},
{IMAGING_MODE_I, IMAGING_MODE_I_16B, I_I16B},
{IMAGING_MODE_I_16B, IMAGING_MODE_I, I16B_I},
{IMAGING_MODE_L, IMAGING_MODE_I_16L, L_I16L},
{IMAGING_MODE_I_16L, IMAGING_MODE_L, I16L_L},
{IMAGING_MODE_L, IMAGING_MODE_I_16B, L_I16B},
{IMAGING_MODE_I_16B, IMAGING_MODE_L, I16B_L},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_L, IMAGING_MODE_I_16N, L_I16B},
{IMAGING_MODE_I_16N, IMAGING_MODE_L, I16B_L},
#else
{IMAGING_MODE_L, IMAGING_MODE_I_16N, L_I16L},
{IMAGING_MODE_I_16N, IMAGING_MODE_L, I16L_L},
#endif
{IMAGING_MODE_I_16, IMAGING_MODE_F, I16L_F},
{IMAGING_MODE_I_16L, IMAGING_MODE_F, I16L_F},
{IMAGING_MODE_I_16B, IMAGING_MODE_F, I16B_F}
};
static Imaging static Imaging
convert( convert(Imaging imOut, Imaging imIn, ModeID mode, ImagingPalette palette, int dither) {
Imaging imOut, Imaging imIn, const char *mode, ImagingPalette palette, int dither
) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
ImagingShuffler convert; ImagingShuffler convert;
int y;
if (!imIn) { if (!imIn) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (!mode) { if (mode == IMAGING_MODE_UNKNOWN) {
/* Map palette image to full depth */ /* Map palette image to full depth */
if (!imIn->palette) { if (!imIn->palette) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
@ -1605,33 +1605,31 @@ convert(
mode = imIn->palette->mode; mode = imIn->palette->mode;
} else { } else {
/* Same mode? */ /* Same mode? */
if (!strcmp(imIn->mode, mode)) { if (imIn->mode == mode) {
return ImagingCopy2(imOut, imIn); return ImagingCopy2(imOut, imIn);
} }
} }
/* test for special conversions */ /* test for special conversions */
if (strcmp(imIn->mode, "P") == 0 || strcmp(imIn->mode, "PA") == 0) { if (imIn->mode == IMAGING_MODE_P || imIn->mode == IMAGING_MODE_PA) {
return frompalette(imOut, imIn, mode); return frompalette(imOut, imIn, mode);
} }
if (strcmp(mode, "P") == 0 || strcmp(mode, "PA") == 0) { if (mode == IMAGING_MODE_P || mode == IMAGING_MODE_PA) {
return topalette(imOut, imIn, mode, palette, dither); return topalette(imOut, imIn, mode, palette, dither);
} }
if (dither && strcmp(mode, "1") == 0) { if (dither && mode == IMAGING_MODE_1) {
return tobilevel(imOut, imIn); return tobilevel(imOut, imIn);
} }
/* standard conversion machinery */ /* standard conversion machinery */
convert = NULL; convert = NULL;
for (size_t i = 0; i < sizeof(converters) / sizeof(*converters); i++) {
for (y = 0; converters[y].from; y++) { if (imIn->mode == converters[i].from && mode == converters[i].to) {
if (!strcmp(imIn->mode, converters[y].from) && convert = converters[i].convert;
!strcmp(mode, converters[y].to)) {
convert = converters[y].convert;
break; break;
} }
} }
@ -1642,7 +1640,11 @@ convert(
#else #else
static char buf[100]; static char buf[100];
snprintf( snprintf(
buf, 100, "conversion from %.10s to %.10s not supported", imIn->mode, mode buf,
100,
"conversion from %.10s to %.10s not supported",
getModeData(imIn->mode)->name,
getModeData(mode)->name
); );
return (Imaging)ImagingError_ValueError(buf); return (Imaging)ImagingError_ValueError(buf);
#endif #endif
@ -1654,7 +1656,7 @@ convert(
} }
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
for (y = 0; y < imIn->ysize; y++) { for (int y = 0; y < imIn->ysize; y++) {
(*convert)((UINT8 *)imOut->image[y], (UINT8 *)imIn->image[y], imIn->xsize); (*convert)((UINT8 *)imOut->image[y], (UINT8 *)imIn->image[y], imIn->xsize);
} }
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
@ -1663,7 +1665,7 @@ convert(
} }
Imaging Imaging
ImagingConvert(Imaging imIn, const char *mode, ImagingPalette palette, int dither) { ImagingConvert(Imaging imIn, const ModeID mode, ImagingPalette palette, int dither) {
return convert(NULL, imIn, mode, palette, dither); return convert(NULL, imIn, mode, palette, dither);
} }
@ -1673,7 +1675,7 @@ ImagingConvert2(Imaging imOut, Imaging imIn) {
} }
Imaging Imaging
ImagingConvertTransparent(Imaging imIn, const char *mode, int r, int g, int b) { ImagingConvertTransparent(Imaging imIn, const ModeID mode, int r, int g, int b) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
ImagingShuffler convert; ImagingShuffler convert;
Imaging imOut = NULL; Imaging imOut = NULL;
@ -1687,27 +1689,27 @@ ImagingConvertTransparent(Imaging imIn, const char *mode, int r, int g, int b) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (strcmp(imIn->mode, "RGB") == 0 && if (imIn->mode == IMAGING_MODE_RGB &&
(strcmp(mode, "RGBA") == 0 || strcmp(mode, "RGBa") == 0)) { (mode == IMAGING_MODE_RGBA || mode == IMAGING_MODE_RGBa)) {
convert = rgb2rgba; convert = rgb2rgba;
if (strcmp(mode, "RGBa") == 0) { if (mode == IMAGING_MODE_RGBa) {
premultiplied = 1; premultiplied = 1;
} }
} else if (strcmp(imIn->mode, "RGB") == 0 && } else if (imIn->mode == IMAGING_MODE_RGB &&
(strcmp(mode, "LA") == 0 || strcmp(mode, "La") == 0)) { (mode == IMAGING_MODE_LA || mode == IMAGING_MODE_La)) {
convert = rgb2la; convert = rgb2la;
source_transparency = 1; source_transparency = 1;
if (strcmp(mode, "La") == 0) { if (mode == IMAGING_MODE_La) {
premultiplied = 1; premultiplied = 1;
} }
} else if ((strcmp(imIn->mode, "1") == 0 || strcmp(imIn->mode, "I") == 0 || } else if ((imIn->mode == IMAGING_MODE_1 || imIn->mode == IMAGING_MODE_I ||
strcmp(imIn->mode, "I;16") == 0 || strcmp(imIn->mode, "L") == 0) && imIn->mode == IMAGING_MODE_I_16 || imIn->mode == IMAGING_MODE_L) &&
(strcmp(mode, "RGBA") == 0 || strcmp(mode, "LA") == 0)) { (mode == IMAGING_MODE_RGBA || mode == IMAGING_MODE_LA)) {
if (strcmp(imIn->mode, "1") == 0) { if (imIn->mode == IMAGING_MODE_1) {
convert = bit2rgb; convert = bit2rgb;
} else if (strcmp(imIn->mode, "I") == 0) { } else if (imIn->mode == IMAGING_MODE_I) {
convert = i2rgb; convert = i2rgb;
} else if (strcmp(imIn->mode, "I;16") == 0) { } else if (imIn->mode == IMAGING_MODE_I_16) {
convert = I16_RGB; convert = I16_RGB;
} else { } else {
convert = l2rgb; convert = l2rgb;
@ -1719,8 +1721,8 @@ ImagingConvertTransparent(Imaging imIn, const char *mode, int r, int g, int b) {
buf, buf,
100, 100,
"conversion from %.10s to %.10s not supported in convert_transparent", "conversion from %.10s to %.10s not supported in convert_transparent",
imIn->mode, getModeData(imIn->mode)->name,
mode getModeData(mode)->name
); );
return (Imaging)ImagingError_ValueError(buf); return (Imaging)ImagingError_ValueError(buf);
} }
@ -1743,15 +1745,15 @@ ImagingConvertTransparent(Imaging imIn, const char *mode, int r, int g, int b) {
} }
Imaging Imaging
ImagingConvertInPlace(Imaging imIn, const char *mode) { ImagingConvertInPlace(Imaging imIn, const ModeID mode) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
ImagingShuffler convert; ImagingShuffler convert;
int y; int y;
/* limited support for inplace conversion */ /* limited support for inplace conversion */
if (strcmp(imIn->mode, "L") == 0 && strcmp(mode, "1") == 0) { if (imIn->mode == IMAGING_MODE_L && mode == IMAGING_MODE_1) {
convert = l2bit; convert = l2bit;
} else if (strcmp(imIn->mode, "1") == 0 && strcmp(mode, "L") == 0) { } else if (imIn->mode == IMAGING_MODE_1 && mode == IMAGING_MODE_L) {
convert = bit2l; convert = bit2l;
} else { } else {
return ImagingError_ModeError(); return ImagingError_ModeError();

34
src/libImaging/Dib.c
View File

@ -25,20 +25,17 @@
#include "ImDib.h" #include "ImDib.h"
char * ModeID
ImagingGetModeDIB(int size_out[2]) { ImagingGetModeDIB(int size_out[2]) {
/* Get device characteristics */ /* Get device characteristics */
HDC dc; const HDC dc = CreateCompatibleDC(NULL);
char *mode;
dc = CreateCompatibleDC(NULL); ModeID mode = IMAGING_MODE_P;
mode = "P";
if (!(GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)) { if (!(GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)) {
mode = "RGB"; mode = IMAGING_MODE_RGB;
if (GetDeviceCaps(dc, BITSPIXEL) == 1) { if (GetDeviceCaps(dc, BITSPIXEL) == 1) {
mode = "1"; mode = IMAGING_MODE_1;
} }
} }
@ -53,7 +50,7 @@ ImagingGetModeDIB(int size_out[2]) {
} }
ImagingDIB ImagingDIB
ImagingNewDIB(const char *mode, int xsize, int ysize) { ImagingNewDIB(const ModeID mode, int xsize, int ysize) {
/* Create a Windows bitmap */ /* Create a Windows bitmap */
ImagingDIB dib; ImagingDIB dib;
@ -61,10 +58,12 @@ ImagingNewDIB(const char *mode, int xsize, int ysize) {
int i; int i;
/* Check mode */ /* Check mode */
if (strcmp(mode, "1") != 0 && strcmp(mode, "L") != 0 && strcmp(mode, "RGB") != 0) { if (mode != IMAGING_MODE_1 && mode != IMAGING_MODE_L && mode != IMAGING_MODE_RGB) {
return (ImagingDIB)ImagingError_ModeError(); return (ImagingDIB)ImagingError_ModeError();
} }
const int pixelsize = mode == IMAGING_MODE_RGB ? 3 : 1;
/* Create DIB context and info header */ /* Create DIB context and info header */
/* malloc check ok, small constant allocation */ /* malloc check ok, small constant allocation */
dib = (ImagingDIB)malloc(sizeof(*dib)); dib = (ImagingDIB)malloc(sizeof(*dib));
@ -83,7 +82,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize) {
dib->info->bmiHeader.biWidth = xsize; dib->info->bmiHeader.biWidth = xsize;
dib->info->bmiHeader.biHeight = ysize; dib->info->bmiHeader.biHeight = ysize;
dib->info->bmiHeader.biPlanes = 1; dib->info->bmiHeader.biPlanes = 1;
dib->info->bmiHeader.biBitCount = strlen(mode) * 8; dib->info->bmiHeader.biBitCount = pixelsize * 8;
dib->info->bmiHeader.biCompression = BI_RGB; dib->info->bmiHeader.biCompression = BI_RGB;
/* Create DIB */ /* Create DIB */
@ -103,12 +102,12 @@ ImagingNewDIB(const char *mode, int xsize, int ysize) {
return (ImagingDIB)ImagingError_MemoryError(); return (ImagingDIB)ImagingError_MemoryError();
} }
strcpy(dib->mode, mode); dib->mode = mode;
dib->xsize = xsize; dib->xsize = xsize;
dib->ysize = ysize; dib->ysize = ysize;
dib->pixelsize = strlen(mode); dib->pixelsize = pixelsize;
dib->linesize = (xsize * dib->pixelsize + 3) & -4; dib->linesize = (xsize * pixelsize + 3) & -4;
if (dib->pixelsize == 1) { if (dib->pixelsize == 1) {
dib->pack = dib->unpack = (ImagingShuffler)memcpy; dib->pack = dib->unpack = (ImagingShuffler)memcpy;
@ -132,7 +131,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize) {
} }
/* Create an associated palette (for 8-bit displays only) */ /* Create an associated palette (for 8-bit displays only) */
if (strcmp(ImagingGetModeDIB(NULL), "P") == 0) { if (ImagingGetModeDIB(NULL) == IMAGING_MODE_P) {
char palbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)]; char palbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
LPLOGPALETTE pal = (LPLOGPALETTE)palbuf; LPLOGPALETTE pal = (LPLOGPALETTE)palbuf;
int i, r, g, b; int i, r, g, b;
@ -142,7 +141,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize) {
pal->palNumEntries = 256; pal->palNumEntries = 256;
GetSystemPaletteEntries(dib->dc, 0, 256, pal->palPalEntry); GetSystemPaletteEntries(dib->dc, 0, 256, pal->palPalEntry);
if (strcmp(mode, "L") == 0) { if (mode == IMAGING_MODE_L) {
/* Grayscale DIB. Fill all 236 slots with a grayscale ramp /* Grayscale DIB. Fill all 236 slots with a grayscale ramp
* (this is usually overkill on Windows since VGA only offers * (this is usually overkill on Windows since VGA only offers
* 6 bits grayscale resolution). Ignore the slots already * 6 bits grayscale resolution). Ignore the slots already
@ -156,8 +155,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize) {
} }
dib->palette = CreatePalette(pal); dib->palette = CreatePalette(pal);
} else if (mode == IMAGING_MODE_RGB) {
} else if (strcmp(mode, "RGB") == 0) {
#ifdef CUBE216 #ifdef CUBE216
/* Colour DIB. Create a 6x6x6 colour cube (216 entries) and /* Colour DIB. Create a 6x6x6 colour cube (216 entries) and

10
src/libImaging/Draw.c
View File

@ -68,7 +68,7 @@ typedef void (*hline_handler)(Imaging, int, int, int, int, Imaging);
static inline void static inline void
point8(Imaging im, int x, int y, int ink) { point8(Imaging im, int x, int y, int ink) {
if (x >= 0 && x < im->xsize && y >= 0 && y < im->ysize) { if (x >= 0 && x < im->xsize && y >= 0 && y < im->ysize) {
if (strncmp(im->mode, "I;16", 4) == 0) { if (isModeI16(im->mode)) {
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
im->image8[y][x * 2] = (UINT8)(ink >> 8); im->image8[y][x * 2] = (UINT8)(ink >> 8);
im->image8[y][x * 2 + 1] = (UINT8)ink; im->image8[y][x * 2 + 1] = (UINT8)ink;
@ -117,13 +117,13 @@ hline8(Imaging im, int x0, int y0, int x1, int ink, Imaging mask) {
} }
if (x0 <= x1) { if (x0 <= x1) {
int bigendian = -1; int bigendian = -1;
if (strncmp(im->mode, "I;16", 4) == 0) { if (isModeI16(im->mode)) {
bigendian = bigendian =
( (
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
strcmp(im->mode, "I;16") == 0 || strcmp(im->mode, "I;16L") == 0 im->mode == IMAGING_MODE_I_16 || im->mode == IMAGING_MODE_I_16L
#else #else
strcmp(im->mode, "I;16B") == 0 im->mode == IMAGING_MODE_I_16B
#endif #endif
) )
? 1 ? 1
@ -675,7 +675,7 @@ DRAW draw32rgba = {point32rgba, hline32rgba, line32rgba};
#define DRAWINIT() \ #define DRAWINIT() \
if (im->image8) { \ if (im->image8) { \
draw = &draw8; \ draw = &draw8; \
if (strncmp(im->mode, "I;16", 4) == 0) { \ if (isModeI16(im->mode)) { \
ink = INK16(ink_); \ ink = INK16(ink_); \
} else { \ } else { \
ink = INK8(ink_); \ ink = INK8(ink_); \

4
src/libImaging/Effects.c
View File

@ -36,7 +36,7 @@ ImagingEffectMandelbrot(int xsize, int ysize, double extent[4], int quality) {
return (Imaging)ImagingError_ValueError(NULL); return (Imaging)ImagingError_ValueError(NULL);
} }
im = ImagingNewDirty("L", xsize, ysize); im = ImagingNewDirty(IMAGING_MODE_L, xsize, ysize);
if (!im) { if (!im) {
return NULL; return NULL;
} }
@ -80,7 +80,7 @@ ImagingEffectNoise(int xsize, int ysize, float sigma) {
int nextok; int nextok;
double this, next; double this, next;
imOut = ImagingNewDirty("L", xsize, ysize); imOut = ImagingNewDirty(IMAGING_MODE_L, xsize, ysize);
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }

7
src/libImaging/File.c
View File

@ -23,14 +23,13 @@ int
ImagingSaveRaw(Imaging im, FILE *fp) { ImagingSaveRaw(Imaging im, FILE *fp) {
int x, y, i; int x, y, i;
if (strcmp(im->mode, "1") == 0 || strcmp(im->mode, "L") == 0) { if (im->mode == IMAGING_MODE_1 || im->mode == IMAGING_MODE_L) {
/* @PIL227: FIXME: for mode "1", map != 0 to 255 */ /* @PIL227: FIXME: for mode "1", map != 0 to 255 */
/* PGM "L" */ /* PGM "L" */
for (y = 0; y < im->ysize; y++) { for (y = 0; y < im->ysize; y++) {
fwrite(im->image[y], 1, im->xsize, fp); fwrite(im->image[y], 1, im->xsize, fp);
} }
} else { } else {
/* PPM "RGB" or other internal format */ /* PPM "RGB" or other internal format */
for (y = 0; y < im->ysize; y++) { for (y = 0; y < im->ysize; y++) {
@ -58,10 +57,10 @@ ImagingSavePPM(Imaging im, const char *outfile) {
return 0; return 0;
} }
if (strcmp(im->mode, "1") == 0 || strcmp(im->mode, "L") == 0) { if (im->mode == IMAGING_MODE_1 || im->mode == IMAGING_MODE_L) {
/* Write "PGM" */ /* Write "PGM" */
fprintf(fp, "P5\n%d %d\n255\n", im->xsize, im->ysize); fprintf(fp, "P5\n%d %d\n255\n", im->xsize, im->ysize);
} else if (strcmp(im->mode, "RGB") == 0) { } else if (im->mode == IMAGING_MODE_RGB) {
/* Write "PPM" */ /* Write "PPM" */
fprintf(fp, "P6\n%d %d\n255\n", im->xsize, im->ysize); fprintf(fp, "P6\n%d %d\n255\n", im->xsize, im->ysize);
} else { } else {

10
src/libImaging/Fill.c
View File

@ -68,11 +68,12 @@ ImagingFill(Imaging im, const void *colour) {
} }
Imaging Imaging
ImagingFillLinearGradient(const char *mode) { ImagingFillLinearGradient(const ModeID mode) {
Imaging im; Imaging im;
int y; int y;
if (strlen(mode) != 1) { if (mode != IMAGING_MODE_1 && mode != IMAGING_MODE_F && mode != IMAGING_MODE_I &&
mode != IMAGING_MODE_L && mode != IMAGING_MODE_P) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
@ -102,12 +103,13 @@ ImagingFillLinearGradient(const char *mode) {
} }
Imaging Imaging
ImagingFillRadialGradient(const char *mode) { ImagingFillRadialGradient(const ModeID mode) {
Imaging im; Imaging im;
int x, y; int x, y;
int d; int d;
if (strlen(mode) != 1) { if (mode != IMAGING_MODE_1 && mode != IMAGING_MODE_F && mode != IMAGING_MODE_I &&
mode != IMAGING_MODE_L && mode != IMAGING_MODE_P) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }

8
src/libImaging/Filter.c
View File

@ -156,9 +156,9 @@ ImagingFilter3x3(Imaging imOut, Imaging im, const float *kernel, float offset) {
int bigendian = 0; int bigendian = 0;
if (im->type == IMAGING_TYPE_SPECIAL) { if (im->type == IMAGING_TYPE_SPECIAL) {
if ( if (
strcmp(im->mode, "I;16B") == 0 im->mode == IMAGING_MODE_I_16B
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
|| strcmp(im->mode, "I;16N") == 0 || im->mode == IMAGING_MODE_I_16N
#endif #endif
) { ) {
bigendian = 1; bigendian = 1;
@ -310,9 +310,9 @@ ImagingFilter5x5(Imaging imOut, Imaging im, const float *kernel, float offset) {
int bigendian = 0; int bigendian = 0;
if (im->type == IMAGING_TYPE_SPECIAL) { if (im->type == IMAGING_TYPE_SPECIAL) {
if ( if (
strcmp(im->mode, "I;16B") == 0 im->mode == IMAGING_MODE_I_16B
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
|| strcmp(im->mode, "I;16N") == 0 || im->mode == IMAGING_MODE_I_16N
#endif #endif
) { ) {
bigendian = 1; bigendian = 1;

32
src/libImaging/Geometry.c
View File

@ -19,7 +19,7 @@ ImagingFlipLeftRight(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
int x, y, xr; int x, y, xr;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->xsize != imOut->xsize || imIn->ysize != imOut->ysize) { if (imIn->xsize != imOut->xsize || imIn->ysize != imOut->ysize) {
@ -41,7 +41,7 @@ ImagingFlipLeftRight(Imaging imOut, Imaging imIn) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
if (imIn->image8) { if (imIn->image8) {
if (strncmp(imIn->mode, "I;16", 4) == 0) { if (isModeI16(imIn->mode)) {
FLIP_LEFT_RIGHT(UINT16, image8) FLIP_LEFT_RIGHT(UINT16, image8)
} else { } else {
FLIP_LEFT_RIGHT(UINT8, image8) FLIP_LEFT_RIGHT(UINT8, image8)
@ -62,7 +62,7 @@ ImagingFlipTopBottom(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
int y, yr; int y, yr;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->xsize != imOut->xsize || imIn->ysize != imOut->ysize) { if (imIn->xsize != imOut->xsize || imIn->ysize != imOut->ysize) {
@ -89,7 +89,7 @@ ImagingRotate90(Imaging imOut, Imaging imIn) {
int x, y, xx, yy, xr, xxsize, yysize; int x, y, xx, yy, xr, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize; int xxx, yyy, xxxsize, yyysize;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) { if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) {
@ -127,7 +127,7 @@ ImagingRotate90(Imaging imOut, Imaging imIn) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
if (imIn->image8) { if (imIn->image8) {
if (strncmp(imIn->mode, "I;16", 4) == 0) { if (isModeI16(imIn->mode)) {
ROTATE_90(UINT16, image8); ROTATE_90(UINT16, image8);
} else { } else {
ROTATE_90(UINT8, image8); ROTATE_90(UINT8, image8);
@ -149,7 +149,7 @@ ImagingTranspose(Imaging imOut, Imaging imIn) {
int x, y, xx, yy, xxsize, yysize; int x, y, xx, yy, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize; int xxx, yyy, xxxsize, yyysize;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) { if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) {
@ -186,7 +186,7 @@ ImagingTranspose(Imaging imOut, Imaging imIn) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
if (imIn->image8) { if (imIn->image8) {
if (strncmp(imIn->mode, "I;16", 4) == 0) { if (isModeI16(imIn->mode)) {
TRANSPOSE(UINT16, image8); TRANSPOSE(UINT16, image8);
} else { } else {
TRANSPOSE(UINT8, image8); TRANSPOSE(UINT8, image8);
@ -208,7 +208,7 @@ ImagingTransverse(Imaging imOut, Imaging imIn) {
int x, y, xr, yr, xx, yy, xxsize, yysize; int x, y, xr, yr, xx, yy, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize; int xxx, yyy, xxxsize, yyysize;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) { if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) {
@ -247,7 +247,7 @@ ImagingTransverse(Imaging imOut, Imaging imIn) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
if (imIn->image8) { if (imIn->image8) {
if (strncmp(imIn->mode, "I;16", 4) == 0) { if (isModeI16(imIn->mode)) {
TRANSVERSE(UINT16, image8); TRANSVERSE(UINT16, image8);
} else { } else {
TRANSVERSE(UINT8, image8); TRANSVERSE(UINT8, image8);
@ -268,7 +268,7 @@ ImagingRotate180(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
int x, y, xr, yr; int x, y, xr, yr;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->xsize != imOut->xsize || imIn->ysize != imOut->ysize) { if (imIn->xsize != imOut->xsize || imIn->ysize != imOut->ysize) {
@ -291,7 +291,7 @@ ImagingRotate180(Imaging imOut, Imaging imIn) {
yr = imIn->ysize - 1; yr = imIn->ysize - 1;
if (imIn->image8) { if (imIn->image8) {
if (strncmp(imIn->mode, "I;16", 4) == 0) { if (isModeI16(imIn->mode)) {
ROTATE_180(UINT16, image8) ROTATE_180(UINT16, image8)
} else { } else {
ROTATE_180(UINT8, image8) ROTATE_180(UINT8, image8)
@ -313,7 +313,7 @@ ImagingRotate270(Imaging imOut, Imaging imIn) {
int x, y, xx, yy, yr, xxsize, yysize; int x, y, xx, yy, yr, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize; int xxx, yyy, xxxsize, yyysize;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) { if (imIn->xsize != imOut->ysize || imIn->ysize != imOut->xsize) {
@ -351,7 +351,7 @@ ImagingRotate270(Imaging imOut, Imaging imIn) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
if (imIn->image8) { if (imIn->image8) {
if (strncmp(imIn->mode, "I;16", 4) == 0) { if (isModeI16(imIn->mode)) {
ROTATE_270(UINT16, image8); ROTATE_270(UINT16, image8);
} else { } else {
ROTATE_270(UINT8, image8); ROTATE_270(UINT8, image8);
@ -791,7 +791,7 @@ ImagingGenericTransform(
char *out; char *out;
double xx, yy; double xx, yy;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
@ -848,7 +848,7 @@ ImagingScaleAffine(
int xmin, xmax; int xmin, xmax;
int *xintab; int *xintab;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
@ -1035,7 +1035,7 @@ ImagingTransformAffine(
double xx, yy; double xx, yy;
double xo, yo; double xo, yo;
if (!imOut || !imIn || strcmp(imIn->mode, imOut->mode) != 0) { if (!imOut || !imIn || imIn->mode != imOut->mode) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }

8
src/libImaging/GetBBox.c
View File

@ -90,9 +90,9 @@ ImagingGetBBox(Imaging im, int bbox[4], int alpha_only) {
if (im->bands == 3) { if (im->bands == 3) {
((UINT8 *)&mask)[3] = 0; ((UINT8 *)&mask)[3] = 0;
} else if (alpha_only && } else if (alpha_only &&
(strcmp(im->mode, "RGBa") == 0 || strcmp(im->mode, "RGBA") == 0 || (im->mode == IMAGING_MODE_RGBa || im->mode == IMAGING_MODE_RGBA ||
strcmp(im->mode, "La") == 0 || strcmp(im->mode, "LA") == 0 || im->mode == IMAGING_MODE_La || im->mode == IMAGING_MODE_LA ||
strcmp(im->mode, "PA") == 0)) { im->mode == IMAGING_MODE_PA)) {
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
mask = 0x000000ff; mask = 0x000000ff;
#else #else
@ -208,7 +208,7 @@ ImagingGetExtrema(Imaging im, void *extrema) {
memcpy(((char *)extrema) + sizeof(fmin), &fmax, sizeof(fmax)); memcpy(((char *)extrema) + sizeof(fmin), &fmax, sizeof(fmax));
break; break;
case IMAGING_TYPE_SPECIAL: case IMAGING_TYPE_SPECIAL:
if (strcmp(im->mode, "I;16") == 0) { if (im->mode == IMAGING_MODE_I_16) {
UINT16 v; UINT16 v;
UINT8 *pixel = *im->image8; UINT8 *pixel = *im->image8;
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN

6
src/libImaging/Histo.c
View File

@ -43,10 +43,10 @@ ImagingHistogramNew(Imaging im) {
if (!h) { if (!h) {
return (ImagingHistogram)ImagingError_MemoryError(); return (ImagingHistogram)ImagingError_MemoryError();
} }
strncpy(h->mode, im->mode, IMAGING_MODE_LENGTH - 1);
h->mode[IMAGING_MODE_LENGTH - 1] = 0;
h->mode = im->mode;
h->bands = im->bands; h->bands = im->bands;
h->histogram = calloc(im->pixelsize, 256 * sizeof(long)); h->histogram = calloc(im->pixelsize, 256 * sizeof(long));
if (!h->histogram) { if (!h->histogram) {
free(h); free(h);
@ -73,7 +73,7 @@ ImagingGetHistogram(Imaging im, Imaging imMask, void *minmax) {
if (im->xsize != imMask->xsize || im->ysize != imMask->ysize) { if (im->xsize != imMask->xsize || im->ysize != imMask->ysize) {
return ImagingError_Mismatch(); return ImagingError_Mismatch();
} }
if (strcmp(imMask->mode, "1") != 0 && strcmp(imMask->mode, "L") != 0) { if (imMask->mode != IMAGING_MODE_1 && imMask->mode != IMAGING_MODE_L) {
return ImagingError_ValueError("bad transparency mask"); return ImagingError_ValueError("bad transparency mask");
} }
} }

6
src/libImaging/ImDib.h
View File

@ -27,7 +27,7 @@ struct ImagingDIBInstance {
UINT8 *bits; UINT8 *bits;
HPALETTE palette; HPALETTE palette;
/* Used by cut and paste */ /* Used by cut and paste */
char mode[4]; ModeID mode;
int xsize, ysize; int xsize, ysize;
int pixelsize; int pixelsize;
int linesize; int linesize;
@ -37,11 +37,11 @@ struct ImagingDIBInstance {
typedef struct ImagingDIBInstance *ImagingDIB; typedef struct ImagingDIBInstance *ImagingDIB;
extern char * extern ModeID
ImagingGetModeDIB(int size_out[2]); ImagingGetModeDIB(int size_out[2]);
extern ImagingDIB extern ImagingDIB
ImagingNewDIB(const char *mode, int xsize, int ysize); ImagingNewDIB(ModeID mode, int xsize, int ysize);
extern void extern void
ImagingDeleteDIB(ImagingDIB im); ImagingDeleteDIB(ImagingDIB im);

51
src/libImaging/Imaging.h
View File

@ -11,6 +11,7 @@
*/ */
#include "ImPlatform.h" #include "ImPlatform.h"
#include "Mode.h"
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
@ -71,9 +72,6 @@ typedef struct ImagingPaletteInstance *ImagingPalette;
#define IMAGING_TYPE_FLOAT32 2 #define IMAGING_TYPE_FLOAT32 2
#define IMAGING_TYPE_SPECIAL 3 /* check mode for details */ #define IMAGING_TYPE_SPECIAL 3 /* check mode for details */
#define IMAGING_MODE_LENGTH \
6 + 1 /* Band names ("1", "L", "P", "RGB", "RGBA", "CMYK", "YCbCr", "BGR;xy") */
typedef struct { typedef struct {
char *ptr; char *ptr;
int size; int size;
@ -81,8 +79,7 @@ typedef struct {
struct ImagingMemoryInstance { struct ImagingMemoryInstance {
/* Format */ /* Format */
char mode[IMAGING_MODE_LENGTH]; /* Band names ("1", "L", "P", "RGB", "RGBA", "CMYK", ModeID mode; /* Image mode (IMAGING_MODE_*) */
"YCbCr", "BGR;xy") */
int type; /* Data type (IMAGING_TYPE_*) */ int type; /* Data type (IMAGING_TYPE_*) */
int depth; /* Depth (ignored in this version) */ int depth; /* Depth (ignored in this version) */
int bands; /* Number of bands (1, 2, 3, or 4) */ int bands; /* Number of bands (1, 2, 3, or 4) */
@ -140,14 +137,14 @@ struct ImagingMemoryInstance {
#define IMAGING_PIXEL_FLOAT32(im, x, y) (((FLOAT32 *)(im)->image32[y])[x]) #define IMAGING_PIXEL_FLOAT32(im, x, y) (((FLOAT32 *)(im)->image32[y])[x])
struct ImagingAccessInstance { struct ImagingAccessInstance {
const char *mode; ModeID mode;
void (*get_pixel)(Imaging im, int x, int y, void *pixel); void (*get_pixel)(Imaging im, int x, int y, void *pixel);
void (*put_pixel)(Imaging im, int x, int y, const void *pixel); void (*put_pixel)(Imaging im, int x, int y, const void *pixel);
}; };
struct ImagingHistogramInstance { struct ImagingHistogramInstance {
/* Format */ /* Format */
char mode[IMAGING_MODE_LENGTH]; /* Band names (of corresponding source image) */ ModeID mode; /* Mode ID of corresponding source image */
int bands; /* Number of bands (1, 2, 3, or 4) */ int bands; /* Number of bands (1, 2, 3, or 4) */
/* Data */ /* Data */
@ -156,7 +153,7 @@ struct ImagingHistogramInstance {
struct ImagingPaletteInstance { struct ImagingPaletteInstance {
/* Format */ /* Format */
char mode[IMAGING_MODE_LENGTH]; /* Band names */ ModeID mode;
/* Data */ /* Data */
int size; int size;
@ -196,20 +193,20 @@ extern void
ImagingMemorySetBlockAllocator(ImagingMemoryArena arena, int use_block_allocator); ImagingMemorySetBlockAllocator(ImagingMemoryArena arena, int use_block_allocator);
extern Imaging extern Imaging
ImagingNew(const char *mode, int xsize, int ysize); ImagingNew(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNewDirty(const char *mode, int xsize, int ysize); ImagingNewDirty(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn); ImagingNew2Dirty(ModeID mode, Imaging imOut, Imaging imIn);
extern void extern void
ImagingDelete(Imaging im); ImagingDelete(Imaging im);
extern Imaging extern Imaging
ImagingNewBlock(const char *mode, int xsize, int ysize); ImagingNewBlock(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNewArrow( ImagingNewArrow(
const char *mode, const ModeID mode,
int xsize, int xsize,
int ysize, int ysize,
PyObject *schema_capsule, PyObject *schema_capsule,
@ -217,9 +214,9 @@ ImagingNewArrow(
); );
extern Imaging extern Imaging
ImagingNewPrologue(const char *mode, int xsize, int ysize); ImagingNewPrologue(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int structure_size); ImagingNewPrologueSubtype(ModeID mode, int xsize, int ysize, int structure_size);
extern void extern void
ImagingCopyPalette(Imaging destination, Imaging source); ImagingCopyPalette(Imaging destination, Imaging source);
@ -227,8 +224,6 @@ ImagingCopyPalette(Imaging destination, Imaging source);
extern void extern void
ImagingHistogramDelete(ImagingHistogram histogram); ImagingHistogramDelete(ImagingHistogram histogram);
extern void
ImagingAccessInit(void);
extern ImagingAccess extern ImagingAccess
ImagingAccessNew(Imaging im); ImagingAccessNew(Imaging im);
extern void extern void
@ -236,7 +231,7 @@ _ImagingAccessDelete(Imaging im, ImagingAccess access);
#define ImagingAccessDelete(im, access) /* nop, for now */ #define ImagingAccessDelete(im, access) /* nop, for now */
extern ImagingPalette extern ImagingPalette
ImagingPaletteNew(const char *mode); ImagingPaletteNew(ModeID mode);
extern ImagingPalette extern ImagingPalette
ImagingPaletteNewBrowser(void); ImagingPaletteNewBrowser(void);
extern ImagingPalette extern ImagingPalette
@ -308,13 +303,13 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha);
extern Imaging extern Imaging
ImagingCopy(Imaging im); ImagingCopy(Imaging im);
extern Imaging extern Imaging
ImagingConvert(Imaging im, const char *mode, ImagingPalette palette, int dither); ImagingConvert(Imaging im, ModeID mode, ImagingPalette palette, int dither);
extern Imaging extern Imaging
ImagingConvertInPlace(Imaging im, const char *mode); ImagingConvertInPlace(Imaging im, ModeID mode);
extern Imaging extern Imaging
ImagingConvertMatrix(Imaging im, const char *mode, float m[]); ImagingConvertMatrix(Imaging im, ModeID mode, float m[]);
extern Imaging extern Imaging
ImagingConvertTransparent(Imaging im, const char *mode, int r, int g, int b); ImagingConvertTransparent(Imaging im, ModeID mode, int r, int g, int b);
extern Imaging extern Imaging
ImagingCrop(Imaging im, int x0, int y0, int x1, int y1); ImagingCrop(Imaging im, int x0, int y0, int x1, int y1);
extern Imaging extern Imaging
@ -328,9 +323,9 @@ ImagingFill2(
extern Imaging extern Imaging
ImagingFillBand(Imaging im, int band, int color); ImagingFillBand(Imaging im, int band, int color);
extern Imaging extern Imaging
ImagingFillLinearGradient(const char *mode); ImagingFillLinearGradient(ModeID mode);
extern Imaging extern Imaging
ImagingFillRadialGradient(const char *mode); ImagingFillRadialGradient(ModeID mode);
extern Imaging extern Imaging
ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32 *kernel, FLOAT32 offset); ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32 *kernel, FLOAT32 offset);
extern Imaging extern Imaging
@ -344,7 +339,7 @@ ImagingGaussianBlur(
extern Imaging extern Imaging
ImagingGetBand(Imaging im, int band); ImagingGetBand(Imaging im, int band);
extern Imaging extern Imaging
ImagingMerge(const char *mode, Imaging bands[4]); ImagingMerge(ModeID mode, Imaging bands[4]);
extern int extern int
ImagingSplit(Imaging im, Imaging bands[4]); ImagingSplit(Imaging im, Imaging bands[4]);
extern int extern int
@ -371,7 +366,7 @@ ImagingOffset(Imaging im, int xoffset, int yoffset);
extern int extern int
ImagingPaste(Imaging into, Imaging im, Imaging mask, int x0, int y0, int x1, int y1); ImagingPaste(Imaging into, Imaging im, Imaging mask, int x0, int y0, int x1, int y1);
extern Imaging extern Imaging
ImagingPoint(Imaging im, const char *tablemode, const void *table); ImagingPoint(Imaging im, ModeID tablemode, const void *table);
extern Imaging extern Imaging
ImagingPointTransform(Imaging imIn, double scale, double offset); ImagingPointTransform(Imaging imIn, double scale, double offset);
extern Imaging extern Imaging
@ -712,9 +707,9 @@ extern void
ImagingConvertYCbCr2RGB(UINT8 *out, const UINT8 *in, int pixels); ImagingConvertYCbCr2RGB(UINT8 *out, const UINT8 *in, int pixels);
extern ImagingShuffler extern ImagingShuffler
ImagingFindUnpacker(const char *mode, const char *rawmode, int *bits_out); ImagingFindUnpacker(ModeID mode, RawModeID rawmode, int *bits_out);
extern ImagingShuffler extern ImagingShuffler
ImagingFindPacker(const char *mode, const char *rawmode, int *bits_out); ImagingFindPacker(ModeID mode, RawModeID rawmode, int *bits_out);
struct ImagingCodecStateInstance { struct ImagingCodecStateInstance {
int count; int count;

12
src/libImaging/Jpeg.h
View File

@ -28,12 +28,12 @@ typedef struct {
typedef struct { typedef struct {
/* CONFIGURATION */ /* CONFIGURATION */
/* Jpeg file mode (empty if not known) */ /* Jpeg file mode */
char jpegmode[8 + 1]; RawModeID jpegmode;
/* Converter output mode (input to the shuffler). If empty, /* Converter output mode (input to the shuffler) */
convert conversions are disabled */ /* If not a valid mode, convert conversions are disabled */
char rawmode[8 + 1]; RawModeID rawmode;
/* If set, trade quality for speed */ /* If set, trade quality for speed */
int draft; int draft;
@ -91,7 +91,7 @@ typedef struct {
unsigned int restart_marker_rows; unsigned int restart_marker_rows;
/* Converter input mode (input to the shuffler) */ /* Converter input mode (input to the shuffler) */
char rawmode[8 + 1]; RawModeID rawmode;
/* Custom quantization tables () */ /* Custom quantization tables () */
unsigned int *qtables; unsigned int *qtables;

44
src/libImaging/Jpeg2KDecode.c
View File

@ -71,7 +71,7 @@ typedef void (*j2k_unpacker_t)(
); );
struct j2k_decode_unpacker { struct j2k_decode_unpacker {
const char *mode; const ModeID mode;
OPJ_COLOR_SPACE color_space; OPJ_COLOR_SPACE color_space;
unsigned components; unsigned components;
/* bool indicating if unpacker supports subsampling */ /* bool indicating if unpacker supports subsampling */
@ -599,26 +599,26 @@ j2ku_sycca_rgba(
} }
static const struct j2k_decode_unpacker j2k_unpackers[] = { static const struct j2k_decode_unpacker j2k_unpackers[] = {
{"L", OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_l}, {IMAGING_MODE_L, OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_l},
{"P", OPJ_CLRSPC_SRGB, 1, 0, j2ku_gray_l}, {IMAGING_MODE_P, OPJ_CLRSPC_SRGB, 1, 0, j2ku_gray_l},
{"PA", OPJ_CLRSPC_SRGB, 2, 0, j2ku_graya_la}, {IMAGING_MODE_PA, OPJ_CLRSPC_SRGB, 2, 0, j2ku_graya_la},
{"I;16", OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_i}, {IMAGING_MODE_I_16, OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_i},
{"I;16B", OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_i}, {IMAGING_MODE_I_16B, OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_i},
{"LA", OPJ_CLRSPC_GRAY, 2, 0, j2ku_graya_la}, {IMAGING_MODE_LA, OPJ_CLRSPC_GRAY, 2, 0, j2ku_graya_la},
{"RGB", OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_rgb}, {IMAGING_MODE_RGB, OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_rgb},
{"RGB", OPJ_CLRSPC_GRAY, 2, 0, j2ku_gray_rgb}, {IMAGING_MODE_RGB, OPJ_CLRSPC_GRAY, 2, 0, j2ku_gray_rgb},
{"RGB", OPJ_CLRSPC_SRGB, 3, 1, j2ku_srgb_rgb}, {IMAGING_MODE_RGB, OPJ_CLRSPC_SRGB, 3, 1, j2ku_srgb_rgb},
{"RGB", OPJ_CLRSPC_SYCC, 3, 1, j2ku_sycc_rgb}, {IMAGING_MODE_RGB, OPJ_CLRSPC_SYCC, 3, 1, j2ku_sycc_rgb},
{"RGB", OPJ_CLRSPC_SRGB, 4, 1, j2ku_srgb_rgb}, {IMAGING_MODE_RGB, OPJ_CLRSPC_SRGB, 4, 1, j2ku_srgb_rgb},
{"RGB", OPJ_CLRSPC_SYCC, 4, 1, j2ku_sycc_rgb}, {IMAGING_MODE_RGB, OPJ_CLRSPC_SYCC, 4, 1, j2ku_sycc_rgb},
{"RGBA", OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_rgb}, {IMAGING_MODE_RGBA, OPJ_CLRSPC_GRAY, 1, 0, j2ku_gray_rgb},
{"RGBA", OPJ_CLRSPC_GRAY, 2, 0, j2ku_graya_la}, {IMAGING_MODE_RGBA, OPJ_CLRSPC_GRAY, 2, 0, j2ku_graya_la},
{"RGBA", OPJ_CLRSPC_SRGB, 3, 1, j2ku_srgb_rgb}, {IMAGING_MODE_RGBA, OPJ_CLRSPC_SRGB, 3, 1, j2ku_srgb_rgb},
{"RGBA", OPJ_CLRSPC_SYCC, 3, 1, j2ku_sycc_rgb}, {IMAGING_MODE_RGBA, OPJ_CLRSPC_SYCC, 3, 1, j2ku_sycc_rgb},
{"RGBA", OPJ_CLRSPC_GRAY, 4, 1, j2ku_srgba_rgba}, {IMAGING_MODE_RGBA, OPJ_CLRSPC_GRAY, 4, 1, j2ku_srgba_rgba},
{"RGBA", OPJ_CLRSPC_SRGB, 4, 1, j2ku_srgba_rgba}, {IMAGING_MODE_RGBA, OPJ_CLRSPC_SRGB, 4, 1, j2ku_srgba_rgba},
{"RGBA", OPJ_CLRSPC_SYCC, 4, 1, j2ku_sycca_rgba}, {IMAGING_MODE_RGBA, OPJ_CLRSPC_SYCC, 4, 1, j2ku_sycca_rgba},
{"CMYK", OPJ_CLRSPC_CMYK, 4, 1, j2ku_srgba_rgba}, {IMAGING_MODE_CMYK, OPJ_CLRSPC_CMYK, 4, 1, j2ku_srgba_rgba},
}; };
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
@ -771,7 +771,7 @@ j2k_decode_entry(Imaging im, ImagingCodecState state) {
if (color_space == j2k_unpackers[n].color_space && if (color_space == j2k_unpackers[n].color_space &&
image->numcomps == j2k_unpackers[n].components && image->numcomps == j2k_unpackers[n].components &&
(j2k_unpackers[n].subsampling || (subsampling == -1)) && (j2k_unpackers[n].subsampling || (subsampling == -1)) &&
strcmp(im->mode, j2k_unpackers[n].mode) == 0) { im->mode == j2k_unpackers[n].mode) {
unpack = j2k_unpackers[n].unpacker; unpack = j2k_unpackers[n].unpacker;
break; break;
} }

18
src/libImaging/Jpeg2KEncode.c
View File

@ -305,34 +305,34 @@ j2k_encode_entry(Imaging im, ImagingCodecState state) {
#endif #endif
/* Setup an opj_image */ /* Setup an opj_image */
if (strcmp(im->mode, "L") == 0) { if (im->mode == IMAGING_MODE_L) {
components = 1; components = 1;
color_space = OPJ_CLRSPC_GRAY; color_space = OPJ_CLRSPC_GRAY;
pack = j2k_pack_l; pack = j2k_pack_l;
} else if (strcmp(im->mode, "I;16") == 0 || strcmp(im->mode, "I;16B") == 0) { } else if (im->mode == IMAGING_MODE_I_16 || im->mode == IMAGING_MODE_I_16B) {
components = 1; components = 1;
color_space = OPJ_CLRSPC_GRAY; color_space = OPJ_CLRSPC_GRAY;
pack = j2k_pack_i16; pack = j2k_pack_i16;
prec = 16; prec = 16;
} else if (strcmp(im->mode, "LA") == 0) { } else if (im->mode == IMAGING_MODE_LA) {
components = 2; components = 2;
color_space = OPJ_CLRSPC_GRAY; color_space = OPJ_CLRSPC_GRAY;
pack = j2k_pack_la; pack = j2k_pack_la;
} else if (strcmp(im->mode, "RGB") == 0) { } else if (im->mode == IMAGING_MODE_RGB) {
components = 3; components = 3;
color_space = OPJ_CLRSPC_SRGB; color_space = OPJ_CLRSPC_SRGB;
pack = j2k_pack_rgb; pack = j2k_pack_rgb;
} else if (strcmp(im->mode, "YCbCr") == 0) { } else if (im->mode == IMAGING_MODE_YCbCr) {
components = 3; components = 3;
color_space = OPJ_CLRSPC_SYCC; color_space = OPJ_CLRSPC_SYCC;
pack = j2k_pack_rgb; pack = j2k_pack_rgb;
} else if (strcmp(im->mode, "RGBA") == 0) { } else if (im->mode == IMAGING_MODE_RGBA) {
components = 4; components = 4;
color_space = OPJ_CLRSPC_SRGB; color_space = OPJ_CLRSPC_SRGB;
pack = j2k_pack_rgba; pack = j2k_pack_rgba;
#if ((OPJ_VERSION_MAJOR == 2 && OPJ_VERSION_MINOR == 5 && OPJ_VERSION_BUILD >= 3) || \ #if ((OPJ_VERSION_MAJOR == 2 && OPJ_VERSION_MINOR == 5 && OPJ_VERSION_BUILD >= 3) || \
(OPJ_VERSION_MAJOR == 2 && OPJ_VERSION_MINOR > 5) || OPJ_VERSION_MAJOR > 2) (OPJ_VERSION_MAJOR == 2 && OPJ_VERSION_MINOR > 5) || OPJ_VERSION_MAJOR > 2)
} else if (strcmp(im->mode, "CMYK") == 0) { } else if (im->mode == IMAGING_MODE_CMYK) {
components = 4; components = 4;
color_space = OPJ_CLRSPC_CMYK; color_space = OPJ_CLRSPC_CMYK;
pack = j2k_pack_rgba; pack = j2k_pack_rgba;
@ -497,9 +497,9 @@ j2k_encode_entry(Imaging im, ImagingCodecState state) {
goto quick_exit; goto quick_exit;
} }
if (strcmp(im->mode, "RGBA") == 0) { if (im->mode == IMAGING_MODE_RGBA) {
image->comps[3].alpha = 1; image->comps[3].alpha = 1;
} else if (strcmp(im->mode, "LA") == 0) { } else if (im->mode == IMAGING_MODE_LA) {
image->comps[1].alpha = 1; image->comps[1].alpha = 1;
} }

34
src/libImaging/JpegDecode.c
View File

@ -180,41 +180,41 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t by
/* Decoder settings */ /* Decoder settings */
/* jpegmode indicates what's in the file; if not set, we'll /* jpegmode indicates what's in the file. */
trust the decoder */ /* If not valid, we'll trust the decoder. */
if (strcmp(context->jpegmode, "L") == 0) { if (context->jpegmode == IMAGING_RAWMODE_L) {
context->cinfo.jpeg_color_space = JCS_GRAYSCALE; context->cinfo.jpeg_color_space = JCS_GRAYSCALE;
} else if (strcmp(context->jpegmode, "RGB") == 0) { } else if (context->jpegmode == IMAGING_RAWMODE_RGB) {
context->cinfo.jpeg_color_space = JCS_RGB; context->cinfo.jpeg_color_space = JCS_RGB;
} else if (strcmp(context->jpegmode, "CMYK") == 0) { } else if (context->jpegmode == IMAGING_RAWMODE_CMYK) {
context->cinfo.jpeg_color_space = JCS_CMYK; context->cinfo.jpeg_color_space = JCS_CMYK;
} else if (strcmp(context->jpegmode, "YCbCr") == 0) { } else if (context->jpegmode == IMAGING_RAWMODE_YCbCr) {
context->cinfo.jpeg_color_space = JCS_YCbCr; context->cinfo.jpeg_color_space = JCS_YCbCr;
} else if (strcmp(context->jpegmode, "YCbCrK") == 0) { } else if (context->jpegmode == IMAGING_RAWMODE_YCbCrK) {
context->cinfo.jpeg_color_space = JCS_YCCK; context->cinfo.jpeg_color_space = JCS_YCCK;
} }
/* rawmode indicates what we want from the decoder. if not /* rawmode indicates what we want from the decoder. */
set, conversions are disabled */ /* If not valid, conversions are disabled. */
if (strcmp(context->rawmode, "L") == 0) { if (context->rawmode == IMAGING_RAWMODE_L) {
context->cinfo.out_color_space = JCS_GRAYSCALE; context->cinfo.out_color_space = JCS_GRAYSCALE;
} else if (strcmp(context->rawmode, "RGB") == 0) { } else if (context->rawmode == IMAGING_RAWMODE_RGB) {
context->cinfo.out_color_space = JCS_RGB; context->cinfo.out_color_space = JCS_RGB;
} }
#ifdef JCS_EXTENSIONS #ifdef JCS_EXTENSIONS
else if (strcmp(context->rawmode, "RGBX") == 0) { else if (context->rawmode == IMAGING_RAWMODE_RGBX) {
context->cinfo.out_color_space = JCS_EXT_RGBX; context->cinfo.out_color_space = JCS_EXT_RGBX;
} }
#endif #endif
else if (strcmp(context->rawmode, "CMYK") == 0 || else if (context->rawmode == IMAGING_RAWMODE_CMYK ||
strcmp(context->rawmode, "CMYK;I") == 0) { context->rawmode == IMAGING_RAWMODE_CMYK_I) {
context->cinfo.out_color_space = JCS_CMYK; context->cinfo.out_color_space = JCS_CMYK;
} else if (strcmp(context->rawmode, "YCbCr") == 0) { } else if (context->rawmode == IMAGING_RAWMODE_YCbCr) {
context->cinfo.out_color_space = JCS_YCbCr; context->cinfo.out_color_space = JCS_YCbCr;
} else if (strcmp(context->rawmode, "YCbCrK") == 0) { } else if (context->rawmode == IMAGING_RAWMODE_YCbCrK) {
context->cinfo.out_color_space = JCS_YCCK; context->cinfo.out_color_space = JCS_YCCK;
} else { } else {
/* Disable decoder conversions */ /* Disable decoder conversions. */
context->cinfo.jpeg_color_space = JCS_UNKNOWN; context->cinfo.jpeg_color_space = JCS_UNKNOWN;
context->cinfo.out_color_space = JCS_UNKNOWN; context->cinfo.out_color_space = JCS_UNKNOWN;
} }

4
src/libImaging/JpegEncode.c
View File

@ -114,7 +114,7 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
break; break;
case 24: case 24:
context->cinfo.input_components = 3; context->cinfo.input_components = 3;
if (strcmp(im->mode, "YCbCr") == 0) { if (im->mode == IMAGING_MODE_YCbCr) {
context->cinfo.in_color_space = JCS_YCbCr; context->cinfo.in_color_space = JCS_YCbCr;
} else { } else {
context->cinfo.in_color_space = JCS_RGB; context->cinfo.in_color_space = JCS_RGB;
@ -124,7 +124,7 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
context->cinfo.input_components = 4; context->cinfo.input_components = 4;
context->cinfo.in_color_space = JCS_CMYK; context->cinfo.in_color_space = JCS_CMYK;
#ifdef JCS_EXTENSIONS #ifdef JCS_EXTENSIONS
if (strcmp(context->rawmode, "RGBX") == 0) { if (context->rawmode == IMAGING_RAWMODE_RGBX) {
context->cinfo.in_color_space = JCS_EXT_RGBX; context->cinfo.in_color_space = JCS_EXT_RGBX;
} }
#endif #endif

10
src/libImaging/Matrix.c
View File

@ -18,7 +18,7 @@
#define CLIPF(v) ((v <= 0.0) ? 0 : (v >= 255.0F) ? 255 : (UINT8)v) #define CLIPF(v) ((v <= 0.0) ? 0 : (v >= 255.0F) ? 255 : (UINT8)v)
Imaging Imaging
ImagingConvertMatrix(Imaging im, const char *mode, float m[]) { ImagingConvertMatrix(Imaging im, const ModeID mode, float m[]) {
Imaging imOut; Imaging imOut;
int x, y; int x, y;
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
@ -28,8 +28,8 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[]) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (strcmp(mode, "L") == 0) { if (mode == IMAGING_MODE_L) {
imOut = ImagingNewDirty("L", im->xsize, im->ysize); imOut = ImagingNewDirty(IMAGING_MODE_L, im->xsize, im->ysize);
if (!imOut) { if (!imOut) {
return NULL; return NULL;
} }
@ -46,8 +46,8 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[]) {
} }
} }
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (mode == IMAGING_MODE_HSV || mode == IMAGING_MODE_LAB ||
} else if (strlen(mode) == 3) { mode == IMAGING_MODE_RGB) {
imOut = ImagingNewDirty(mode, im->xsize, im->ysize); imOut = ImagingNewDirty(mode, im->xsize, im->ysize);
if (!imOut) { if (!imOut) {
return NULL; return NULL;

259
src/libImaging/Mode.c Normal file
View File

@ -0,0 +1,259 @@
#include "Mode.h"
#include <string.h>
#ifdef NDEBUG
#include <stdio.h>
#include <stdlib.h>
#endif
const ModeData MODES[] = {
[IMAGING_MODE_UNKNOWN] = {""},
[IMAGING_MODE_1] = {"1"}, [IMAGING_MODE_CMYK] = {"CMYK"},
[IMAGING_MODE_F] = {"F"}, [IMAGING_MODE_HSV] = {"HSV"},
[IMAGING_MODE_I] = {"I"}, [IMAGING_MODE_L] = {"L"},
[IMAGING_MODE_LA] = {"LA"}, [IMAGING_MODE_LAB] = {"LAB"},
[IMAGING_MODE_La] = {"La"}, [IMAGING_MODE_P] = {"P"},
[IMAGING_MODE_PA] = {"PA"}, [IMAGING_MODE_RGB] = {"RGB"},
[IMAGING_MODE_RGBA] = {"RGBA"}, [IMAGING_MODE_RGBX] = {"RGBX"},
[IMAGING_MODE_RGBa] = {"RGBa"}, [IMAGING_MODE_YCbCr] = {"YCbCr"},
[IMAGING_MODE_I_16] = {"I;16"}, [IMAGING_MODE_I_16L] = {"I;16L"},
[IMAGING_MODE_I_16B] = {"I;16B"}, [IMAGING_MODE_I_16N] = {"I;16N"},
[IMAGING_MODE_I_32L] = {"I;32L"}, [IMAGING_MODE_I_32B] = {"I;32B"},
};
const ModeID
findModeID(const char *const name) {
if (name == NULL) {
return IMAGING_MODE_UNKNOWN;
}
for (size_t i = 0; i < sizeof(MODES) / sizeof(*MODES); i++) {
#ifdef NDEBUG
if (MODES[i].name == NULL) {
fprintf(stderr, "Mode ID %zu is not defined.\n", (size_t)i);
} else
#endif
if (strcmp(MODES[i].name, name) == 0) {
return (ModeID)i;
}
}
return IMAGING_MODE_UNKNOWN;
}
const ModeData *const
getModeData(const ModeID id) {
if (id < 0 || id > sizeof(MODES) / sizeof(*MODES)) {
return &MODES[IMAGING_MODE_UNKNOWN];
}
return &MODES[id];
}
const RawModeData RAWMODES[] = {
[IMAGING_RAWMODE_UNKNOWN] = {""},
[IMAGING_RAWMODE_1] = {"1"},
[IMAGING_RAWMODE_CMYK] = {"CMYK"},
[IMAGING_RAWMODE_F] = {"F"},
[IMAGING_RAWMODE_HSV] = {"HSV"},
[IMAGING_RAWMODE_I] = {"I"},
[IMAGING_RAWMODE_L] = {"L"},
[IMAGING_RAWMODE_LA] = {"LA"},
[IMAGING_RAWMODE_LAB] = {"LAB"},
[IMAGING_RAWMODE_La] = {"La"},
[IMAGING_RAWMODE_P] = {"P"},
[IMAGING_RAWMODE_PA] = {"PA"},
[IMAGING_RAWMODE_RGB] = {"RGB"},
[IMAGING_RAWMODE_RGBA] = {"RGBA"},
[IMAGING_RAWMODE_RGBX] = {"RGBX"},
[IMAGING_RAWMODE_RGBa] = {"RGBa"},
[IMAGING_RAWMODE_YCbCr] = {"YCbCr"},
[IMAGING_RAWMODE_BGR_15] = {"BGR;15"},
[IMAGING_RAWMODE_BGR_16] = {"BGR;16"},
[IMAGING_RAWMODE_I_16] = {"I;16"},
[IMAGING_RAWMODE_I_16L] = {"I;16L"},
[IMAGING_RAWMODE_I_16B] = {"I;16B"},
[IMAGING_RAWMODE_I_16N] = {"I;16N"},
[IMAGING_RAWMODE_I_32L] = {"I;32L"},
[IMAGING_RAWMODE_I_32B] = {"I;32B"},
[IMAGING_RAWMODE_1_8] = {"1;8"},
[IMAGING_RAWMODE_1_I] = {"1;I"},
[IMAGING_RAWMODE_1_IR] = {"1;IR"},
[IMAGING_RAWMODE_1_R] = {"1;R"},
[IMAGING_RAWMODE_A] = {"A"},
[IMAGING_RAWMODE_ABGR] = {"ABGR"},
[IMAGING_RAWMODE_ARGB] = {"ARGB"},
[IMAGING_RAWMODE_A_16B] = {"A;16B"},
[IMAGING_RAWMODE_A_16L] = {"A;16L"},
[IMAGING_RAWMODE_A_16N] = {"A;16N"},
[IMAGING_RAWMODE_B] = {"B"},
[IMAGING_RAWMODE_BGAR] = {"BGAR"},
[IMAGING_RAWMODE_BGR] = {"BGR"},
[IMAGING_RAWMODE_BGRA] = {"BGRA"},
[IMAGING_RAWMODE_BGRA_15] = {"BGRA;15"},
[IMAGING_RAWMODE_BGRA_15Z] = {"BGRA;15Z"},
[IMAGING_RAWMODE_BGRA_16B] = {"BGRA;16B"},
[IMAGING_RAWMODE_BGRA_16L] = {"BGRA;16L"},
[IMAGING_RAWMODE_BGRX] = {"BGRX"},
[IMAGING_RAWMODE_BGR_5] = {"BGR;5"},
[IMAGING_RAWMODE_BGRa] = {"BGRa"},
[IMAGING_RAWMODE_BGXR] = {"BGXR"},
[IMAGING_RAWMODE_B_16B] = {"B;16B"},
[IMAGING_RAWMODE_B_16L] = {"B;16L"},
[IMAGING_RAWMODE_B_16N] = {"B;16N"},
[IMAGING_RAWMODE_C] = {"C"},
[IMAGING_RAWMODE_CMYKX] = {"CMYKX"},
[IMAGING_RAWMODE_CMYKXX] = {"CMYKXX"},
[IMAGING_RAWMODE_CMYK_16B] = {"CMYK;16B"},
[IMAGING_RAWMODE_CMYK_16L] = {"CMYK;16L"},
[IMAGING_RAWMODE_CMYK_16N] = {"CMYK;16N"},
[IMAGING_RAWMODE_CMYK_I] = {"CMYK;I"},
[IMAGING_RAWMODE_CMYK_L] = {"CMYK;L"},
[IMAGING_RAWMODE_C_I] = {"C;I"},
[IMAGING_RAWMODE_Cb] = {"Cb"},
[IMAGING_RAWMODE_Cr] = {"Cr"},
[IMAGING_RAWMODE_F_16] = {"F;16"},
[IMAGING_RAWMODE_F_16B] = {"F;16B"},
[IMAGING_RAWMODE_F_16BS] = {"F;16BS"},
[IMAGING_RAWMODE_F_16N] = {"F;16N"},
[IMAGING_RAWMODE_F_16NS] = {"F;16NS"},
[IMAGING_RAWMODE_F_16S] = {"F;16S"},
[IMAGING_RAWMODE_F_32] = {"F;32"},
[IMAGING_RAWMODE_F_32B] = {"F;32B"},
[IMAGING_RAWMODE_F_32BF] = {"F;32BF"},
[IMAGING_RAWMODE_F_32BS] = {"F;32BS"},
[IMAGING_RAWMODE_F_32F] = {"F;32F"},
[IMAGING_RAWMODE_F_32N] = {"F;32N"},
[IMAGING_RAWMODE_F_32NF] = {"F;32NF"},
[IMAGING_RAWMODE_F_32NS] = {"F;32NS"},
[IMAGING_RAWMODE_F_32S] = {"F;32S"},
[IMAGING_RAWMODE_F_64BF] = {"F;64BF"},
[IMAGING_RAWMODE_F_64F] = {"F;64F"},
[IMAGING_RAWMODE_F_64NF] = {"F;64NF"},
[IMAGING_RAWMODE_F_8] = {"F;8"},
[IMAGING_RAWMODE_F_8S] = {"F;8S"},
[IMAGING_RAWMODE_G] = {"G"},
[IMAGING_RAWMODE_G_16B] = {"G;16B"},
[IMAGING_RAWMODE_G_16L] = {"G;16L"},
[IMAGING_RAWMODE_G_16N] = {"G;16N"},
[IMAGING_RAWMODE_H] = {"H"},
[IMAGING_RAWMODE_I_12] = {"I;12"},
[IMAGING_RAWMODE_I_16BS] = {"I;16BS"},
[IMAGING_RAWMODE_I_16NS] = {"I;16NS"},
[IMAGING_RAWMODE_I_16R] = {"I;16R"},
[IMAGING_RAWMODE_I_16S] = {"I;16S"},
[IMAGING_RAWMODE_I_32] = {"I;32"},
[IMAGING_RAWMODE_I_32BS] = {"I;32BS"},
[IMAGING_RAWMODE_I_32N] = {"I;32N"},
[IMAGING_RAWMODE_I_32NS] = {"I;32NS"},
[IMAGING_RAWMODE_I_32S] = {"I;32S"},
[IMAGING_RAWMODE_I_8] = {"I;8"},
[IMAGING_RAWMODE_I_8S] = {"I;8S"},
[IMAGING_RAWMODE_K] = {"K"},
[IMAGING_RAWMODE_K_I] = {"K;I"},
[IMAGING_RAWMODE_LA_16B] = {"LA;16B"},
[IMAGING_RAWMODE_LA_L] = {"LA;L"},
[IMAGING_RAWMODE_L_16] = {"L;16"},
[IMAGING_RAWMODE_L_16B] = {"L;16B"},
[IMAGING_RAWMODE_L_2] = {"L;2"},
[IMAGING_RAWMODE_L_2I] = {"L;2I"},
[IMAGING_RAWMODE_L_2IR] = {"L;2IR"},
[IMAGING_RAWMODE_L_2R] = {"L;2R"},
[IMAGING_RAWMODE_L_4] = {"L;4"},
[IMAGING_RAWMODE_L_4I] = {"L;4I"},
[IMAGING_RAWMODE_L_4IR] = {"L;4IR"},
[IMAGING_RAWMODE_L_4R] = {"L;4R"},
[IMAGING_RAWMODE_L_I] = {"L;I"},
[IMAGING_RAWMODE_L_R] = {"L;R"},
[IMAGING_RAWMODE_M] = {"M"},
[IMAGING_RAWMODE_M_I] = {"M;I"},
[IMAGING_RAWMODE_PA_L] = {"PA;L"},
[IMAGING_RAWMODE_PX] = {"PX"},
[IMAGING_RAWMODE_P_1] = {"P;1"},
[IMAGING_RAWMODE_P_2] = {"P;2"},
[IMAGING_RAWMODE_P_2L] = {"P;2L"},
[IMAGING_RAWMODE_P_4] = {"P;4"},
[IMAGING_RAWMODE_P_4L] = {"P;4L"},
[IMAGING_RAWMODE_P_R] = {"P;R"},
[IMAGING_RAWMODE_R] = {"R"},
[IMAGING_RAWMODE_RGBAX] = {"RGBAX"},
[IMAGING_RAWMODE_RGBAXX] = {"RGBAXX"},
[IMAGING_RAWMODE_RGBA_15] = {"RGBA;15"},
[IMAGING_RAWMODE_RGBA_16B] = {"RGBA;16B"},
[IMAGING_RAWMODE_RGBA_16L] = {"RGBA;16L"},
[IMAGING_RAWMODE_RGBA_16N] = {"RGBA;16N"},
[IMAGING_RAWMODE_RGBA_4B] = {"RGBA;4B"},
[IMAGING_RAWMODE_RGBA_I] = {"RGBA;I"},
[IMAGING_RAWMODE_RGBA_L] = {"RGBA;L"},
[IMAGING_RAWMODE_RGBXX] = {"RGBXX"},
[IMAGING_RAWMODE_RGBXXX] = {"RGBXXX"},
[IMAGING_RAWMODE_RGBX_16B] = {"RGBX;16B"},
[IMAGING_RAWMODE_RGBX_16L] = {"RGBX;16L"},
[IMAGING_RAWMODE_RGBX_16N] = {"RGBX;16N"},
[IMAGING_RAWMODE_RGBX_L] = {"RGBX;L"},
[IMAGING_RAWMODE_RGB_15] = {"RGB;15"},
[IMAGING_RAWMODE_RGB_16] = {"RGB;16"},
[IMAGING_RAWMODE_RGB_16B] = {"RGB;16B"},
[IMAGING_RAWMODE_RGB_16L] = {"RGB;16L"},
[IMAGING_RAWMODE_RGB_16N] = {"RGB;16N"},
[IMAGING_RAWMODE_RGB_4B] = {"RGB;4B"},
[IMAGING_RAWMODE_RGB_L] = {"RGB;L"},
[IMAGING_RAWMODE_RGB_R] = {"RGB;R"},
[IMAGING_RAWMODE_RGBaX] = {"RGBaX"},
[IMAGING_RAWMODE_RGBaXX] = {"RGBaXX"},
[IMAGING_RAWMODE_RGBa_16B] = {"RGBa;16B"},
[IMAGING_RAWMODE_RGBa_16L] = {"RGBa;16L"},
[IMAGING_RAWMODE_RGBa_16N] = {"RGBa;16N"},
[IMAGING_RAWMODE_R_16B] = {"R;16B"},
[IMAGING_RAWMODE_R_16L] = {"R;16L"},
[IMAGING_RAWMODE_R_16N] = {"R;16N"},
[IMAGING_RAWMODE_S] = {"S"},
[IMAGING_RAWMODE_V] = {"V"},
[IMAGING_RAWMODE_X] = {"X"},
[IMAGING_RAWMODE_XBGR] = {"XBGR"},
[IMAGING_RAWMODE_XRGB] = {"XRGB"},
[IMAGING_RAWMODE_Y] = {"Y"},
[IMAGING_RAWMODE_YCCA_P] = {"YCCA;P"},
[IMAGING_RAWMODE_YCC_P] = {"YCC;P"},
[IMAGING_RAWMODE_YCbCrK] = {"YCbCrK"},
[IMAGING_RAWMODE_YCbCrX] = {"YCbCrX"},
[IMAGING_RAWMODE_YCbCr_L] = {"YCbCr;L"},
[IMAGING_RAWMODE_Y_I] = {"Y;I"},
[IMAGING_RAWMODE_aBGR] = {"aBGR"},
[IMAGING_RAWMODE_aRGB] = {"aRGB"},
};
const RawModeID
findRawModeID(const char *const name) {
if (name == NULL) {
return IMAGING_RAWMODE_UNKNOWN;
}
for (size_t i = 0; i < sizeof(RAWMODES) / sizeof(*RAWMODES); i++) {
#ifdef NDEBUG
if (RAWMODES[i].name == NULL) {
fprintf(stderr, "Rawmode ID %zu is not defined.\n", (size_t)i);
} else
#endif
if (strcmp(RAWMODES[i].name, name) == 0) {
return (RawModeID)i;
}
}
return IMAGING_RAWMODE_UNKNOWN;
}
const RawModeData *const
getRawModeData(const RawModeID id) {
if (id < 0 || id > sizeof(RAWMODES) / sizeof(*RAWMODES)) {
return &RAWMODES[IMAGING_RAWMODE_UNKNOWN];
}
return &RAWMODES[id];
}
int
isModeI16(const ModeID mode) {
return mode == IMAGING_MODE_I_16 || mode == IMAGING_MODE_I_16L ||
mode == IMAGING_MODE_I_16B || mode == IMAGING_MODE_I_16N;
}

232
src/libImaging/Mode.h Normal file
View File

@ -0,0 +1,232 @@
#ifndef __MODE_H__
#define __MODE_H__
typedef enum {
IMAGING_MODE_UNKNOWN,
IMAGING_MODE_1,
IMAGING_MODE_CMYK,
IMAGING_MODE_F,
IMAGING_MODE_HSV,
IMAGING_MODE_I,
IMAGING_MODE_L,
IMAGING_MODE_LA,
IMAGING_MODE_LAB,
IMAGING_MODE_La,
IMAGING_MODE_P,
IMAGING_MODE_PA,
IMAGING_MODE_RGB,
IMAGING_MODE_RGBA,
IMAGING_MODE_RGBX,
IMAGING_MODE_RGBa,
IMAGING_MODE_YCbCr,
IMAGING_MODE_I_16,
IMAGING_MODE_I_16L,
IMAGING_MODE_I_16B,
IMAGING_MODE_I_16N,
IMAGING_MODE_I_32L,
IMAGING_MODE_I_32B,
} ModeID;
typedef struct {
const char *const name;
} ModeData;
const ModeID
findModeID(const char *const name);
const ModeData *const
getModeData(const ModeID id);
typedef enum {
IMAGING_RAWMODE_UNKNOWN,
// Non-rawmode aliases.
IMAGING_RAWMODE_1,
IMAGING_RAWMODE_CMYK,
IMAGING_RAWMODE_F,
IMAGING_RAWMODE_HSV,
IMAGING_RAWMODE_I,
IMAGING_RAWMODE_L,
IMAGING_RAWMODE_LA,
IMAGING_RAWMODE_LAB,
IMAGING_RAWMODE_La,
IMAGING_RAWMODE_P,
IMAGING_RAWMODE_PA,
IMAGING_RAWMODE_RGB,
IMAGING_RAWMODE_RGBA,
IMAGING_RAWMODE_RGBX,
IMAGING_RAWMODE_RGBa,
IMAGING_RAWMODE_YCbCr,
// I;* modes.
IMAGING_RAWMODE_I_16,
IMAGING_RAWMODE_I_16L,
IMAGING_RAWMODE_I_16B,
IMAGING_RAWMODE_I_16N,
IMAGING_RAWMODE_I_32L,
IMAGING_RAWMODE_I_32B,
// Rawmodes
IMAGING_RAWMODE_1_8,
IMAGING_RAWMODE_1_I,
IMAGING_RAWMODE_1_IR,
IMAGING_RAWMODE_1_R,
IMAGING_RAWMODE_A,
IMAGING_RAWMODE_ABGR,
IMAGING_RAWMODE_ARGB,
IMAGING_RAWMODE_A_16B,
IMAGING_RAWMODE_A_16L,
IMAGING_RAWMODE_A_16N,
IMAGING_RAWMODE_B,
IMAGING_RAWMODE_BGAR,
IMAGING_RAWMODE_BGR,
IMAGING_RAWMODE_BGRA,
IMAGING_RAWMODE_BGRA_15,
IMAGING_RAWMODE_BGRA_15Z,
IMAGING_RAWMODE_BGRA_16B,
IMAGING_RAWMODE_BGRA_16L,
IMAGING_RAWMODE_BGRX,
IMAGING_RAWMODE_BGR_5,
IMAGING_RAWMODE_BGR_15,
IMAGING_RAWMODE_BGR_16,
IMAGING_RAWMODE_BGRa,
IMAGING_RAWMODE_BGXR,
IMAGING_RAWMODE_B_16B,
IMAGING_RAWMODE_B_16L,
IMAGING_RAWMODE_B_16N,
IMAGING_RAWMODE_C,
IMAGING_RAWMODE_CMYKX,
IMAGING_RAWMODE_CMYKXX,
IMAGING_RAWMODE_CMYK_16B,
IMAGING_RAWMODE_CMYK_16L,
IMAGING_RAWMODE_CMYK_16N,
IMAGING_RAWMODE_CMYK_I,
IMAGING_RAWMODE_CMYK_L,
IMAGING_RAWMODE_C_I,
IMAGING_RAWMODE_Cb,
IMAGING_RAWMODE_Cr,
IMAGING_RAWMODE_F_16,
IMAGING_RAWMODE_F_16B,
IMAGING_RAWMODE_F_16BS,
IMAGING_RAWMODE_F_16N,
IMAGING_RAWMODE_F_16NS,
IMAGING_RAWMODE_F_16S,
IMAGING_RAWMODE_F_32,
IMAGING_RAWMODE_F_32B,
IMAGING_RAWMODE_F_32BF,
IMAGING_RAWMODE_F_32BS,
IMAGING_RAWMODE_F_32F,
IMAGING_RAWMODE_F_32N,
IMAGING_RAWMODE_F_32NF,
IMAGING_RAWMODE_F_32NS,
IMAGING_RAWMODE_F_32S,
IMAGING_RAWMODE_F_64BF,
IMAGING_RAWMODE_F_64F,
IMAGING_RAWMODE_F_64NF,
IMAGING_RAWMODE_F_8,
IMAGING_RAWMODE_F_8S,
IMAGING_RAWMODE_G,
IMAGING_RAWMODE_G_16B,
IMAGING_RAWMODE_G_16L,
IMAGING_RAWMODE_G_16N,
IMAGING_RAWMODE_H,
IMAGING_RAWMODE_I_12,
IMAGING_RAWMODE_I_16BS,
IMAGING_RAWMODE_I_16NS,
IMAGING_RAWMODE_I_16R,
IMAGING_RAWMODE_I_16S,
IMAGING_RAWMODE_I_32,
IMAGING_RAWMODE_I_32BS,
IMAGING_RAWMODE_I_32N,
IMAGING_RAWMODE_I_32NS,
IMAGING_RAWMODE_I_32S,
IMAGING_RAWMODE_I_8,
IMAGING_RAWMODE_I_8S,
IMAGING_RAWMODE_K,
IMAGING_RAWMODE_K_I,
IMAGING_RAWMODE_LA_16B,
IMAGING_RAWMODE_LA_L,
IMAGING_RAWMODE_L_16,
IMAGING_RAWMODE_L_16B,
IMAGING_RAWMODE_L_2,
IMAGING_RAWMODE_L_2I,
IMAGING_RAWMODE_L_2IR,
IMAGING_RAWMODE_L_2R,
IMAGING_RAWMODE_L_4,
IMAGING_RAWMODE_L_4I,
IMAGING_RAWMODE_L_4IR,
IMAGING_RAWMODE_L_4R,
IMAGING_RAWMODE_L_I,
IMAGING_RAWMODE_L_R,
IMAGING_RAWMODE_M,
IMAGING_RAWMODE_M_I,
IMAGING_RAWMODE_PA_L,
IMAGING_RAWMODE_PX,
IMAGING_RAWMODE_P_1,
IMAGING_RAWMODE_P_2,
IMAGING_RAWMODE_P_2L,
IMAGING_RAWMODE_P_4,
IMAGING_RAWMODE_P_4L,
IMAGING_RAWMODE_P_R,
IMAGING_RAWMODE_R,
IMAGING_RAWMODE_RGBAX,
IMAGING_RAWMODE_RGBAXX,
IMAGING_RAWMODE_RGBA_15,
IMAGING_RAWMODE_RGBA_16B,
IMAGING_RAWMODE_RGBA_16L,
IMAGING_RAWMODE_RGBA_16N,
IMAGING_RAWMODE_RGBA_4B,
IMAGING_RAWMODE_RGBA_I,
IMAGING_RAWMODE_RGBA_L,
IMAGING_RAWMODE_RGBXX,
IMAGING_RAWMODE_RGBXXX,
IMAGING_RAWMODE_RGBX_16B,
IMAGING_RAWMODE_RGBX_16L,
IMAGING_RAWMODE_RGBX_16N,
IMAGING_RAWMODE_RGBX_L,
IMAGING_RAWMODE_RGB_15,
IMAGING_RAWMODE_RGB_16,
IMAGING_RAWMODE_RGB_16B,
IMAGING_RAWMODE_RGB_16L,
IMAGING_RAWMODE_RGB_16N,
IMAGING_RAWMODE_RGB_4B,
IMAGING_RAWMODE_RGB_L,
IMAGING_RAWMODE_RGB_R,
IMAGING_RAWMODE_RGBaX,
IMAGING_RAWMODE_RGBaXX,
IMAGING_RAWMODE_RGBa_16B,
IMAGING_RAWMODE_RGBa_16L,
IMAGING_RAWMODE_RGBa_16N,
IMAGING_RAWMODE_R_16B,
IMAGING_RAWMODE_R_16L,
IMAGING_RAWMODE_R_16N,
IMAGING_RAWMODE_S,
IMAGING_RAWMODE_V,
IMAGING_RAWMODE_X,
IMAGING_RAWMODE_XBGR,
IMAGING_RAWMODE_XRGB,
IMAGING_RAWMODE_Y,
IMAGING_RAWMODE_YCCA_P,
IMAGING_RAWMODE_YCC_P,
IMAGING_RAWMODE_YCbCrK,
IMAGING_RAWMODE_YCbCrX,
IMAGING_RAWMODE_YCbCr_L,
IMAGING_RAWMODE_Y_I,
IMAGING_RAWMODE_aBGR,
IMAGING_RAWMODE_aRGB,
} RawModeID;
typedef struct {
const char *const name;
} RawModeData;
const RawModeID
findRawModeID(const char *const name);
const RawModeData *const
getRawModeData(const RawModeID id);
int
isModeI16(const ModeID mode);
#endif // __MODE_H__

197
src/libImaging/Pack.c
View File

@ -519,150 +519,145 @@ band3(UINT8 *out, const UINT8 *in, int pixels) {
} }
static struct { static struct {
const char *mode; const ModeID mode;
const char *rawmode; const RawModeID rawmode;
int bits; int bits;
ImagingShuffler pack; ImagingShuffler pack;
} packers[] = { } packers[] = {
/* bilevel */ /* bilevel */
{"1", "1", 1, pack1}, {IMAGING_MODE_1, IMAGING_RAWMODE_1, 1, pack1},
{"1", "1;I", 1, pack1I}, {IMAGING_MODE_1, IMAGING_RAWMODE_1_I, 1, pack1I},
{"1", "1;R", 1, pack1R}, {IMAGING_MODE_1, IMAGING_RAWMODE_1_R, 1, pack1R},
{"1", "1;IR", 1, pack1IR}, {IMAGING_MODE_1, IMAGING_RAWMODE_1_IR, 1, pack1IR},
{"1", "L", 8, pack1L}, {IMAGING_MODE_1, IMAGING_RAWMODE_L, 8, pack1L},
/* grayscale */ /* grayscale */
{"L", "L", 8, copy1}, {IMAGING_MODE_L, IMAGING_RAWMODE_L, 8, copy1},
{"L", "L;16", 16, packL16}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_16, 16, packL16},
{"L", "L;16B", 16, packL16B}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_16B, 16, packL16B},
/* grayscale w. alpha */ /* grayscale w. alpha */
{"LA", "LA", 16, packLA}, {IMAGING_MODE_LA, IMAGING_RAWMODE_LA, 16, packLA},
{"LA", "LA;L", 16, packLAL}, {IMAGING_MODE_LA, IMAGING_RAWMODE_LA_L, 16, packLAL},
/* grayscale w. alpha premultiplied */ /* grayscale w. alpha premultiplied */
{"La", "La", 16, packLA}, {IMAGING_MODE_La, IMAGING_RAWMODE_La, 16, packLA},
/* palette */ /* palette */
{"P", "P;1", 1, pack1}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_1, 1, pack1},
{"P", "P;2", 2, packP2}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_2, 2, packP2},
{"P", "P;4", 4, packP4}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_4, 4, packP4},
{"P", "P", 8, copy1}, {IMAGING_MODE_P, IMAGING_RAWMODE_P, 8, copy1},
/* palette w. alpha */ /* palette w. alpha */
{"PA", "PA", 16, packLA}, {IMAGING_MODE_PA, IMAGING_RAWMODE_PA, 16, packLA},
{"PA", "PA;L", 16, packLAL}, {IMAGING_MODE_PA, IMAGING_RAWMODE_PA_L, 16, packLAL},
/* true colour */ /* true colour */
{"RGB", "RGB", 24, ImagingPackRGB}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{"RGB", "RGBX", 32, copy4}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX, 32, copy4},
{"RGB", "RGBA", 32, copy4}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA, 32, copy4},
{"RGB", "XRGB", 32, ImagingPackXRGB}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_XRGB, 32, ImagingPackXRGB},
{"RGB", "BGR", 24, ImagingPackBGR}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{"RGB", "BGRX", 32, ImagingPackBGRX}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGRX, 32, ImagingPackBGRX},
{"RGB", "XBGR", 32, ImagingPackXBGR}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_XBGR, 32, ImagingPackXBGR},
{"RGB", "RGB;L", 24, packRGBL}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_L, 24, packRGBL},
{"RGB", "R", 8, band0}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_R, 8, band0},
{"RGB", "G", 8, band1}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_G, 8, band1},
{"RGB", "B", 8, band2}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_B, 8, band2},
/* true colour w. alpha */ /* true colour w. alpha */
{"RGBA", "RGBA", 32, copy4}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA, 32, copy4},
{"RGBA", "RGBA;L", 32, packRGBXL}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_L, 32, packRGBXL},
{"RGBA", "RGB", 24, ImagingPackRGB}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{"RGBA", "BGR", 24, ImagingPackBGR}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{"RGBA", "BGRA", 32, ImagingPackBGRA}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA, 32, ImagingPackBGRA},
{"RGBA", "ABGR", 32, ImagingPackABGR}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_ABGR, 32, ImagingPackABGR},
{"RGBA", "BGRa", 32, ImagingPackBGRa}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRa, 32, ImagingPackBGRa},
{"RGBA", "R", 8, band0}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_R, 8, band0},
{"RGBA", "G", 8, band1}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_G, 8, band1},
{"RGBA", "B", 8, band2}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_B, 8, band2},
{"RGBA", "A", 8, band3}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_A, 8, band3},
/* true colour w. alpha premultiplied */ /* true colour w. alpha premultiplied */
{"RGBa", "RGBa", 32, copy4}, {IMAGING_MODE_RGBa, IMAGING_RAWMODE_RGBa, 32, copy4},
{"RGBa", "BGRa", 32, ImagingPackBGRA}, {IMAGING_MODE_RGBa, IMAGING_RAWMODE_BGRa, 32, ImagingPackBGRA},
{"RGBa", "aBGR", 32, ImagingPackABGR}, {IMAGING_MODE_RGBa, IMAGING_RAWMODE_aBGR, 32, ImagingPackABGR},
/* true colour w. padding */ /* true colour w. padding */
{"RGBX", "RGBX", 32, copy4}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX, 32, copy4},
{"RGBX", "RGBX;L", 32, packRGBXL}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_L, 32, packRGBXL},
{"RGBX", "RGB", 24, ImagingPackRGB}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{"RGBX", "BGR", 24, ImagingPackBGR}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{"RGBX", "BGRX", 32, ImagingPackBGRX}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGRX, 32, ImagingPackBGRX},
{"RGBX", "XBGR", 32, ImagingPackXBGR}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_XBGR, 32, ImagingPackXBGR},
{"RGBX", "R", 8, band0}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_R, 8, band0},
{"RGBX", "G", 8, band1}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_G, 8, band1},
{"RGBX", "B", 8, band2}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_B, 8, band2},
{"RGBX", "X", 8, band3}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_X, 8, band3},
/* colour separation */ /* colour separation */
{"CMYK", "CMYK", 32, copy4}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK, 32, copy4},
{"CMYK", "CMYK;I", 32, copy4I}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_I, 32, copy4I},
{"CMYK", "CMYK;L", 32, packRGBXL}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_L, 32, packRGBXL},
{"CMYK", "C", 8, band0}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_C, 8, band0},
{"CMYK", "M", 8, band1}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_M, 8, band1},
{"CMYK", "Y", 8, band2}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y, 8, band2},
{"CMYK", "K", 8, band3}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_K, 8, band3},
/* video (YCbCr) */ /* video (YCbCr) */
{"YCbCr", "YCbCr", 24, ImagingPackRGB}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr, 24, ImagingPackRGB},
{"YCbCr", "YCbCr;L", 24, packRGBL}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr_L, 24, packRGBL},
{"YCbCr", "YCbCrX", 32, copy4}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrX, 32, copy4},
{"YCbCr", "YCbCrK", 32, copy4}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrK, 32, copy4},
{"YCbCr", "Y", 8, band0}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Y, 8, band0},
{"YCbCr", "Cb", 8, band1}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Cb, 8, band1},
{"YCbCr", "Cr", 8, band2}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Cr, 8, band2},
/* LAB Color */ /* LAB Color */
{"LAB", "LAB", 24, ImagingPackLAB}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_LAB, 24, ImagingPackLAB},
{"LAB", "L", 8, band0}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_L, 8, band0},
{"LAB", "A", 8, band1}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_A, 8, band1},
{"LAB", "B", 8, band2}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_B, 8, band2},
/* HSV */ /* HSV */
{"HSV", "HSV", 24, ImagingPackRGB}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_HSV, 24, ImagingPackRGB},
{"HSV", "H", 8, band0}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_H, 8, band0},
{"HSV", "S", 8, band1}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_S, 8, band1},
{"HSV", "V", 8, band2}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_V, 8, band2},
/* integer */ /* integer */
{"I", "I", 32, copy4}, {IMAGING_MODE_I, IMAGING_RAWMODE_I, 32, copy4},
{"I", "I;16B", 16, packI16B}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_16B, 16, packI16B},
{"I", "I;32S", 32, packI32S}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32S, 32, packI32S},
{"I", "I;32NS", 32, copy4}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32NS, 32, copy4},
/* floating point */ /* floating point */
{"F", "F", 32, copy4}, {IMAGING_MODE_F, IMAGING_RAWMODE_F, 32, copy4},
{"F", "F;32F", 32, packI32S}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32F, 32, packI32S},
{"F", "F;32NF", 32, copy4}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32NF, 32, copy4},
/* storage modes */ /* storage modes */
{"I;16", "I;16", 16, copy2}, {IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16, 16, copy2},
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
{"I;16", "I;16B", 16, packI16N_I16}, {IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, packI16N_I16},
#else #else
{"I;16", "I;16B", 16, packI16N_I16B}, {IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, packI16N_I16B},
#endif #endif
{"I;16B", "I;16B", 16, copy2}, {IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16B, 16, copy2},
{"I;16L", "I;16L", 16, copy2}, {IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16L, 16, copy2},
{"I;16N", "I;16N", 16, copy2}, {IMAGING_MODE_I_16N, IMAGING_RAWMODE_I_16N, 16, copy2},
{"I;16", "I;16N", 16, packI16N_I16}, // LibTiff native->image endian. // LibTiff native->image endian.
{"I;16L", "I;16N", 16, packI16N_I16}, {IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16N, 16, packI16N_I16},
{"I;16B", "I;16N", 16, packI16N_I16B}, {IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16N, 16, packI16N_I16},
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16N, 16, packI16N_I16B}
{NULL} /* sentinel */
}; };
ImagingShuffler ImagingShuffler
ImagingFindPacker(const char *mode, const char *rawmode, int *bits_out) { ImagingFindPacker(const ModeID mode, const RawModeID rawmode, int *bits_out) {
int i; for (size_t i = 0; i < sizeof(packers) / sizeof(*packers); i++) {
if (packers[i].mode == mode && packers[i].rawmode == rawmode) {
/* find a suitable pixel packer */
for (i = 0; packers[i].rawmode; i++) {
if (strcmp(packers[i].mode, mode) == 0 &&
strcmp(packers[i].rawmode, rawmode) == 0) {
if (bits_out) { if (bits_out) {
*bits_out = packers[i].bits; *bits_out = packers[i].bits;
} }

9
src/libImaging/Palette.c
View File

@ -21,13 +21,13 @@
#include <math.h> #include <math.h>
ImagingPalette ImagingPalette
ImagingPaletteNew(const char *mode) { ImagingPaletteNew(const ModeID mode) {
/* Create a palette object */ /* Create a palette object */
int i; int i;
ImagingPalette palette; ImagingPalette palette;
if (strcmp(mode, "RGB") && strcmp(mode, "RGBA")) { if (mode != IMAGING_MODE_RGB && mode != IMAGING_MODE_RGBA) {
return (ImagingPalette)ImagingError_ModeError(); return (ImagingPalette)ImagingError_ModeError();
} }
@ -36,8 +36,7 @@ ImagingPaletteNew(const char *mode) {
return (ImagingPalette)ImagingError_MemoryError(); return (ImagingPalette)ImagingError_MemoryError();
} }
strncpy(palette->mode, mode, IMAGING_MODE_LENGTH - 1); palette->mode = mode;
palette->mode[IMAGING_MODE_LENGTH - 1] = 0;
palette->size = 0; palette->size = 0;
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
@ -54,7 +53,7 @@ ImagingPaletteNewBrowser(void) {
int i, r, g, b; int i, r, g, b;
ImagingPalette palette; ImagingPalette palette;
palette = ImagingPaletteNew("RGB"); palette = ImagingPaletteNew(IMAGING_MODE_RGB);
if (!palette) { if (!palette) {
return NULL; return NULL;
} }

38
src/libImaging/Paste.c
View File

@ -79,8 +79,8 @@ paste_mask_1(
PREPARE_PASTE_LOOP(); PREPARE_PASTE_LOOP();
if (imOut->image8) { if (imOut->image8) {
int in_i16 = strncmp(imIn->mode, "I;16", 4) == 0; int in_i16 = isModeI16(imIn->mode);
int out_i16 = strncmp(imOut->mode, "I;16", 4) == 0; int out_i16 = isModeI16(imOut->mode);
for (; y != y_end; y += offset) { for (; y != y_end; y += offset) {
UINT8 *out = imOut->image8[y + dy] + dx; UINT8 *out = imOut->image8[y + dy] + dx;
if (out_i16) { if (out_i16) {
@ -322,31 +322,26 @@ ImagingPaste(
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
paste(imOut, imIn, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize); paste(imOut, imIn, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_1) {
} else if (strcmp(imMask->mode, "1") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
paste_mask_1(imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize); paste_mask_1(imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_L) {
} else if (strcmp(imMask->mode, "L") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
paste_mask_L(imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize); paste_mask_L(imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_LA || imMask->mode == IMAGING_MODE_RGBA) {
} else if (strcmp(imMask->mode, "LA") == 0 || strcmp(imMask->mode, "RGBA") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
paste_mask_RGBA( paste_mask_RGBA(
imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize
); );
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_RGBa) {
} else if (strcmp(imMask->mode, "RGBa") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
paste_mask_RGBa( paste_mask_RGBa(
imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize
); );
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else { } else {
(void)ImagingError_ValueError("bad transparency mask"); (void)ImagingError_ValueError("bad transparency mask");
return -1; return -1;
@ -452,7 +447,7 @@ fill_mask_L(
unsigned int tmp1; unsigned int tmp1;
if (imOut->image8) { if (imOut->image8) {
int i16 = strncmp(imOut->mode, "I;16", 4) == 0; int i16 = isModeI16(imOut->mode);
for (y = 0; y < ysize; y++) { for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx; UINT8 *out = imOut->image8[y + dy] + dx;
if (i16) { if (i16) {
@ -471,9 +466,9 @@ fill_mask_L(
} else { } else {
int alpha_channel = int alpha_channel =
strcmp(imOut->mode, "RGBa") == 0 || strcmp(imOut->mode, "RGBA") == 0 || imOut->mode == IMAGING_MODE_RGBa || imOut->mode == IMAGING_MODE_RGBA ||
strcmp(imOut->mode, "La") == 0 || strcmp(imOut->mode, "LA") == 0 || imOut->mode == IMAGING_MODE_La || imOut->mode == IMAGING_MODE_LA ||
strcmp(imOut->mode, "PA") == 0; imOut->mode == IMAGING_MODE_PA;
for (y = 0; y < ysize; y++) { for (y = 0; y < ysize; y++) {
UINT8 *out = (UINT8 *)imOut->image[y + dy] + dx * pixelsize; UINT8 *out = (UINT8 *)imOut->image[y + dy] + dx * pixelsize;
UINT8 *mask = (UINT8 *)imMask->image[y + sy] + sx; UINT8 *mask = (UINT8 *)imMask->image[y + sy] + sx;
@ -632,27 +627,22 @@ ImagingFill2(
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
fill(imOut, ink, dx0, dy0, xsize, ysize, pixelsize); fill(imOut, ink, dx0, dy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_1) {
} else if (strcmp(imMask->mode, "1") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
fill_mask_1(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize); fill_mask_1(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_L) {
} else if (strcmp(imMask->mode, "L") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
fill_mask_L(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize); fill_mask_L(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_RGBA) {
} else if (strcmp(imMask->mode, "RGBA") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
fill_mask_RGBA(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize); fill_mask_RGBA(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else if (imMask->mode == IMAGING_MODE_RGBa) {
} else if (strcmp(imMask->mode, "RGBa") == 0) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
fill_mask_RGBa(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize); fill_mask_RGBa(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
} else { } else {
(void)ImagingError_ValueError("bad transparency mask"); (void)ImagingError_ValueError("bad transparency mask");
return -1; return -1;

14
src/libImaging/Point.c
View File

@ -128,7 +128,7 @@ im_point_32_8(Imaging imOut, Imaging imIn, im_point_context *context) {
} }
Imaging Imaging
ImagingPoint(Imaging imIn, const char *mode, const void *table) { ImagingPoint(Imaging imIn, ModeID mode, const void *table) {
/* lookup table transform */ /* lookup table transform */
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
@ -140,15 +140,15 @@ ImagingPoint(Imaging imIn, const char *mode, const void *table) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (!mode) { if (mode == IMAGING_MODE_UNKNOWN) {
mode = imIn->mode; mode = imIn->mode;
} }
if (imIn->type != IMAGING_TYPE_UINT8) { if (imIn->type != IMAGING_TYPE_UINT8) {
if (imIn->type != IMAGING_TYPE_INT32 || strcmp(mode, "L") != 0) { if (imIn->type != IMAGING_TYPE_INT32 || mode != IMAGING_MODE_L) {
goto mode_mismatch; goto mode_mismatch;
} }
} else if (!imIn->image8 && strcmp(imIn->mode, mode) != 0) { } else if (!imIn->image8 && imIn->mode != mode) {
goto mode_mismatch; goto mode_mismatch;
} }
@ -210,8 +210,8 @@ ImagingPointTransform(Imaging imIn, double scale, double offset) {
Imaging imOut; Imaging imOut;
int x, y; int x, y;
if (!imIn || (strcmp(imIn->mode, "I") != 0 && strcmp(imIn->mode, "I;16") != 0 && if (!imIn || (imIn->mode != IMAGING_MODE_I && imIn->mode != IMAGING_MODE_I_16 &&
strcmp(imIn->mode, "F") != 0)) { imIn->mode != IMAGING_MODE_F)) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
@ -245,7 +245,7 @@ ImagingPointTransform(Imaging imIn, double scale, double offset) {
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
break; break;
case IMAGING_TYPE_SPECIAL: case IMAGING_TYPE_SPECIAL:
if (strcmp(imIn->mode, "I;16") == 0) { if (imIn->mode == IMAGING_MODE_I_16) {
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
for (y = 0; y < imIn->ysize; y++) { for (y = 0; y < imIn->ysize; y++) {
char *in = (char *)imIn->image[y]; char *in = (char *)imIn->image[y];

18
src/libImaging/Quant.c
View File

@ -1684,13 +1684,13 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
return (Imaging)ImagingError_ValueError("bad number of colors"); return (Imaging)ImagingError_ValueError("bad number of colors");
} }
if (strcmp(im->mode, "L") != 0 && strcmp(im->mode, "P") != 0 && if (im->mode != IMAGING_MODE_L && im->mode != IMAGING_MODE_P &&
strcmp(im->mode, "RGB") != 0 && strcmp(im->mode, "RGBA") != 0) { im->mode != IMAGING_MODE_RGB && im->mode != IMAGING_MODE_RGBA) {
return ImagingError_ModeError(); return ImagingError_ModeError();
} }
/* only octree and imagequant supports RGBA */ /* only octree and imagequant supports RGBA */
if (!strcmp(im->mode, "RGBA") && mode != 2 && mode != 3) { if (im->mode == IMAGING_MODE_RGBA && mode != 2 && mode != 3) {
return ImagingError_ModeError(); return ImagingError_ModeError();
} }
@ -1708,7 +1708,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
/* FIXME: maybe we could load the hash tables directly from the /* FIXME: maybe we could load the hash tables directly from the
image data? */ image data? */
if (!strcmp(im->mode, "L")) { if (im->mode == IMAGING_MODE_L) {
/* grayscale */ /* grayscale */
/* FIXME: converting a "L" image to "P" with 256 colors /* FIXME: converting a "L" image to "P" with 256 colors
@ -1721,7 +1721,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
} }
} }
} else if (!strcmp(im->mode, "P")) { } else if (im->mode == IMAGING_MODE_P) {
/* palette */ /* palette */
pp = im->palette->palette; pp = im->palette->palette;
@ -1736,10 +1736,10 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
} }
} }
} else if (!strcmp(im->mode, "RGB") || !strcmp(im->mode, "RGBA")) { } else if (im->mode == IMAGING_MODE_RGB || im->mode == IMAGING_MODE_RGBA) {
/* true colour */ /* true colour */
withAlpha = !strcmp(im->mode, "RGBA"); withAlpha = im->mode == IMAGING_MODE_RGBA;
int transparency = 0; int transparency = 0;
unsigned char r = 0, g = 0, b = 0; unsigned char r = 0, g = 0, b = 0;
for (i = y = 0; y < im->ysize; y++) { for (i = y = 0; y < im->ysize; y++) {
@ -1834,7 +1834,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
if (result > 0) { if (result > 0) {
imOut = ImagingNewDirty("P", im->xsize, im->ysize); imOut = ImagingNewDirty(IMAGING_MODE_P, im->xsize, im->ysize);
ImagingSectionEnter(&cookie); ImagingSectionEnter(&cookie);
for (i = y = 0; y < im->ysize; y++) { for (i = y = 0; y < im->ysize; y++) {
@ -1859,7 +1859,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
} }
if (withAlpha) { if (withAlpha) {
strcpy(imOut->palette->mode, "RGBA"); imOut->palette->mode = IMAGING_MODE_RGBA;
} }
free(palette); free(palette);

2
src/libImaging/Reduce.c
View File

@ -1452,7 +1452,7 @@ ImagingReduce(Imaging imIn, int xscale, int yscale, int box[4]) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
Imaging imOut = NULL; Imaging imOut = NULL;
if (strcmp(imIn->mode, "P") == 0 || strcmp(imIn->mode, "1") == 0) { if (imIn->mode == IMAGING_MODE_P || imIn->mode == IMAGING_MODE_1) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }

12
src/libImaging/Resample.c
View File

@ -471,9 +471,9 @@ ImagingResampleHorizontal_16bpc(
int bigendian = 0; int bigendian = 0;
if ( if (
strcmp(imIn->mode, "I;16N") == 0 imIn->mode == IMAGING_MODE_I_16N
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
|| strcmp(imIn->mode, "I;16B") == 0 || imIn->mode == IMAGING_MODE_I_16B
#endif #endif
) { ) {
bigendian = 1; bigendian = 1;
@ -511,9 +511,9 @@ ImagingResampleVertical_16bpc(
int bigendian = 0; int bigendian = 0;
if ( if (
strcmp(imIn->mode, "I;16N") == 0 imIn->mode == IMAGING_MODE_I_16N
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
|| strcmp(imIn->mode, "I;16B") == 0 || imIn->mode == IMAGING_MODE_I_16B
#endif #endif
) { ) {
bigendian = 1; bigendian = 1;
@ -648,12 +648,12 @@ ImagingResample(Imaging imIn, int xsize, int ysize, int filter, float box[4]) {
ResampleFunction ResampleHorizontal; ResampleFunction ResampleHorizontal;
ResampleFunction ResampleVertical; ResampleFunction ResampleVertical;
if (strcmp(imIn->mode, "P") == 0 || strcmp(imIn->mode, "1") == 0) { if (imIn->mode == IMAGING_MODE_P || imIn->mode == IMAGING_MODE_1) {
return (Imaging)ImagingError_ModeError(); return (Imaging)ImagingError_ModeError();
} }
if (imIn->type == IMAGING_TYPE_SPECIAL) { if (imIn->type == IMAGING_TYPE_SPECIAL) {
if (strncmp(imIn->mode, "I;16", 4) == 0) { if (isModeI16(imIn->mode)) {
ResampleHorizontal = ImagingResampleHorizontal_16bpc; ResampleHorizontal = ImagingResampleHorizontal_16bpc;
ResampleVertical = ImagingResampleVertical_16bpc; ResampleVertical = ImagingResampleVertical_16bpc;
} else { } else {

59
src/libImaging/Storage.c
View File

@ -42,7 +42,7 @@
*/ */
Imaging Imaging
ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) { ImagingNewPrologueSubtype(const ModeID mode, int xsize, int ysize, int size) {
Imaging im; Imaging im;
/* linesize overflow check, roughly the current largest space req'd */ /* linesize overflow check, roughly the current largest space req'd */
@ -62,37 +62,37 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
im->type = IMAGING_TYPE_UINT8; im->type = IMAGING_TYPE_UINT8;
strcpy(im->arrow_band_format, "C"); strcpy(im->arrow_band_format, "C");
if (strcmp(mode, "1") == 0) { if (mode == IMAGING_MODE_1) {
/* 1-bit images */ /* 1-bit images */
im->bands = im->pixelsize = 1; im->bands = im->pixelsize = 1;
im->linesize = xsize; im->linesize = xsize;
strcpy(im->band_names[0], "1"); strcpy(im->band_names[0], "1");
} else if (strcmp(mode, "P") == 0) { } else if (mode == IMAGING_MODE_P) {
/* 8-bit palette mapped images */ /* 8-bit palette mapped images */
im->bands = im->pixelsize = 1; im->bands = im->pixelsize = 1;
im->linesize = xsize; im->linesize = xsize;
im->palette = ImagingPaletteNew("RGB"); im->palette = ImagingPaletteNew(IMAGING_MODE_RGB);
strcpy(im->band_names[0], "P"); strcpy(im->band_names[0], "P");
} else if (strcmp(mode, "PA") == 0) { } else if (mode == IMAGING_MODE_PA) {
/* 8-bit palette with alpha */ /* 8-bit palette with alpha */
im->bands = 2; im->bands = 2;
im->pixelsize = 4; /* store in image32 memory */ im->pixelsize = 4; /* store in image32 memory */
im->linesize = xsize * 4; im->linesize = xsize * 4;
im->palette = ImagingPaletteNew("RGB"); im->palette = ImagingPaletteNew(IMAGING_MODE_RGB);
strcpy(im->band_names[0], "P"); strcpy(im->band_names[0], "P");
strcpy(im->band_names[1], "X"); strcpy(im->band_names[1], "X");
strcpy(im->band_names[2], "X"); strcpy(im->band_names[2], "X");
strcpy(im->band_names[3], "A"); strcpy(im->band_names[3], "A");
} else if (strcmp(mode, "L") == 0) { } else if (mode == IMAGING_MODE_L) {
/* 8-bit grayscale (luminance) images */ /* 8-bit grayscale (luminance) images */
im->bands = im->pixelsize = 1; im->bands = im->pixelsize = 1;
im->linesize = xsize; im->linesize = xsize;
strcpy(im->band_names[0], "L"); strcpy(im->band_names[0], "L");
} else if (strcmp(mode, "LA") == 0) { } else if (mode == IMAGING_MODE_LA) {
/* 8-bit grayscale (luminance) with alpha */ /* 8-bit grayscale (luminance) with alpha */
im->bands = 2; im->bands = 2;
im->pixelsize = 4; /* store in image32 memory */ im->pixelsize = 4; /* store in image32 memory */
@ -102,7 +102,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "X"); strcpy(im->band_names[2], "X");
strcpy(im->band_names[3], "A"); strcpy(im->band_names[3], "A");
} else if (strcmp(mode, "La") == 0) { } else if (mode == IMAGING_MODE_La) {
/* 8-bit grayscale (luminance) with premultiplied alpha */ /* 8-bit grayscale (luminance) with premultiplied alpha */
im->bands = 2; im->bands = 2;
im->pixelsize = 4; /* store in image32 memory */ im->pixelsize = 4; /* store in image32 memory */
@ -112,7 +112,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "X"); strcpy(im->band_names[2], "X");
strcpy(im->band_names[3], "a"); strcpy(im->band_names[3], "a");
} else if (strcmp(mode, "F") == 0) { } else if (mode == IMAGING_MODE_F) {
/* 32-bit floating point images */ /* 32-bit floating point images */
im->bands = 1; im->bands = 1;
im->pixelsize = 4; im->pixelsize = 4;
@ -121,7 +121,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->arrow_band_format, "f"); strcpy(im->arrow_band_format, "f");
strcpy(im->band_names[0], "F"); strcpy(im->band_names[0], "F");
} else if (strcmp(mode, "I") == 0) { } else if (mode == IMAGING_MODE_I) {
/* 32-bit integer images */ /* 32-bit integer images */
im->bands = 1; im->bands = 1;
im->pixelsize = 4; im->pixelsize = 4;
@ -130,8 +130,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->arrow_band_format, "i"); strcpy(im->arrow_band_format, "i");
strcpy(im->band_names[0], "I"); strcpy(im->band_names[0], "I");
} else if (strcmp(mode, "I;16") == 0 || strcmp(mode, "I;16L") == 0 || } else if (isModeI16(mode)) {
strcmp(mode, "I;16B") == 0 || strcmp(mode, "I;16N") == 0) {
/* EXPERIMENTAL */ /* EXPERIMENTAL */
/* 16-bit raw integer images */ /* 16-bit raw integer images */
im->bands = 1; im->bands = 1;
@ -141,7 +140,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->arrow_band_format, "s"); strcpy(im->arrow_band_format, "s");
strcpy(im->band_names[0], "I"); strcpy(im->band_names[0], "I");
} else if (strcmp(mode, "RGB") == 0) { } else if (mode == IMAGING_MODE_RGB) {
/* 24-bit true colour images */ /* 24-bit true colour images */
im->bands = 3; im->bands = 3;
im->pixelsize = 4; im->pixelsize = 4;
@ -151,7 +150,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "B"); strcpy(im->band_names[2], "B");
strcpy(im->band_names[3], "X"); strcpy(im->band_names[3], "X");
} else if (strcmp(mode, "RGBX") == 0) { } else if (mode == IMAGING_MODE_RGBX) {
/* 32-bit true colour images with padding */ /* 32-bit true colour images with padding */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = xsize * 4;
@ -160,7 +159,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "B"); strcpy(im->band_names[2], "B");
strcpy(im->band_names[3], "X"); strcpy(im->band_names[3], "X");
} else if (strcmp(mode, "RGBA") == 0) { } else if (mode == IMAGING_MODE_RGBA) {
/* 32-bit true colour images with alpha */ /* 32-bit true colour images with alpha */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = xsize * 4;
@ -169,7 +168,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "B"); strcpy(im->band_names[2], "B");
strcpy(im->band_names[3], "A"); strcpy(im->band_names[3], "A");
} else if (strcmp(mode, "RGBa") == 0) { } else if (mode == IMAGING_MODE_RGBa) {
/* 32-bit true colour images with premultiplied alpha */ /* 32-bit true colour images with premultiplied alpha */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = xsize * 4;
@ -178,7 +177,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "B"); strcpy(im->band_names[2], "B");
strcpy(im->band_names[3], "a"); strcpy(im->band_names[3], "a");
} else if (strcmp(mode, "CMYK") == 0) { } else if (mode == IMAGING_MODE_CMYK) {
/* 32-bit colour separation */ /* 32-bit colour separation */
im->bands = im->pixelsize = 4; im->bands = im->pixelsize = 4;
im->linesize = xsize * 4; im->linesize = xsize * 4;
@ -187,7 +186,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "Y"); strcpy(im->band_names[2], "Y");
strcpy(im->band_names[3], "K"); strcpy(im->band_names[3], "K");
} else if (strcmp(mode, "YCbCr") == 0) { } else if (mode == IMAGING_MODE_YCbCr) {
/* 24-bit video format */ /* 24-bit video format */
im->bands = 3; im->bands = 3;
im->pixelsize = 4; im->pixelsize = 4;
@ -197,7 +196,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "Cr"); strcpy(im->band_names[2], "Cr");
strcpy(im->band_names[3], "X"); strcpy(im->band_names[3], "X");
} else if (strcmp(mode, "LAB") == 0) { } else if (mode == IMAGING_MODE_LAB) {
/* 24-bit color, luminance, + 2 color channels */ /* 24-bit color, luminance, + 2 color channels */
/* L is uint8, a,b are int8 */ /* L is uint8, a,b are int8 */
im->bands = 3; im->bands = 3;
@ -208,7 +207,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
strcpy(im->band_names[2], "b"); strcpy(im->band_names[2], "b");
strcpy(im->band_names[3], "X"); strcpy(im->band_names[3], "X");
} else if (strcmp(mode, "HSV") == 0) { } else if (mode == IMAGING_MODE_HSV) {
/* 24-bit color, luminance, + 2 color channels */ /* 24-bit color, luminance, + 2 color channels */
/* L is uint8, a,b are int8 */ /* L is uint8, a,b are int8 */
im->bands = 3; im->bands = 3;
@ -225,7 +224,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
} }
/* Setup image descriptor */ /* Setup image descriptor */
strcpy(im->mode, mode); im->mode = mode;
/* Pointer array (allocate at least one line, to avoid MemoryError /* Pointer array (allocate at least one line, to avoid MemoryError
exceptions on platforms where calloc(0, x) returns NULL) */ exceptions on platforms where calloc(0, x) returns NULL) */
@ -257,7 +256,7 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
} }
Imaging Imaging
ImagingNewPrologue(const char *mode, int xsize, int ysize) { ImagingNewPrologue(const ModeID mode, int xsize, int ysize) {
return ImagingNewPrologueSubtype( return ImagingNewPrologueSubtype(
mode, xsize, ysize, sizeof(struct ImagingMemoryInstance) mode, xsize, ysize, sizeof(struct ImagingMemoryInstance)
); );
@ -594,7 +593,7 @@ ImagingBorrowArrow(
*/ */
Imaging Imaging
ImagingNewInternal(const char *mode, int xsize, int ysize, int dirty) { ImagingNewInternal(const ModeID mode, int xsize, int ysize, int dirty) {
Imaging im; Imaging im;
if (xsize < 0 || ysize < 0) { if (xsize < 0 || ysize < 0) {
@ -630,7 +629,7 @@ ImagingNewInternal(const char *mode, int xsize, int ysize, int dirty) {
} }
Imaging Imaging
ImagingNew(const char *mode, int xsize, int ysize) { ImagingNew(const ModeID mode, int xsize, int ysize) {
if (ImagingDefaultArena.use_block_allocator) { if (ImagingDefaultArena.use_block_allocator) {
return ImagingNewBlock(mode, xsize, ysize); return ImagingNewBlock(mode, xsize, ysize);
} }
@ -638,7 +637,7 @@ ImagingNew(const char *mode, int xsize, int ysize) {
} }
Imaging Imaging
ImagingNewDirty(const char *mode, int xsize, int ysize) { ImagingNewDirty(const ModeID mode, int xsize, int ysize) {
if (ImagingDefaultArena.use_block_allocator) { if (ImagingDefaultArena.use_block_allocator) {
return ImagingNewBlock(mode, xsize, ysize); return ImagingNewBlock(mode, xsize, ysize);
} }
@ -646,7 +645,7 @@ ImagingNewDirty(const char *mode, int xsize, int ysize) {
} }
Imaging Imaging
ImagingNewBlock(const char *mode, int xsize, int ysize) { ImagingNewBlock(const ModeID mode, int xsize, int ysize) {
Imaging im; Imaging im;
if (xsize < 0 || ysize < 0) { if (xsize < 0 || ysize < 0) {
@ -668,7 +667,7 @@ ImagingNewBlock(const char *mode, int xsize, int ysize) {
Imaging Imaging
ImagingNewArrow( ImagingNewArrow(
const char *mode, const ModeID mode,
int xsize, int xsize,
int ysize, int ysize,
PyObject *schema_capsule, PyObject *schema_capsule,
@ -741,12 +740,12 @@ ImagingNewArrow(
} }
Imaging Imaging
ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn) { ImagingNew2Dirty(const ModeID mode, Imaging imOut, Imaging imIn) {
/* allocate or validate output image */ /* allocate or validate output image */
if (imOut) { if (imOut) {
/* make sure images match */ /* make sure images match */
if (strcmp(imOut->mode, mode) != 0 || imOut->xsize != imIn->xsize || if (imOut->mode != mode || imOut->xsize != imIn->xsize ||
imOut->ysize != imIn->ysize) { imOut->ysize != imIn->ysize) {
return ImagingError_Mismatch(); return ImagingError_Mismatch();
} }

38
src/libImaging/TiffDecode.c
View File

@ -246,14 +246,26 @@ _pickUnpackers(
// We'll pick appropriate set of unpackers depending on planar_configuration // We'll pick appropriate set of unpackers depending on planar_configuration
// It does not matter if data is RGB(A), CMYK or LUV really, // It does not matter if data is RGB(A), CMYK or LUV really,
// we just copy it plane by plane // we just copy it plane by plane
unpackers[0] = unpackers[0] = ImagingFindUnpacker(
ImagingFindUnpacker("RGBA", bits_per_sample == 16 ? "R;16N" : "R", NULL); IMAGING_MODE_RGBA,
unpackers[1] = bits_per_sample == 16 ? IMAGING_RAWMODE_R_16N : IMAGING_RAWMODE_R,
ImagingFindUnpacker("RGBA", bits_per_sample == 16 ? "G;16N" : "G", NULL); NULL
unpackers[2] = );
ImagingFindUnpacker("RGBA", bits_per_sample == 16 ? "B;16N" : "B", NULL); unpackers[1] = ImagingFindUnpacker(
unpackers[3] = IMAGING_MODE_RGBA,
ImagingFindUnpacker("RGBA", bits_per_sample == 16 ? "A;16N" : "A", NULL); bits_per_sample == 16 ? IMAGING_RAWMODE_G_16N : IMAGING_RAWMODE_G,
NULL
);
unpackers[2] = ImagingFindUnpacker(
IMAGING_MODE_RGBA,
bits_per_sample == 16 ? IMAGING_RAWMODE_B_16N : IMAGING_RAWMODE_B,
NULL
);
unpackers[3] = ImagingFindUnpacker(
IMAGING_MODE_RGBA,
bits_per_sample == 16 ? IMAGING_RAWMODE_A_16N : IMAGING_RAWMODE_A,
NULL
);
return im->bands; return im->bands;
} else { } else {
@ -644,7 +656,7 @@ ImagingLibTiffDecode(
); );
TRACE( TRACE(
("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n", ("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
im->mode, getModeData(im->mode)->name,
im->type, im->type,
im->bands, im->bands,
im->xsize, im->xsize,
@ -755,7 +767,7 @@ ImagingLibTiffDecode(
if (!state->errcode) { if (!state->errcode) {
// Check if raw mode was RGBa and it was stored on separate planes // Check if raw mode was RGBa and it was stored on separate planes
// so we have to convert it to RGBA // so we have to convert it to RGBA
if (planes > 3 && strcmp(im->mode, "RGBA") == 0) { if (planes > 3 && im->mode == IMAGING_MODE_RGBA) {
uint16_t extrasamples; uint16_t extrasamples;
uint16_t *sampleinfo; uint16_t *sampleinfo;
ImagingShuffler shuffle; ImagingShuffler shuffle;
@ -767,7 +779,9 @@ ImagingLibTiffDecode(
if (extrasamples >= 1 && (sampleinfo[0] == EXTRASAMPLE_UNSPECIFIED || if (extrasamples >= 1 && (sampleinfo[0] == EXTRASAMPLE_UNSPECIFIED ||
sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA)) { sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA)) {
shuffle = ImagingFindUnpacker("RGBA", "RGBa", NULL); shuffle = ImagingFindUnpacker(
IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa, NULL
);
for (y = state->yoff; y < state->ysize; y++) { for (y = state->yoff; y < state->ysize; y++) {
UINT8 *ptr = (UINT8 *)im->image[y + state->yoff] + UINT8 *ptr = (UINT8 *)im->image[y + state->yoff] +
@ -991,7 +1005,7 @@ ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int byt
); );
TRACE( TRACE(
("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n", ("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
im->mode, getModeData(im->mode)->name,
im->type, im->type,
im->bands, im->bands,
im->xsize, im->xsize,

483
src/libImaging/Unpack.c
View File

@ -1542,12 +1542,11 @@ band316L(UINT8 *out, const UINT8 *in, int pixels) {
} }
static struct { static struct {
const char *mode; const ModeID mode;
const char *rawmode; const RawModeID rawmode;
int bits; int bits;
ImagingShuffler unpack; ImagingShuffler unpack;
} unpackers[] = { } unpackers[] = {
/* raw mode syntax is "<mode>;<bits><flags>" where "bits" defaults /* raw mode syntax is "<mode>;<bits><flags>" where "bits" defaults
depending on mode (1 for "1", 8 for "P" and "L", etc), and depending on mode (1 for "1", 8 for "P" and "L", etc), and
"flags" should be given in alphabetical order. if both bits "flags" should be given in alphabetical order. if both bits
@ -1560,299 +1559,295 @@ static struct {
/* exception: rawmodes "I" and "F" are always native endian byte order */ /* exception: rawmodes "I" and "F" are always native endian byte order */
/* bilevel */ /* bilevel */
{"1", "1", 1, unpack1}, {IMAGING_MODE_1, IMAGING_RAWMODE_1, 1, unpack1},
{"1", "1;I", 1, unpack1I}, {IMAGING_MODE_1, IMAGING_RAWMODE_1_I, 1, unpack1I},
{"1", "1;R", 1, unpack1R}, {IMAGING_MODE_1, IMAGING_RAWMODE_1_R, 1, unpack1R},
{"1", "1;IR", 1, unpack1IR}, {IMAGING_MODE_1, IMAGING_RAWMODE_1_IR, 1, unpack1IR},
{"1", "1;8", 8, unpack18}, {IMAGING_MODE_1, IMAGING_RAWMODE_1_8, 8, unpack18},
/* grayscale */ /* grayscale */
{"L", "L;2", 2, unpackL2}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_2, 2, unpackL2},
{"L", "L;2I", 2, unpackL2I}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_2I, 2, unpackL2I},
{"L", "L;2R", 2, unpackL2R}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_2R, 2, unpackL2R},
{"L", "L;2IR", 2, unpackL2IR}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_2IR, 2, unpackL2IR},
{"L", "L;4", 4, unpackL4}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_4, 4, unpackL4},
{"L", "L;4I", 4, unpackL4I}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_4I, 4, unpackL4I},
{"L", "L;4R", 4, unpackL4R}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_4R, 4, unpackL4R},
{"L", "L;4IR", 4, unpackL4IR}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_4IR, 4, unpackL4IR},
{"L", "L", 8, copy1}, {IMAGING_MODE_L, IMAGING_RAWMODE_L, 8, copy1},
{"L", "L;I", 8, unpackLI}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_I, 8, unpackLI},
{"L", "L;R", 8, unpackLR}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_R, 8, unpackLR},
{"L", "L;16", 16, unpackL16}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_16, 16, unpackL16},
{"L", "L;16B", 16, unpackL16B}, {IMAGING_MODE_L, IMAGING_RAWMODE_L_16B, 16, unpackL16B},
/* grayscale w. alpha */ /* grayscale w. alpha */
{"LA", "LA", 16, unpackLA}, {IMAGING_MODE_LA, IMAGING_RAWMODE_LA, 16, unpackLA},
{"LA", "LA;L", 16, unpackLAL}, {IMAGING_MODE_LA, IMAGING_RAWMODE_LA_L, 16, unpackLAL},
/* grayscale w. alpha premultiplied */ /* grayscale w. alpha premultiplied */
{"La", "La", 16, unpackLA}, {IMAGING_MODE_La, IMAGING_RAWMODE_La, 16, unpackLA},
/* palette */ /* palette */
{"P", "P;1", 1, unpackP1}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_1, 1, unpackP1},
{"P", "P;2", 2, unpackP2}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_2, 2, unpackP2},
{"P", "P;2L", 2, unpackP2L}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_2L, 2, unpackP2L},
{"P", "P;4", 4, unpackP4}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_4, 4, unpackP4},
{"P", "P;4L", 4, unpackP4L}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_4L, 4, unpackP4L},
{"P", "P", 8, copy1}, {IMAGING_MODE_P, IMAGING_RAWMODE_P, 8, copy1},
{"P", "P;R", 8, unpackLR}, {IMAGING_MODE_P, IMAGING_RAWMODE_P_R, 8, unpackLR},
{"P", "L", 8, copy1}, {IMAGING_MODE_P, IMAGING_RAWMODE_L, 8, copy1},
{"P", "PX", 16, unpackL16B}, {IMAGING_MODE_P, IMAGING_RAWMODE_PX, 16, unpackL16B},
/* palette w. alpha */ /* palette w. alpha */
{"PA", "PA", 16, unpackLA}, {IMAGING_MODE_PA, IMAGING_RAWMODE_PA, 16, unpackLA},
{"PA", "PA;L", 16, unpackLAL}, {IMAGING_MODE_PA, IMAGING_RAWMODE_PA_L, 16, unpackLAL},
{"PA", "LA", 16, unpackLA}, {IMAGING_MODE_PA, IMAGING_RAWMODE_LA, 16, unpackLA},
/* true colour */ /* true colour */
{"RGB", "RGB", 24, ImagingUnpackRGB}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB, 24, ImagingUnpackRGB},
{"RGB", "RGB;L", 24, unpackRGBL}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_L, 24, unpackRGBL},
{"RGB", "RGB;R", 24, unpackRGBR}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_R, 24, unpackRGBR},
{"RGB", "RGB;16L", 48, unpackRGB16L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16L, 48, unpackRGB16L},
{"RGB", "RGB;16B", 48, unpackRGB16B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16B, 48, unpackRGB16B},
{"RGB", "BGR", 24, ImagingUnpackBGR}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR, 24, ImagingUnpackBGR},
{"RGB", "RGB;15", 16, ImagingUnpackRGB15}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_15, 16, ImagingUnpackRGB15},
{"RGB", "BGR;15", 16, ImagingUnpackBGR15}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_15, 16, ImagingUnpackBGR15},
{"RGB", "RGB;16", 16, ImagingUnpackRGB16}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16, 16, ImagingUnpackRGB16},
{"RGB", "BGR;16", 16, ImagingUnpackBGR16}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_16, 16, ImagingUnpackBGR16},
{"RGB", "RGBX;16L", 64, unpackRGBA16L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16L, 64, unpackRGBA16L},
{"RGB", "RGBX;16B", 64, unpackRGBA16B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16B, 64, unpackRGBA16B},
{"RGB", "RGB;4B", 16, ImagingUnpackRGB4B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_4B, 16, ImagingUnpackRGB4B},
{"RGB", "BGR;5", 16, ImagingUnpackBGR15}, /* compat */ {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_5, 16, ImagingUnpackBGR15}, /* compat */
{"RGB", "RGBX", 32, copy4}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX, 32, copy4},
{"RGB", "RGBX;L", 32, unpackRGBAL}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_L, 32, unpackRGBAL},
{"RGB", "RGBXX", 40, copy4skip1}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBXX, 40, copy4skip1},
{"RGB", "RGBXXX", 48, copy4skip2}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBXXX, 48, copy4skip2},
{"RGB", "RGBA;L", 32, unpackRGBAL}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA_L, 32, unpackRGBAL},
{"RGB", "RGBA;15", 16, ImagingUnpackRGBA15}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA_15, 16, ImagingUnpackRGBA15},
{"RGB", "BGRX", 32, ImagingUnpackBGRX}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGRX, 32, ImagingUnpackBGRX},
{"RGB", "BGXR", 32, ImagingUnpackBGXR}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_BGXR, 32, ImagingUnpackBGXR},
{"RGB", "XRGB", 32, ImagingUnpackXRGB}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_XRGB, 32, ImagingUnpackXRGB},
{"RGB", "XBGR", 32, ImagingUnpackXBGR}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_XBGR, 32, ImagingUnpackXBGR},
{"RGB", "YCC;P", 24, ImagingUnpackYCC}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_YCC_P, 24, ImagingUnpackYCC},
{"RGB", "R", 8, band0}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_R, 8, band0},
{"RGB", "G", 8, band1}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_G, 8, band1},
{"RGB", "B", 8, band2}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_B, 8, band2},
{"RGB", "R;16L", 16, band016L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16L, 16, band016L},
{"RGB", "G;16L", 16, band116L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16L, 16, band116L},
{"RGB", "B;16L", 16, band216L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16L, 16, band216L},
{"RGB", "R;16B", 16, band016B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16B, 16, band016B},
{"RGB", "G;16B", 16, band116B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16B, 16, band116B},
{"RGB", "B;16B", 16, band216B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16B, 16, band216B},
{"RGB", "CMYK", 32, cmyk2rgb}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_CMYK, 32, cmyk2rgb},
/* true colour w. alpha */ /* true colour w. alpha */
{"RGBA", "LA", 16, unpackRGBALA}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_LA, 16, unpackRGBALA},
{"RGBA", "LA;16B", 32, unpackRGBALA16B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_LA_16B, 32, unpackRGBALA16B},
{"RGBA", "RGBA", 32, copy4}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA, 32, copy4},
{"RGBA", "RGBAX", 40, copy4skip1}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBAX, 40, copy4skip1},
{"RGBA", "RGBAXX", 48, copy4skip2}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBAXX, 48, copy4skip2},
{"RGBA", "RGBa", 32, unpackRGBa}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa, 32, unpackRGBa},
{"RGBA", "RGBaX", 40, unpackRGBaskip1}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBaX, 40, unpackRGBaskip1},
{"RGBA", "RGBaXX", 48, unpackRGBaskip2}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBaXX, 48, unpackRGBaskip2},
{"RGBA", "RGBa;16L", 64, unpackRGBa16L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16L, 64, unpackRGBa16L},
{"RGBA", "RGBa;16B", 64, unpackRGBa16B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16B, 64, unpackRGBa16B},
{"RGBA", "BGR", 24, ImagingUnpackBGR}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGR, 24, ImagingUnpackBGR},
{"RGBA", "BGRa", 32, unpackBGRa}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRa, 32, unpackBGRa},
{"RGBA", "RGBA;I", 32, unpackRGBAI}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_I, 32, unpackRGBAI},
{"RGBA", "RGBA;L", 32, unpackRGBAL}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_L, 32, unpackRGBAL},
{"RGBA", "RGBA;15", 16, ImagingUnpackRGBA15}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_15, 16, ImagingUnpackRGBA15},
{"RGBA", "BGRA;15", 16, ImagingUnpackBGRA15}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_15, 16, ImagingUnpackBGRA15},
{"RGBA", "BGRA;15Z", 16, ImagingUnpackBGRA15Z}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_15Z, 16, ImagingUnpackBGRA15Z},
{"RGBA", "RGBA;4B", 16, ImagingUnpackRGBA4B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_4B, 16, ImagingUnpackRGBA4B},
{"RGBA", "RGBA;16L", 64, unpackRGBA16L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16L, 64, unpackRGBA16L},
{"RGBA", "RGBA;16B", 64, unpackRGBA16B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16B, 64, unpackRGBA16B},
{"RGBA", "BGRA", 32, unpackBGRA}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA, 32, unpackBGRA},
{"RGBA", "BGRA;16L", 64, unpackBGRA16L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_16L, 64, unpackBGRA16L},
{"RGBA", "BGRA;16B", 64, unpackBGRA16B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_16B, 64, unpackBGRA16B},
{"RGBA", "BGAR", 32, unpackBGAR}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGAR, 32, unpackBGAR},
{"RGBA", "ARGB", 32, unpackARGB}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_ARGB, 32, unpackARGB},
{"RGBA", "ABGR", 32, unpackABGR}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_ABGR, 32, unpackABGR},
{"RGBA", "YCCA;P", 32, ImagingUnpackYCCA}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_YCCA_P, 32, ImagingUnpackYCCA},
{"RGBA", "R", 8, band0}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_R, 8, band0},
{"RGBA", "G", 8, band1}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_G, 8, band1},
{"RGBA", "B", 8, band2}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_B, 8, band2},
{"RGBA", "A", 8, band3}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_A, 8, band3},
{"RGBA", "R;16L", 16, band016L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16L, 16, band016L},
{"RGBA", "G;16L", 16, band116L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16L, 16, band116L},
{"RGBA", "B;16L", 16, band216L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16L, 16, band216L},
{"RGBA", "A;16L", 16, band316L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16L, 16, band316L},
{"RGBA", "R;16B", 16, band016B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16B, 16, band016B},
{"RGBA", "G;16B", 16, band116B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16B, 16, band116B},
{"RGBA", "B;16B", 16, band216B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16B, 16, band216B},
{"RGBA", "A;16B", 16, band316B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16B, 16, band316B},
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
{"RGB", "RGB;16N", 48, unpackRGB16B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16N, 48, unpackRGB16B},
{"RGB", "RGBX;16N", 64, unpackRGBA16B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16B},
{"RGBA", "RGBa;16N", 64, unpackRGBa16B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16N, 64, unpackRGBa16B},
{"RGBA", "RGBA;16N", 64, unpackRGBA16B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16N, 64, unpackRGBA16B},
{"RGBX", "RGBX;16N", 64, unpackRGBA16B}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16B},
{"RGB", "R;16N", 16, band016B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16N, 16, band016B},
{"RGB", "G;16N", 16, band116B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16N, 16, band116B},
{"RGB", "B;16N", 16, band216B}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16N, 16, band216B},
{"RGBA", "R;16N", 16, band016B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16N, 16, band016B},
{"RGBA", "G;16N", 16, band116B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16N, 16, band116B},
{"RGBA", "B;16N", 16, band216B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16N, 16, band216B},
{"RGBA", "A;16N", 16, band316B}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16N, 16, band316B},
#else #else
{"RGB", "RGB;16N", 48, unpackRGB16L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16N, 48, unpackRGB16L},
{"RGB", "RGBX;16N", 64, unpackRGBA16L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16L},
{"RGBA", "RGBa;16N", 64, unpackRGBa16L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16N, 64, unpackRGBa16L},
{"RGBA", "RGBA;16N", 64, unpackRGBA16L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16N, 64, unpackRGBA16L},
{"RGBX", "RGBX;16N", 64, unpackRGBA16L}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16L},
{"RGB", "R;16N", 16, band016L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16N, 16, band016L},
{"RGB", "G;16N", 16, band116L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16N, 16, band116L},
{"RGB", "B;16N", 16, band216L}, {IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16N, 16, band216L},
{"RGBA", "R;16N", 16, band016L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16N, 16, band016L},
{"RGBA", "G;16N", 16, band116L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16N, 16, band116L},
{"RGBA", "B;16N", 16, band216L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16N, 16, band216L},
{"RGBA", "A;16N", 16, band316L}, {IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16N, 16, band316L},
#endif #endif
/* true colour w. alpha premultiplied */ /* true colour w. alpha premultiplied */
{"RGBa", "RGBa", 32, copy4}, {IMAGING_MODE_RGBa, IMAGING_RAWMODE_RGBa, 32, copy4},
{"RGBa", "BGRa", 32, unpackBGRA}, {IMAGING_MODE_RGBa, IMAGING_RAWMODE_BGRa, 32, unpackBGRA},
{"RGBa", "aRGB", 32, unpackARGB}, {IMAGING_MODE_RGBa, IMAGING_RAWMODE_aRGB, 32, unpackARGB},
{"RGBa", "aBGR", 32, unpackABGR}, {IMAGING_MODE_RGBa, IMAGING_RAWMODE_aBGR, 32, unpackABGR},
/* true colour w. padding */ /* true colour w. padding */
{"RGBX", "RGB", 24, ImagingUnpackRGB}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB, 24, ImagingUnpackRGB},
{"RGBX", "RGB;L", 24, unpackRGBL}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_L, 24, unpackRGBL},
{"RGBX", "RGB;16B", 48, unpackRGB16B}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_16B, 48, unpackRGB16B},
{"RGBX", "BGR", 24, ImagingUnpackBGR}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR, 24, ImagingUnpackBGR},
{"RGBX", "RGB;15", 16, ImagingUnpackRGB15}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_15, 16, ImagingUnpackRGB15},
{"RGBX", "BGR;15", 16, ImagingUnpackBGR15}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR_15, 16, ImagingUnpackBGR15},
{"RGBX", "RGB;4B", 16, ImagingUnpackRGB4B}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_4B, 16, ImagingUnpackRGB4B},
{"RGBX", "BGR;5", 16, ImagingUnpackBGR15}, /* compat */ {IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR_5, 16, ImagingUnpackBGR15}, /* compat */
{"RGBX", "RGBX", 32, copy4}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX, 32, copy4},
{"RGBX", "RGBXX", 40, copy4skip1}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBXX, 40, copy4skip1},
{"RGBX", "RGBXXX", 48, copy4skip2}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBXXX, 48, copy4skip2},
{"RGBX", "RGBX;L", 32, unpackRGBAL}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_L, 32, unpackRGBAL},
{"RGBX", "RGBX;16L", 64, unpackRGBA16L}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16L, 64, unpackRGBA16L},
{"RGBX", "RGBX;16B", 64, unpackRGBA16B}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16B, 64, unpackRGBA16B},
{"RGBX", "BGRX", 32, ImagingUnpackBGRX}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGRX, 32, ImagingUnpackBGRX},
{"RGBX", "XRGB", 32, ImagingUnpackXRGB}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_XRGB, 32, ImagingUnpackXRGB},
{"RGBX", "XBGR", 32, ImagingUnpackXBGR}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_XBGR, 32, ImagingUnpackXBGR},
{"RGBX", "YCC;P", 24, ImagingUnpackYCC}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_YCC_P, 24, ImagingUnpackYCC},
{"RGBX", "R", 8, band0}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_R, 8, band0},
{"RGBX", "G", 8, band1}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_G, 8, band1},
{"RGBX", "B", 8, band2}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_B, 8, band2},
{"RGBX", "X", 8, band3}, {IMAGING_MODE_RGBX, IMAGING_RAWMODE_X, 8, band3},
/* colour separation */ /* colour separation */
{"CMYK", "CMYK", 32, copy4}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK, 32, copy4},
{"CMYK", "CMYKX", 40, copy4skip1}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYKX, 40, copy4skip1},
{"CMYK", "CMYKXX", 48, copy4skip2}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYKXX, 48, copy4skip2},
{"CMYK", "CMYK;I", 32, unpackCMYKI}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_I, 32, unpackCMYKI},
{"CMYK", "CMYK;L", 32, unpackRGBAL}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_L, 32, unpackRGBAL},
{"CMYK", "CMYK;16L", 64, unpackRGBA16L}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16L, 64, unpackRGBA16L},
{"CMYK", "CMYK;16B", 64, unpackRGBA16B}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16B, 64, unpackRGBA16B},
{"CMYK", "C", 8, band0}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_C, 8, band0},
{"CMYK", "M", 8, band1}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_M, 8, band1},
{"CMYK", "Y", 8, band2}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y, 8, band2},
{"CMYK", "K", 8, band3}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_K, 8, band3},
{"CMYK", "C;I", 8, band0I}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_C_I, 8, band0I},
{"CMYK", "M;I", 8, band1I}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_M_I, 8, band1I},
{"CMYK", "Y;I", 8, band2I}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y_I, 8, band2I},
{"CMYK", "K;I", 8, band3I}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_K_I, 8, band3I},
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
{"CMYK", "CMYK;16N", 64, unpackRGBA16B}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16N, 64, unpackRGBA16B},
#else #else
{"CMYK", "CMYK;16N", 64, unpackRGBA16L}, {IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16N, 64, unpackRGBA16L},
#endif #endif
/* video (YCbCr) */ /* video (YCbCr) */
{"YCbCr", "YCbCr", 24, ImagingUnpackRGB}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr, 24, ImagingUnpackRGB},
{"YCbCr", "YCbCr;L", 24, unpackRGBL}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr_L, 24, unpackRGBL},
{"YCbCr", "YCbCrX", 32, copy4}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrX, 32, copy4},
{"YCbCr", "YCbCrK", 32, copy4}, {IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrK, 32, copy4},
/* LAB Color */ /* LAB Color */
{"LAB", "LAB", 24, ImagingUnpackLAB}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_LAB, 24, ImagingUnpackLAB},
{"LAB", "L", 8, band0}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_L, 8, band0},
{"LAB", "A", 8, band1}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_A, 8, band1},
{"LAB", "B", 8, band2}, {IMAGING_MODE_LAB, IMAGING_RAWMODE_B, 8, band2},
/* HSV Color */ /* HSV Color */
{"HSV", "HSV", 24, ImagingUnpackRGB}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_HSV, 24, ImagingUnpackRGB},
{"HSV", "H", 8, band0}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_H, 8, band0},
{"HSV", "S", 8, band1}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_S, 8, band1},
{"HSV", "V", 8, band2}, {IMAGING_MODE_HSV, IMAGING_RAWMODE_V, 8, band2},
/* integer variations */ /* integer variations */
{"I", "I", 32, copy4}, {IMAGING_MODE_I, IMAGING_RAWMODE_I, 32, copy4},
{"I", "I;8", 8, unpackI8}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_8, 8, unpackI8},
{"I", "I;8S", 8, unpackI8S}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_8S, 8, unpackI8S},
{"I", "I;16", 16, unpackI16}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_16, 16, unpackI16},
{"I", "I;16S", 16, unpackI16S}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_16S, 16, unpackI16S},
{"I", "I;16B", 16, unpackI16B}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_16B, 16, unpackI16B},
{"I", "I;16BS", 16, unpackI16BS}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_16BS, 16, unpackI16BS},
{"I", "I;16N", 16, unpackI16N}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_16N, 16, unpackI16N},
{"I", "I;16NS", 16, unpackI16NS}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_16NS, 16, unpackI16NS},
{"I", "I;32", 32, unpackI32}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32, 32, unpackI32},
{"I", "I;32S", 32, unpackI32S}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32S, 32, unpackI32S},
{"I", "I;32B", 32, unpackI32B}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32B, 32, unpackI32B},
{"I", "I;32BS", 32, unpackI32BS}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32BS, 32, unpackI32BS},
{"I", "I;32N", 32, unpackI32N}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32N, 32, unpackI32N},
{"I", "I;32NS", 32, unpackI32NS}, {IMAGING_MODE_I, IMAGING_RAWMODE_I_32NS, 32, unpackI32NS},
/* floating point variations */ /* floating point variations */
{"F", "F", 32, copy4}, {IMAGING_MODE_F, IMAGING_RAWMODE_F, 32, copy4},
{"F", "F;8", 8, unpackF8}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_8, 8, unpackF8},
{"F", "F;8S", 8, unpackF8S}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_8S, 8, unpackF8S},
{"F", "F;16", 16, unpackF16}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_16, 16, unpackF16},
{"F", "F;16S", 16, unpackF16S}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_16S, 16, unpackF16S},
{"F", "F;16B", 16, unpackF16B}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_16B, 16, unpackF16B},
{"F", "F;16BS", 16, unpackF16BS}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_16BS, 16, unpackF16BS},
{"F", "F;16N", 16, unpackF16N}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_16N, 16, unpackF16N},
{"F", "F;16NS", 16, unpackF16NS}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_16NS, 16, unpackF16NS},
{"F", "F;32", 32, unpackF32}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32, 32, unpackF32},
{"F", "F;32S", 32, unpackF32S}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32S, 32, unpackF32S},
{"F", "F;32B", 32, unpackF32B}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32B, 32, unpackF32B},
{"F", "F;32BS", 32, unpackF32BS}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32BS, 32, unpackF32BS},
{"F", "F;32N", 32, unpackF32N}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32N, 32, unpackF32N},
{"F", "F;32NS", 32, unpackF32NS}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32NS, 32, unpackF32NS},
{"F", "F;32F", 32, unpackF32F}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32F, 32, unpackF32F},
{"F", "F;32BF", 32, unpackF32BF}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32BF, 32, unpackF32BF},
{"F", "F;32NF", 32, unpackF32NF}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_32NF, 32, unpackF32NF},
#ifdef FLOAT64 #ifdef FLOAT64
{"F", "F;64F", 64, unpackF64F}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_64F, 64, unpackF64F},
{"F", "F;64BF", 64, unpackF64BF}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_64BF, 64, unpackF64BF},
{"F", "F;64NF", 64, unpackF64NF}, {IMAGING_MODE_F, IMAGING_RAWMODE_F_64NF, 64, unpackF64NF},
#endif #endif
/* storage modes */ /* storage modes */
{"I;16", "I;16", 16, copy2}, {IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16, 16, copy2},
{"I;16B", "I;16B", 16, copy2}, {IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16B, 16, copy2},
{"I;16L", "I;16L", 16, copy2}, {IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16L, 16, copy2},
{"I;16N", "I;16N", 16, copy2}, {IMAGING_MODE_I_16N, IMAGING_RAWMODE_I_16N, 16, copy2},
{"I;16", "I;16B", 16, unpackI16B_I16}, {IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, unpackI16B_I16},
{"I;16", "I;16N", 16, unpackI16N_I16}, // LibTiff native->image endian. {IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16B},
{"I;16L", "I;16N", 16, unpackI16N_I16}, // LibTiff native->image endian. {IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16R, 16, unpackI16R_I16},
{"I;16B", "I;16N", 16, unpackI16N_I16B},
{"I;16", "I;16R", 16, unpackI16R_I16}, // LibTiff native->image endian.
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16},
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16},
{"I;16", "I;12", 12, unpackI12_I16}, // 12 bit Tiffs stored in 16bits. // 12 bit Tiffs stored in 16bits.
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_12, 12, unpackI12_I16}
{NULL} /* sentinel */
}; };
ImagingShuffler ImagingShuffler
ImagingFindUnpacker(const char *mode, const char *rawmode, int *bits_out) { ImagingFindUnpacker(const ModeID mode, const RawModeID rawmode, int *bits_out) {
int i; for (size_t i = 0; i < sizeof(unpackers) / sizeof(*unpackers); i++) {
if (unpackers[i].mode == mode && unpackers[i].rawmode == rawmode) {
/* find a suitable pixel unpacker */
for (i = 0; unpackers[i].rawmode; i++) {
if (strcmp(unpackers[i].mode, mode) == 0 &&
strcmp(unpackers[i].rawmode, rawmode) == 0) {
if (bits_out) { if (bits_out) {
*bits_out = unpackers[i].bits; *bits_out = unpackers[i].bits;
} }

10
src/map.c
View File

@ -55,7 +55,7 @@ PyImaging_MapBuffer(PyObject *self, PyObject *args) {
PyObject *target; PyObject *target;
Py_buffer view; Py_buffer view;
char *mode; char *mode_name;
char *codec; char *codec;
Py_ssize_t offset; Py_ssize_t offset;
int xsize, ysize; int xsize, ysize;
@ -70,7 +70,7 @@ PyImaging_MapBuffer(PyObject *self, PyObject *args) {
&ysize, &ysize,
&codec, &codec,
&offset, &offset,
&mode, &mode_name,
&stride, &stride,
&ystep &ystep
)) { )) {
@ -82,10 +82,12 @@ PyImaging_MapBuffer(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const ModeID mode = findModeID(mode_name);
if (stride <= 0) { if (stride <= 0) {
if (!strcmp(mode, "L") || !strcmp(mode, "P")) { if (mode == IMAGING_MODE_L || mode == IMAGING_MODE_P) {
stride = xsize; stride = xsize;
} else if (!strncmp(mode, "I;16", 4)) { } else if (isModeI16(mode)) {
stride = xsize * 2; stride = xsize * 2;
} else { } else {
stride = xsize * 4; stride = xsize * 4;