python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-02-12 01:20:53 +03:00
Code Issues Packages Projects Releases Wiki Activity

change mode structs to enums

Browse Source 
Structs have better type safety, but they make allocation more difficult, especially when we have multiple Python modules trying to share the same code.
This commit is contained in:
Yay295 2024-04-23 11:45:49 -05:00
parent 20986c82aa
commit 9c02ccd0db
25 changed files with 1224 additions and 1533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
src/_imaging.c
View File

@ -285,7 +285,7 @@ ImagingError_Clear(void) {
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
static int static int
getbands(const Mode *mode) { getbands(const ModeID mode) {
Imaging im; Imaging im;
int bands; int bands;
@ -649,7 +649,7 @@ _fill(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
im = ImagingNewDirty(mode, xsize, ysize); im = ImagingNewDirty(mode, xsize, ysize);
if (!im) { if (!im) {
@ -678,7 +678,7 @@ _new(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingNew(mode, xsize, ysize)); return PyImagingNew(ImagingNew(mode, xsize, ysize));
} }
@ -692,7 +692,7 @@ _new_block(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingNewBlock(mode, xsize, ysize)); return PyImagingNew(ImagingNewBlock(mode, xsize, ysize));
} }
@ -705,7 +705,7 @@ _linear_gradient(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingFillLinearGradient(mode)); return PyImagingNew(ImagingFillLinearGradient(mode));
} }
@ -718,7 +718,7 @@ _radial_gradient(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingFillRadialGradient(mode)); return PyImagingNew(ImagingFillRadialGradient(mode));
} }
@ -882,7 +882,7 @@ _color_lut_3d(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
/* actually, it is trilinear */ /* actually, it is trilinear */
if (filter != IMAGING_TRANSFORM_BILINEAR) { if (filter != IMAGING_TRANSFORM_BILINEAR) {
@ -951,7 +951,7 @@ _convert(ImagingObject *self, PyObject *args) {
} }
} }
const Mode * const mode = findMode(mode_name); 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
@ -1003,7 +1003,7 @@ _convert_matrix(ImagingObject *self, PyObject *args) {
} }
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
return PyImagingNew(ImagingConvertMatrix(self->image, mode, m)); return PyImagingNew(ImagingConvertMatrix(self->image, mode, m));
} }
@ -1013,12 +1013,12 @@ _convert_transparent(ImagingObject *self, PyObject *args) {
char *mode_name; char *mode_name;
int r, g, b; int r, g, b;
if (PyArg_ParseTuple(args, "s(iii)", &mode_name, &r, &g, &b)) { if (PyArg_ParseTuple(args, "s(iii)", &mode_name, &r, &g, &b)) {
const Mode * const mode = findMode(mode_name); 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_name, &r)) { if (PyArg_ParseTuple(args, "si", &mode_name, &r)) {
const Mode * const mode = findMode(mode_name); 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;
@ -1132,8 +1132,8 @@ _getpalette(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
pack = ImagingFindPacker(mode, rawmode, &bits); pack = ImagingFindPacker(mode, rawmode, &bits);
if (!pack) { if (!pack) {
@ -1161,7 +1161,7 @@ _getpalettemode(ImagingObject *self) {
return NULL; return NULL;
} }
return PyUnicode_FromString(self->image->palette->mode->name); return PyUnicode_FromString(getModeData(self->image->palette->mode)->name);
} }
static inline int static inline int
@ -1449,7 +1449,7 @@ _point(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
if (mode == IMAGING_MODE_F) { if (mode == IMAGING_MODE_F) {
FLOAT32 *data; FLOAT32 *data;
@ -1746,14 +1746,14 @@ _putpalette(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const palette_mode = findMode(palette_mode_name); const ModeID palette_mode = findModeID(palette_mode_name);
if (palette_mode == NULL) { if (palette_mode == IMAGING_MODE_UNKNOWN) {
PyErr_SetString(PyExc_ValueError, wrong_mode); PyErr_SetString(PyExc_ValueError, wrong_mode);
return NULL; return NULL;
} }
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
if (rawmode == NULL) { if (rawmode == IMAGING_RAWMODE_UNKNOWN) {
PyErr_SetString(PyExc_ValueError, wrong_raw_mode); PyErr_SetString(PyExc_ValueError, wrong_raw_mode);
return NULL; return NULL;
} }
@ -2003,7 +2003,7 @@ _reduce(ImagingObject *self, PyObject *args) {
} }
static int static int
isRGB(const Mode * const mode) { isRGB(const ModeID mode) {
return mode == IMAGING_MODE_RGB || mode == IMAGING_MODE_RGBA || mode == IMAGING_MODE_RGBX; return mode == IMAGING_MODE_RGB || mode == IMAGING_MODE_RGBA || mode == IMAGING_MODE_RGBX;
} }
@ -2019,7 +2019,7 @@ im_setmode(ImagingObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
im = self->image; im = self->image;
@ -2428,7 +2428,7 @@ _merge(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
if (band0) { if (band0) {
bands[0] = band0->image; bands[0] = band0->image;
@ -3730,7 +3730,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->name); return PyUnicode_FromString(getModeData(self->image->mode)->name);
} }
static PyObject * static PyObject *
@ -4374,11 +4374,6 @@ setup_module(PyObject *m) {
return -1; return -1;
} }
ImagingAccessInit();
ImagingConvertInit();
ImagingPackInit();
ImagingUnpackInit();
#ifdef HAVE_LIBJPEG #ifdef HAVE_LIBJPEG
{ {
extern const char *ImagingJpegVersion(void); extern const char *ImagingJpegVersion(void);
@ -4482,14 +4477,6 @@ setup_module(PyObject *m) {
return 0; return 0;
} }
static void
free_module(void *m) {
ImagingAccessFree();
ImagingConvertFree();
ImagingPackFree();
ImagingUnpackFree();
}
PyMODINIT_FUNC PyMODINIT_FUNC
PyInit__imaging(void) { PyInit__imaging(void) {
PyObject *m; PyObject *m;
@ -4500,10 +4487,6 @@ PyInit__imaging(void) {
NULL, /* m_doc */ NULL, /* m_doc */
-1, /* m_size */ -1, /* m_size */
functions, /* m_methods */ functions, /* m_methods */
NULL, /* m_slots */
NULL, /* m_traverse */
NULL, /* m_clear */
free_module /* m_free */
}; };
m = PyModule_Create(&module_def); m = PyModule_Create(&module_def);

44
src/decode.c
View File

@ -293,7 +293,7 @@ static PyTypeObject ImagingDecoderType = {
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
int int
get_unpacker(ImagingDecoderObject *decoder, const Mode *mode, const RawMode *rawmode) { get_unpacker(ImagingDecoderObject *decoder, const ModeID mode, const RawModeID rawmode) {
int bits; int bits;
ImagingShuffler unpack; ImagingShuffler unpack;
@ -468,8 +468,8 @@ PyImaging_HexDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
@ -508,8 +508,8 @@ PyImaging_LibTiffDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
TRACE(("new tiff decoder %s\n", compname)); TRACE(("new tiff decoder %s\n", compname));
@ -549,8 +549,8 @@ PyImaging_PackbitsDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
@ -603,8 +603,8 @@ PyImaging_PcxDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
@ -637,8 +637,8 @@ PyImaging_RawDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(sizeof(RAWSTATE)); decoder = PyImaging_DecoderNew(sizeof(RAWSTATE));
if (decoder == NULL) { if (decoder == NULL) {
@ -673,8 +673,8 @@ PyImaging_SgiRleDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(sizeof(SGISTATE)); decoder = PyImaging_DecoderNew(sizeof(SGISTATE));
if (decoder == NULL) { if (decoder == NULL) {
@ -707,8 +707,8 @@ PyImaging_SunRleDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
@ -739,8 +739,8 @@ PyImaging_TgaRleDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(0); decoder = PyImaging_DecoderNew(0);
if (decoder == NULL) { if (decoder == NULL) {
@ -799,8 +799,8 @@ PyImaging_ZipDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_name); const RawModeID rawmode = findRawModeID(rawmode_name);
decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE)); decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE));
if (decoder == NULL) { if (decoder == NULL) {
@ -855,9 +855,9 @@ PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * rawmode = findRawMode(rawmode_name); RawModeID rawmode = findRawModeID(rawmode_name);
const RawMode * const jpegmode = findRawMode(jpegmode_name); const RawModeID jpegmode = findRawModeID(jpegmode_name);
decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE)); decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE));
if (decoder == NULL) { if (decoder == NULL) {

10
src/display.c
View File

@ -47,7 +47,7 @@ typedef struct {
static PyTypeObject ImagingDisplayType; static PyTypeObject ImagingDisplayType;
static ImagingDisplayObject * static ImagingDisplayObject *
_new(const Mode * const 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) {
@ -240,7 +240,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->name); return Py_BuildValue("s", getModeData(self->dib->mode)->name);
} }
static PyObject * static PyObject *
@ -295,7 +295,7 @@ PyImaging_DisplayWin32(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); 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;
@ -307,8 +307,8 @@ PyImaging_DisplayWin32(PyObject *self, PyObject *args) {
PyObject * PyObject *
PyImaging_DisplayModeWin32(PyObject *self, PyObject *args) { PyImaging_DisplayModeWin32(PyObject *self, PyObject *args) {
int size[2]; int size[2];
const Mode * const mode = ImagingGetModeDIB(size); const ModeID mode = ImagingGetModeDIB(size);
return Py_BuildValue("s(ii)", mode->name, size[0], size[1]); return Py_BuildValue("s(ii)", getModeData(mode)->name, size[0], size[1]);
} }
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */

34
src/encode.c
View File

@ -360,7 +360,7 @@ static PyTypeObject ImagingEncoderType = {
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
int int
get_packer(ImagingEncoderObject *encoder, const Mode *mode, const RawMode *rawmode) { get_packer(ImagingEncoderObject *encoder, const ModeID mode, const RawModeID rawmode) {
int bits; int bits;
ImagingShuffler pack; ImagingShuffler pack;
@ -370,8 +370,8 @@ get_packer(ImagingEncoderObject *encoder, const Mode *mode, const RawMode *rawmo
PyErr_Format( PyErr_Format(
PyExc_ValueError, PyExc_ValueError,
"No packer found from %s to %s", "No packer found from %s to %s",
mode->name, getModeData(mode)->name,
rawmode->name getRawModeData(rawmode)->name
); );
return -1; return -1;
} }
@ -421,8 +421,8 @@ PyImaging_GifEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_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;
@ -457,8 +457,8 @@ PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_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;
@ -491,8 +491,8 @@ PyImaging_RawEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_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;
@ -527,8 +527,8 @@ PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_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;
@ -615,8 +615,8 @@ PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_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);
@ -722,8 +722,8 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * const rawmode = findRawMode(rawmode_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;
@ -1156,8 +1156,8 @@ PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
const RawMode * rawmode = findRawMode(rawmode_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)

77
src/libImaging/Access.c
View File

@ -151,54 +151,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));
} }
static struct ImagingAccessInstance *accessors = NULL; static struct ImagingAccessInstance accessors[] = {
{IMAGING_MODE_1, get_pixel_8, put_pixel_8},
void {IMAGING_MODE_L, get_pixel_8, put_pixel_8},
ImagingAccessInit(void) { {IMAGING_MODE_LA, get_pixel_32_2bands, put_pixel_32},
const struct ImagingAccessInstance temp[] = { {IMAGING_MODE_La, get_pixel_32_2bands, put_pixel_32},
{IMAGING_MODE_1, get_pixel_8, put_pixel_8}, {IMAGING_MODE_I, get_pixel_32, put_pixel_32},
{IMAGING_MODE_L, get_pixel_8, put_pixel_8}, {IMAGING_MODE_I_16, get_pixel_16L, put_pixel_16L},
{IMAGING_MODE_LA, get_pixel_32_2bands, put_pixel_32}, {IMAGING_MODE_I_16L, get_pixel_16L, put_pixel_16L},
{IMAGING_MODE_La, get_pixel_32_2bands, put_pixel_32}, {IMAGING_MODE_I_16B, get_pixel_16B, put_pixel_16B},
{IMAGING_MODE_I, get_pixel_32, put_pixel_32},
{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},
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
{IMAGING_MODE_I_16N, get_pixel_16B, put_pixel_16B}, {IMAGING_MODE_I_16N, get_pixel_16B, put_pixel_16B},
#else #else
{IMAGING_MODE_I_16N, get_pixel_16L, put_pixel_16L}, {IMAGING_MODE_I_16N, get_pixel_16L, put_pixel_16L},
#endif #endif
{IMAGING_MODE_I_32L, get_pixel_32L, put_pixel_32L}, {IMAGING_MODE_I_32L, get_pixel_32L, put_pixel_32L},
{IMAGING_MODE_I_32B, get_pixel_32B, put_pixel_32B}, {IMAGING_MODE_I_32B, get_pixel_32B, put_pixel_32B},
{IMAGING_MODE_F, get_pixel_32, put_pixel_32}, {IMAGING_MODE_F, get_pixel_32, put_pixel_32},
{IMAGING_MODE_P, get_pixel_8, put_pixel_8}, {IMAGING_MODE_P, get_pixel_8, put_pixel_8},
{IMAGING_MODE_PA, get_pixel_32_2bands, put_pixel_32}, {IMAGING_MODE_PA, get_pixel_32_2bands, put_pixel_32},
{IMAGING_MODE_BGR_15, get_pixel_BGR15, put_pixel_BGR1516}, {IMAGING_MODE_BGR_15, get_pixel_BGR15, put_pixel_BGR1516},
{IMAGING_MODE_BGR_16, get_pixel_BGR16, put_pixel_BGR1516}, {IMAGING_MODE_BGR_16, get_pixel_BGR16, put_pixel_BGR1516},
{IMAGING_MODE_BGR_24, get_pixel_BGR24, put_pixel_BGR24}, {IMAGING_MODE_BGR_24, get_pixel_BGR24, put_pixel_BGR24},
{IMAGING_MODE_RGB, get_pixel_32, put_pixel_32}, {IMAGING_MODE_RGB, get_pixel_32, put_pixel_32},
{IMAGING_MODE_RGBA, get_pixel_32, put_pixel_32}, {IMAGING_MODE_RGBA, get_pixel_32, put_pixel_32},
{IMAGING_MODE_RGBa, get_pixel_32, put_pixel_32}, {IMAGING_MODE_RGBa, get_pixel_32, put_pixel_32},
{IMAGING_MODE_RGBX, get_pixel_32, put_pixel_32}, {IMAGING_MODE_RGBX, get_pixel_32, put_pixel_32},
{IMAGING_MODE_CMYK, get_pixel_32, put_pixel_32}, {IMAGING_MODE_CMYK, get_pixel_32, put_pixel_32},
{IMAGING_MODE_YCbCr, get_pixel_32, put_pixel_32}, {IMAGING_MODE_YCbCr, get_pixel_32, put_pixel_32},
{IMAGING_MODE_LAB, get_pixel_32, put_pixel_32}, {IMAGING_MODE_LAB, get_pixel_32, put_pixel_32},
{IMAGING_MODE_HSV, get_pixel_32, put_pixel_32}, {IMAGING_MODE_HSV, get_pixel_32, put_pixel_32}
{NULL} };
};
accessors = malloc(sizeof(temp));
if (accessors == NULL) {
fprintf(stderr, "AccessInit: failed to allocate memory for accessors table\n");
exit(1);
}
memcpy(accessors, temp, sizeof(temp));
}
ImagingAccess ImagingAccess
ImagingAccessNew(const Imaging im) { ImagingAccessNew(const Imaging im) {
int i; for (size_t i = 0; i < sizeof(accessors) / sizeof(*accessors); i++) {
for (i = 0; accessors[i].mode; i++) {
if (im->mode == accessors[i].mode) { if (im->mode == accessors[i].mode) {
return &accessors[i]; return &accessors[i];
} }
@ -208,9 +195,3 @@ ImagingAccessNew(const Imaging im) {
void void
_ImagingAccessDelete(Imaging im, ImagingAccess access) {} _ImagingAccessDelete(Imaging im, ImagingAccess access) {}
void
ImagingAccessFree(void) {
free(accessors);
accessors = NULL;
}

2
src/libImaging/Bands.c
View File

@ -240,7 +240,7 @@ ImagingFillBand(Imaging imOut, int band, int color) {
} }
Imaging Imaging
ImagingMerge(const Mode *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;

58
src/libImaging/Chops.c
View File

@ -18,28 +18,28 @@
#include "Imaging.h" #include "Imaging.h"
#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; \
} \ } \
for (y = 0; y < imOut->ysize; y++) { \ for (y = 0; y < imOut->ysize; y++) { \
UINT8 *out = (UINT8 *)imOut->image[y]; \ UINT8 *out = (UINT8 *)imOut->image[y]; \
UINT8 *in1 = (UINT8 *)imIn1->image[y]; \ UINT8 *in1 = (UINT8 *)imIn1->image[y]; \
UINT8 *in2 = (UINT8 *)imIn2->image[y]; \ UINT8 *in2 = (UINT8 *)imIn2->image[y]; \
for (x = 0; x < imOut->linesize; x++) { \ for (x = 0; x < imOut->linesize; x++) { \
int temp = operation; \ int temp = operation; \
if (temp <= 0) { \ if (temp <= 0) { \
out[x] = 0; \ out[x] = 0; \
} else if (temp >= 255) { \ } else if (temp >= 255) { \
out[x] = 255; \ out[x] = 255; \
} else { \ } else { \
out[x] = temp; \ out[x] = temp; \
} \ } \
} \ } \
} \ } \
return imOut; return imOut;
#define CHOP2(operation, mode) \ #define CHOP2(operation, mode) \
@ -60,11 +60,11 @@
return imOut; return imOut;
static Imaging static Imaging
create(Imaging im1, Imaging im2, const Mode *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 && (im1->mode != mode || im2->mode != mode))) { (mode != IMAGING_MODE_UNKNOWN && (im1->mode != mode || im2->mode != mode))) {
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) {
@ -129,12 +129,12 @@ ImagingChopXor(Imaging imIn1, Imaging imIn2) {
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 +142,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 +151,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 +160,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
); );
} }

325
src/libImaging/Convert.c
View File

@ -1122,7 +1122,7 @@ pa2ycbcr(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) {
} }
static Imaging static Imaging
frompalette(Imaging imOut, Imaging imIn, const Mode *mode) { frompalette(Imaging imOut, Imaging imIn, const ModeID mode) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
int alpha; int alpha;
int y; int y;
@ -1192,7 +1192,7 @@ frompalette(Imaging imOut, Imaging imIn, const Mode *mode) {
#endif #endif
static Imaging static Imaging
topalette( topalette(
Imaging imOut, Imaging imIn, const Mode *mode, ImagingPalette inpalette, int dither Imaging imOut, Imaging imIn, const ModeID mode, ImagingPalette inpalette, int dither
) { ) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
int alpha; int alpha;
@ -1488,25 +1488,151 @@ tobilevel(Imaging imOut, Imaging imIn) {
/* Conversion handlers */ /* Conversion handlers */
/* ------------------- */ /* ------------------- */
static struct Converter { static struct {
const Mode *from; const ModeID from;
const Mode *to; const ModeID to;
ImagingShuffler convert; ImagingShuffler convert;
} *converters = NULL; } 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_BGR_15, rgb2bgr15},
{IMAGING_MODE_RGB, IMAGING_MODE_BGR_16, rgb2bgr16},
{IMAGING_MODE_RGB, IMAGING_MODE_BGR_24, rgb2bgr24},
{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 Mode *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();
@ -1536,10 +1662,9 @@ convert(
/* 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 (imIn->mode == converters[y].from && mode == converters[y].to) { convert = converters[i].convert;
convert = converters[y].convert;
break; break;
} }
} }
@ -1550,7 +1675,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->name, mode->name 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
@ -1562,7 +1691,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);
@ -1571,7 +1700,7 @@ convert(
} }
Imaging Imaging
ImagingConvert(Imaging imIn, const Mode *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);
} }
@ -1581,7 +1710,7 @@ ImagingConvert2(Imaging imOut, Imaging imIn) {
} }
Imaging Imaging
ImagingConvertTransparent(Imaging imIn, const Mode *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;
@ -1630,8 +1759,8 @@ ImagingConvertTransparent(Imaging imIn, const Mode *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->name, getModeData(imIn->mode)->name,
mode->name getModeData(mode)->name
); );
return (Imaging)ImagingError_ValueError(buf); return (Imaging)ImagingError_ValueError(buf);
} }
@ -1654,7 +1783,7 @@ ImagingConvertTransparent(Imaging imIn, const Mode *mode, int r, int g, int b) {
} }
Imaging Imaging
ImagingConvertInPlace(Imaging imIn, const Mode *mode) { ImagingConvertInPlace(Imaging imIn, const ModeID mode) {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
ImagingShuffler convert; ImagingShuffler convert;
int y; int y;
@ -1676,155 +1805,3 @@ ImagingConvertInPlace(Imaging imIn, const Mode *mode) {
return imIn; return imIn;
} }
/* ------------------ */
/* Converter mappings */
/* ------------------ */
void
ImagingConvertInit(void) {
const struct Converter temp[] = {
{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_BGR_15, rgb2bgr15},
{IMAGING_MODE_RGB, IMAGING_MODE_BGR_16, rgb2bgr16},
{IMAGING_MODE_RGB, IMAGING_MODE_BGR_24, rgb2bgr24},
{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},
{NULL}
};
converters = malloc(sizeof(temp));
if (converters == NULL) {
fprintf(stderr, "ConvertInit: failed to allocate memory for converter table\n");
exit(1);
}
memcpy(converters, temp, sizeof(temp));
}
void
ImagingConvertFree(void) {
free(converters);
converters = NULL;
}

6
src/libImaging/Dib.c
View File

@ -25,13 +25,13 @@
#include "ImDib.h" #include "ImDib.h"
const Mode * ModeID
ImagingGetModeDIB(int size_out[2]) { ImagingGetModeDIB(int size_out[2]) {
/* Get device characteristics */ /* Get device characteristics */
const HDC dc = CreateCompatibleDC(NULL); const HDC dc = CreateCompatibleDC(NULL);
const Mode *mode = IMAGING_MODE_P; ModeID mode = IMAGING_MODE_P;
if (!(GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)) { if (!(GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)) {
mode = IMAGING_MODE_RGB; mode = IMAGING_MODE_RGB;
if (GetDeviceCaps(dc, BITSPIXEL) == 1) { if (GetDeviceCaps(dc, BITSPIXEL) == 1) {
@ -50,7 +50,7 @@ ImagingGetModeDIB(int size_out[2]) {
} }
ImagingDIB ImagingDIB
ImagingNewDIB(const Mode * const 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;

4
src/libImaging/Fill.c
View File

@ -68,7 +68,7 @@ ImagingFill(Imaging im, const void *colour) {
} }
Imaging Imaging
ImagingFillLinearGradient(const Mode *mode) { ImagingFillLinearGradient(const ModeID mode) {
Imaging im; Imaging im;
int y; int y;
@ -105,7 +105,7 @@ ImagingFillLinearGradient(const Mode *mode) {
} }
Imaging Imaging
ImagingFillRadialGradient(const Mode *mode) { ImagingFillRadialGradient(const ModeID mode) {
Imaging im; Imaging im;
int x, y; int x, y;
int d; int d;

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 */
const Mode *mode; 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 const Mode * extern ModeID
ImagingGetModeDIB(int size_out[2]); ImagingGetModeDIB(int size_out[2]);
extern ImagingDIB extern ImagingDIB
ImagingNewDIB(const Mode * const mode, int xsize, int ysize); ImagingNewDIB(ModeID mode, int xsize, int ysize);
extern void extern void
ImagingDeleteDIB(ImagingDIB im); ImagingDeleteDIB(ImagingDIB im);

75
src/libImaging/Imaging.h
View File

@ -77,11 +77,11 @@ typedef struct {
struct ImagingMemoryInstance { struct ImagingMemoryInstance {
/* Format */ /* Format */
const Mode *mode; /* Image mode (IMAGING_MODE_*) */ ModeID mode; /* Image mode (IMAGING_MODE_*) */
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) */
int xsize; /* Image dimension. */ int xsize; /* Image dimension. */
int ysize; int ysize;
/* Colour palette (for "P" images only) */ /* Colour palette (for "P" images only) */
@ -120,15 +120,15 @@ 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 Mode *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 */
const Mode *mode; /* Mode of corresponding source image */ ModeID mode; /* Mode ID of corresponding source image */
int bands; /* Number of bands (1, 3, or 4) */ int bands; /* Number of bands (1, 3, or 4) */
/* Data */ /* Data */
long *histogram; /* Histogram (bands*256 longs) */ long *histogram; /* Histogram (bands*256 longs) */
@ -136,7 +136,7 @@ struct ImagingHistogramInstance {
struct ImagingPaletteInstance { struct ImagingPaletteInstance {
/* Format */ /* Format */
const Mode *mode; ModeID mode;
/* Data */ /* Data */
int size; int size;
@ -163,29 +163,6 @@ typedef struct ImagingMemoryArena {
#endif #endif
} *ImagingMemoryArena; } *ImagingMemoryArena;
/* Memory Management */
/* ----------------- */
extern void
ImagingAccessInit(void);
extern void
ImagingAccessFree(void);
extern void
ImagingConvertInit(void);
extern void
ImagingConvertFree(void);
extern void
ImagingPackInit(void);
extern void
ImagingPackFree(void);
extern void
ImagingUnpackInit(void);
extern void
ImagingUnpackFree(void);
/* Objects */ /* Objects */
/* ------- */ /* ------- */
@ -196,21 +173,21 @@ extern void
ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size); ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size);
extern Imaging extern Imaging
ImagingNew(const Mode *mode, int xsize, int ysize); ImagingNew(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNewDirty(const Mode *mode, int xsize, int ysize); ImagingNewDirty(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNew2Dirty(const Mode *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 Mode *mode, int xsize, int ysize); ImagingNewBlock(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNewPrologue(const Mode *mode, int xsize, int ysize); ImagingNewPrologue(ModeID mode, int xsize, int ysize);
extern Imaging extern Imaging
ImagingNewPrologueSubtype(const Mode *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);
@ -225,7 +202,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 Mode *mode); ImagingPaletteNew(ModeID mode);
extern ImagingPalette extern ImagingPalette
ImagingPaletteNewBrowser(void); ImagingPaletteNewBrowser(void);
extern ImagingPalette extern ImagingPalette
@ -301,13 +278,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 Mode *mode, ImagingPalette palette, int dither); ImagingConvert(Imaging im, ModeID mode, ImagingPalette palette, int dither);
extern Imaging extern Imaging
ImagingConvertInPlace(Imaging im, const Mode *mode); ImagingConvertInPlace(Imaging im, ModeID mode);
extern Imaging extern Imaging
ImagingConvertMatrix(Imaging im, const Mode *mode, float m[]); ImagingConvertMatrix(Imaging im, ModeID mode, float m[]);
extern Imaging extern Imaging
ImagingConvertTransparent(Imaging im, const Mode *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
@ -321,9 +298,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 Mode *mode); ImagingFillLinearGradient(ModeID mode);
extern Imaging extern Imaging
ImagingFillRadialGradient(const Mode *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
@ -337,7 +314,7 @@ ImagingGaussianBlur(
extern Imaging extern Imaging
ImagingGetBand(Imaging im, int band); ImagingGetBand(Imaging im, int band);
extern Imaging extern Imaging
ImagingMerge(const Mode *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
@ -364,7 +341,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 Mode *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
@ -692,9 +669,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 Mode *mode, const RawMode *rawmode, int *bits_out); ImagingFindUnpacker(ModeID mode, RawModeID rawmode, int *bits_out);
extern ImagingShuffler extern ImagingShuffler
ImagingFindPacker(const Mode *mode, const RawMode *rawmode, int *bits_out); ImagingFindPacker(ModeID mode, RawModeID rawmode, int *bits_out);
struct ImagingCodecStateInstance { struct ImagingCodecStateInstance {
int count; int count;

10
src/libImaging/Jpeg.h
View File

@ -28,12 +28,12 @@ typedef struct {
typedef struct { typedef struct {
/* CONFIGURATION */ /* CONFIGURATION */
/* Jpeg file mode (NULL if not known) */ /* Jpeg file mode */
const RawMode *jpegmode; RawModeID jpegmode;
/* Converter output mode (input to the shuffler) */ /* Converter output mode (input to the shuffler) */
/* If NULL, convert conversions are disabled */ /* If not a valid mode, convert conversions are disabled */
const RawMode *rawmode; 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) */
const RawMode *rawmode; RawModeID rawmode;
/* Custom quantization tables () */ /* Custom quantization tables () */
unsigned int *qtables; unsigned int *qtables;

2
src/libImaging/Jpeg2KDecode.c
View File

@ -770,7 +770,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->name, j2k_unpackers[n].mode) == 0) { strcmp(getModeData(im->mode)->name, j2k_unpackers[n].mode) == 0) {
unpack = j2k_unpackers[n].unpacker; unpack = j2k_unpackers[n].unpacker;
break; break;
} }

10
src/libImaging/JpegDecode.c
View File

@ -180,8 +180,8 @@ 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 (context->jpegmode == IMAGING_RAWMODE_L) { if (context->jpegmode == IMAGING_RAWMODE_L) {
context->cinfo.jpeg_color_space = JCS_GRAYSCALE; context->cinfo.jpeg_color_space = JCS_GRAYSCALE;
} else if (context->jpegmode == IMAGING_RAWMODE_RGB) { } else if (context->jpegmode == IMAGING_RAWMODE_RGB) {
@ -194,8 +194,8 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t by
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 (context->rawmode == IMAGING_RAWMODE_L) { if (context->rawmode == IMAGING_RAWMODE_L) {
context->cinfo.out_color_space = JCS_GRAYSCALE; context->cinfo.out_color_space = JCS_GRAYSCALE;
} else if (context->rawmode == IMAGING_RAWMODE_RGB) { } else if (context->rawmode == IMAGING_RAWMODE_RGB) {
@ -214,7 +214,7 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t by
} else if (context->rawmode == IMAGING_RAWMODE_YCbCrK) { } 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;
} }

2
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 Mode *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;

651
src/libImaging/Mode.c
View File

@ -2,453 +2,258 @@
#include <string.h> #include <string.h>
#define CREATE_MODE(TYPE, NAME, INIT) \ const ModeData MODES[] = {
const TYPE IMAGING_##NAME##_VAL = INIT;\ [IMAGING_MODE_UNKNOWN] = {""},
const TYPE * const IMAGING_##NAME = &IMAGING_##NAME##_VAL;
[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"},
CREATE_MODE(Mode, MODE_1, {"1"}) [IMAGING_MODE_BGR_15] = {"BGR;15"},
CREATE_MODE(Mode, MODE_CMYK, {"CMYK"}) [IMAGING_MODE_BGR_16] = {"BGR;16"},
CREATE_MODE(Mode, MODE_F, {"F"}) [IMAGING_MODE_BGR_24] = {"BGR;24"},
CREATE_MODE(Mode, MODE_HSV, {"HSV"})
CREATE_MODE(Mode, MODE_I, {"I"})
CREATE_MODE(Mode, MODE_L, {"L"})
CREATE_MODE(Mode, MODE_LA, {"LA"})
CREATE_MODE(Mode, MODE_LAB, {"LAB"})
CREATE_MODE(Mode, MODE_La, {"La"})
CREATE_MODE(Mode, MODE_P, {"P"})
CREATE_MODE(Mode, MODE_PA, {"PA"})
CREATE_MODE(Mode, MODE_RGB, {"RGB"})
CREATE_MODE(Mode, MODE_RGBA, {"RGBA"})
CREATE_MODE(Mode, MODE_RGBX, {"RGBX"})
CREATE_MODE(Mode, MODE_RGBa, {"RGBa"})
CREATE_MODE(Mode, MODE_YCbCr, {"YCbCr"})
CREATE_MODE(Mode, MODE_BGR_15, {"BGR;15"}) [IMAGING_MODE_I_16] = {"I;16"},
CREATE_MODE(Mode, MODE_BGR_16, {"BGR;16"}) [IMAGING_MODE_I_16L] = {"I;16L"},
CREATE_MODE(Mode, MODE_BGR_24, {"BGR;24"}) [IMAGING_MODE_I_16B] = {"I;16B"},
[IMAGING_MODE_I_16N] = {"I;16N"},
CREATE_MODE(Mode, MODE_I_16, {"I;16"}) [IMAGING_MODE_I_32L] = {"I;32L"},
CREATE_MODE(Mode, MODE_I_16L, {"I;16L"}) [IMAGING_MODE_I_32B] = {"I;32B"},
CREATE_MODE(Mode, MODE_I_16B, {"I;16B"})
CREATE_MODE(Mode, MODE_I_16N, {"I;16N"})
CREATE_MODE(Mode, MODE_I_32L, {"I;32L"})
CREATE_MODE(Mode, MODE_I_32B, {"I;32B"})
const Mode * const MODES[] = {
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_BGR_15,
IMAGING_MODE_BGR_16,
IMAGING_MODE_BGR_24,
IMAGING_MODE_I_16,
IMAGING_MODE_I_16L,
IMAGING_MODE_I_16B,
IMAGING_MODE_I_16N,
IMAGING_MODE_I_32L,
IMAGING_MODE_I_32B,
NULL
}; };
const Mode * findMode(const char * const name) { const ModeID findModeID(const char * const name) {
if (name == NULL) { if (name == NULL) {
return NULL; return IMAGING_MODE_UNKNOWN;
} }
const Mode * mode; for (size_t i = 0; i < sizeof(MODES) / sizeof(*MODES); i++) {
for (int i = 0; (mode = MODES[i]); i++) { if (strcmp(MODES[i].name, name) == 0) {
if (strcmp(mode->name, name) == 0) { return (ModeID)i;
return mode;
} }
} }
return NULL; 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];
} }
// Alias all of the modes as rawmodes so that the addresses are the same. const RawModeData RAWMODES[] = {
#define ALIAS_MODE_AS_RAWMODE(NAME) const RawMode * const IMAGING_RAWMODE_##NAME = (const RawMode * const)IMAGING_MODE_##NAME; [IMAGING_RAWMODE_UNKNOWN] = {""},
ALIAS_MODE_AS_RAWMODE(1)
ALIAS_MODE_AS_RAWMODE(CMYK)
ALIAS_MODE_AS_RAWMODE(F)
ALIAS_MODE_AS_RAWMODE(HSV)
ALIAS_MODE_AS_RAWMODE(I)
ALIAS_MODE_AS_RAWMODE(L)
ALIAS_MODE_AS_RAWMODE(LA)
ALIAS_MODE_AS_RAWMODE(LAB)
ALIAS_MODE_AS_RAWMODE(La)
ALIAS_MODE_AS_RAWMODE(P)
ALIAS_MODE_AS_RAWMODE(PA)
ALIAS_MODE_AS_RAWMODE(RGB)
ALIAS_MODE_AS_RAWMODE(RGBA)
ALIAS_MODE_AS_RAWMODE(RGBX)
ALIAS_MODE_AS_RAWMODE(RGBa)
ALIAS_MODE_AS_RAWMODE(YCbCr)
ALIAS_MODE_AS_RAWMODE(BGR_15) [IMAGING_RAWMODE_1] = {"1"},
ALIAS_MODE_AS_RAWMODE(BGR_16) [IMAGING_RAWMODE_CMYK] = {"CMYK"},
ALIAS_MODE_AS_RAWMODE(BGR_24) [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"},
ALIAS_MODE_AS_RAWMODE(I_16) [IMAGING_RAWMODE_BGR_15] = {"BGR;15"},
ALIAS_MODE_AS_RAWMODE(I_16L) [IMAGING_RAWMODE_BGR_16] = {"BGR;16"},
ALIAS_MODE_AS_RAWMODE(I_16B) [IMAGING_RAWMODE_BGR_24] = {"BGR;24"},
ALIAS_MODE_AS_RAWMODE(I_16N) [IMAGING_RAWMODE_BGR_32] = {"BGR;32"},
ALIAS_MODE_AS_RAWMODE(I_32L)
ALIAS_MODE_AS_RAWMODE(I_32B)
CREATE_MODE(RawMode, RAWMODE_1_8, {"1;8"}) [IMAGING_RAWMODE_I_16] = {"I;16"},
CREATE_MODE(RawMode, RAWMODE_1_I, {"1;I"}) [IMAGING_RAWMODE_I_16L] = {"I;16L"},
CREATE_MODE(RawMode, RAWMODE_1_IR, {"1;IR"}) [IMAGING_RAWMODE_I_16B] = {"I;16B"},
CREATE_MODE(RawMode, RAWMODE_1_R, {"1;R"}) [IMAGING_RAWMODE_I_16N] = {"I;16N"},
CREATE_MODE(RawMode, RAWMODE_A, {"A"}) [IMAGING_RAWMODE_I_32L] = {"I;32L"},
CREATE_MODE(RawMode, RAWMODE_ABGR, {"ABGR"}) [IMAGING_RAWMODE_I_32B] = {"I;32B"},
CREATE_MODE(RawMode, RAWMODE_ARGB, {"ARGB"})
CREATE_MODE(RawMode, RAWMODE_A_16B, {"A;16B"})
CREATE_MODE(RawMode, RAWMODE_A_16L, {"A;16L"})
CREATE_MODE(RawMode, RAWMODE_A_16N, {"A;16N"})
CREATE_MODE(RawMode, RAWMODE_B, {"B"})
CREATE_MODE(RawMode, RAWMODE_BGAR, {"BGAR"})
CREATE_MODE(RawMode, RAWMODE_BGR, {"BGR"})
CREATE_MODE(RawMode, RAWMODE_BGRA, {"BGRA"})
CREATE_MODE(RawMode, RAWMODE_BGRA_15, {"BGRA;15"})
CREATE_MODE(RawMode, RAWMODE_BGRA_15Z, {"BGRA;15Z"})
CREATE_MODE(RawMode, RAWMODE_BGRA_16B, {"BGRA;16B"})
CREATE_MODE(RawMode, RAWMODE_BGRA_16L, {"BGRA;16L"})
CREATE_MODE(RawMode, RAWMODE_BGRX, {"BGRX"})
CREATE_MODE(RawMode, RAWMODE_BGR_5, {"BGR;5"})
CREATE_MODE(RawMode, RAWMODE_BGRa, {"BGRa"})
CREATE_MODE(RawMode, RAWMODE_BGXR, {"BGXR"})
CREATE_MODE(RawMode, RAWMODE_B_16B, {"B;16B"})
CREATE_MODE(RawMode, RAWMODE_B_16L, {"B;16L"})
CREATE_MODE(RawMode, RAWMODE_B_16N, {"B;16N"})
CREATE_MODE(RawMode, RAWMODE_C, {"C"})
CREATE_MODE(RawMode, RAWMODE_CMYKX, {"CMYKX"})
CREATE_MODE(RawMode, RAWMODE_CMYKXX, {"CMYKXX"})
CREATE_MODE(RawMode, RAWMODE_CMYK_16B, {"CMYK;16B"})
CREATE_MODE(RawMode, RAWMODE_CMYK_16L, {"CMYK;16L"})
CREATE_MODE(RawMode, RAWMODE_CMYK_16N, {"CMYK;16N"})
CREATE_MODE(RawMode, RAWMODE_CMYK_I, {"CMYK;I"})
CREATE_MODE(RawMode, RAWMODE_CMYK_L, {"CMYK;L"})
CREATE_MODE(RawMode, RAWMODE_C_I, {"C;I"})
CREATE_MODE(RawMode, RAWMODE_Cb, {"Cb"})
CREATE_MODE(RawMode, RAWMODE_Cr, {"Cr"})
CREATE_MODE(RawMode, RAWMODE_F_16, {"F;16"})
CREATE_MODE(RawMode, RAWMODE_F_16B, {"F;16B"})
CREATE_MODE(RawMode, RAWMODE_F_16BS, {"F;16BS"})
CREATE_MODE(RawMode, RAWMODE_F_16N, {"F;16N"})
CREATE_MODE(RawMode, RAWMODE_F_16NS, {"F;16NS"})
CREATE_MODE(RawMode, RAWMODE_F_16S, {"F;16S"})
CREATE_MODE(RawMode, RAWMODE_F_32, {"F;32"})
CREATE_MODE(RawMode, RAWMODE_F_32B, {"F;32B"})
CREATE_MODE(RawMode, RAWMODE_F_32BF, {"F;32BF"})
CREATE_MODE(RawMode, RAWMODE_F_32BS, {"F;32BS"})
CREATE_MODE(RawMode, RAWMODE_F_32F, {"F;32F"})
CREATE_MODE(RawMode, RAWMODE_F_32N, {"F;32N"})
CREATE_MODE(RawMode, RAWMODE_F_32NF, {"F;32NF"})
CREATE_MODE(RawMode, RAWMODE_F_32NS, {"F;32NS"})
CREATE_MODE(RawMode, RAWMODE_F_32S, {"F;32S"})
CREATE_MODE(RawMode, RAWMODE_F_64BF, {"F;64BF"})
CREATE_MODE(RawMode, RAWMODE_F_64F, {"F;64F"})
CREATE_MODE(RawMode, RAWMODE_F_64NF, {"F;64NF"})
CREATE_MODE(RawMode, RAWMODE_F_8, {"F;8"})
CREATE_MODE(RawMode, RAWMODE_F_8S, {"F;8S"})
CREATE_MODE(RawMode, RAWMODE_G, {"G"})
CREATE_MODE(RawMode, RAWMODE_G_16B, {"G;16B"})
CREATE_MODE(RawMode, RAWMODE_G_16L, {"G;16L"})
CREATE_MODE(RawMode, RAWMODE_G_16N, {"G;16N"})
CREATE_MODE(RawMode, RAWMODE_H, {"H"})
CREATE_MODE(RawMode, RAWMODE_I_12, {"I;12"})
CREATE_MODE(RawMode, RAWMODE_I_16BS, {"I;16BS"})
CREATE_MODE(RawMode, RAWMODE_I_16NS, {"I;16NS"})
CREATE_MODE(RawMode, RAWMODE_I_16R, {"I;16R"})
CREATE_MODE(RawMode, RAWMODE_I_16S, {"I;16S"})
CREATE_MODE(RawMode, RAWMODE_I_32, {"I;32"})
CREATE_MODE(RawMode, RAWMODE_I_32BS, {"I;32BS"})
CREATE_MODE(RawMode, RAWMODE_I_32N, {"I;32N"})
CREATE_MODE(RawMode, RAWMODE_I_32NS, {"I;32NS"})
CREATE_MODE(RawMode, RAWMODE_I_32S, {"I;32S"})
CREATE_MODE(RawMode, RAWMODE_I_8, {"I;8"})
CREATE_MODE(RawMode, RAWMODE_I_8S, {"I;8S"})
CREATE_MODE(RawMode, RAWMODE_K, {"K"})
CREATE_MODE(RawMode, RAWMODE_K_I, {"K;I"})
CREATE_MODE(RawMode, RAWMODE_LA_16B, {"LA;16B"})
CREATE_MODE(RawMode, RAWMODE_LA_L, {"LA;L"})
CREATE_MODE(RawMode, RAWMODE_L_16, {"L;16"})
CREATE_MODE(RawMode, RAWMODE_L_16B, {"L;16B"})
CREATE_MODE(RawMode, RAWMODE_L_2, {"L;2"})
CREATE_MODE(RawMode, RAWMODE_L_2I, {"L;2I"})
CREATE_MODE(RawMode, RAWMODE_L_2IR, {"L;2IR"})
CREATE_MODE(RawMode, RAWMODE_L_2R, {"L;2R"})
CREATE_MODE(RawMode, RAWMODE_L_4, {"L;4"})
CREATE_MODE(RawMode, RAWMODE_L_4I, {"L;4I"})
CREATE_MODE(RawMode, RAWMODE_L_4IR, {"L;4IR"})
CREATE_MODE(RawMode, RAWMODE_L_4R, {"L;4R"})
CREATE_MODE(RawMode, RAWMODE_L_I, {"L;I"})
CREATE_MODE(RawMode, RAWMODE_L_R, {"L;R"})
CREATE_MODE(RawMode, RAWMODE_M, {"M"})
CREATE_MODE(RawMode, RAWMODE_M_I, {"M;I"})
CREATE_MODE(RawMode, RAWMODE_PA_L, {"PA;L"})
CREATE_MODE(RawMode, RAWMODE_PX, {"PX"})
CREATE_MODE(RawMode, RAWMODE_P_1, {"P;1"})
CREATE_MODE(RawMode, RAWMODE_P_2, {"P;2"})
CREATE_MODE(RawMode, RAWMODE_P_2L, {"P;2L"})
CREATE_MODE(RawMode, RAWMODE_P_4, {"P;4"})
CREATE_MODE(RawMode, RAWMODE_P_4L, {"P;4L"})
CREATE_MODE(RawMode, RAWMODE_P_R, {"P;R"})
CREATE_MODE(RawMode, RAWMODE_R, {"R"})
CREATE_MODE(RawMode, RAWMODE_RGBAX, {"RGBAX"})
CREATE_MODE(RawMode, RAWMODE_RGBAXX, {"RGBAXX"})
CREATE_MODE(RawMode, RAWMODE_RGBA_15, {"RGBA;15"})
CREATE_MODE(RawMode, RAWMODE_RGBA_16B, {"RGBA;16B"})
CREATE_MODE(RawMode, RAWMODE_RGBA_16L, {"RGBA;16L"})
CREATE_MODE(RawMode, RAWMODE_RGBA_16N, {"RGBA;16N"})
CREATE_MODE(RawMode, RAWMODE_RGBA_4B, {"RGBA;4B"})
CREATE_MODE(RawMode, RAWMODE_RGBA_I, {"RGBA;I"})
CREATE_MODE(RawMode, RAWMODE_RGBA_L, {"RGBA;L"})
CREATE_MODE(RawMode, RAWMODE_RGBXX, {"RGBXX"})
CREATE_MODE(RawMode, RAWMODE_RGBXXX, {"RGBXXX"})
CREATE_MODE(RawMode, RAWMODE_RGBX_16B, {"RGBX;16B"})
CREATE_MODE(RawMode, RAWMODE_RGBX_16L, {"RGBX;16L"})
CREATE_MODE(RawMode, RAWMODE_RGBX_16N, {"RGBX;16N"})
CREATE_MODE(RawMode, RAWMODE_RGBX_L, {"RGBX;L"})
CREATE_MODE(RawMode, RAWMODE_RGB_15, {"RGB;15"})
CREATE_MODE(RawMode, RAWMODE_RGB_16, {"RGB;16"})
CREATE_MODE(RawMode, RAWMODE_RGB_16B, {"RGB;16B"})
CREATE_MODE(RawMode, RAWMODE_RGB_16L, {"RGB;16L"})
CREATE_MODE(RawMode, RAWMODE_RGB_16N, {"RGB;16N"})
CREATE_MODE(RawMode, RAWMODE_RGB_4B, {"RGB;4B"})
CREATE_MODE(RawMode, RAWMODE_RGB_L, {"RGB;L"})
CREATE_MODE(RawMode, RAWMODE_RGB_R, {"RGB;R"})
CREATE_MODE(RawMode, RAWMODE_RGBaX, {"RGBaX"})
CREATE_MODE(RawMode, RAWMODE_RGBaXX, {"RGBaXX"})
CREATE_MODE(RawMode, RAWMODE_RGBa_16B, {"RGBa;16B"})
CREATE_MODE(RawMode, RAWMODE_RGBa_16L, {"RGBa;16L"})
CREATE_MODE(RawMode, RAWMODE_RGBa_16N, {"RGBa;16N"})
CREATE_MODE(RawMode, RAWMODE_R_16B, {"R;16B"})
CREATE_MODE(RawMode, RAWMODE_R_16L, {"R;16L"})
CREATE_MODE(RawMode, RAWMODE_R_16N, {"R;16N"})
CREATE_MODE(RawMode, RAWMODE_S, {"S"})
CREATE_MODE(RawMode, RAWMODE_V, {"V"})
CREATE_MODE(RawMode, RAWMODE_X, {"X"})
CREATE_MODE(RawMode, RAWMODE_XBGR, {"XBGR"})
CREATE_MODE(RawMode, RAWMODE_XRGB, {"XRGB"})
CREATE_MODE(RawMode, RAWMODE_Y, {"Y"})
CREATE_MODE(RawMode, RAWMODE_YCCA_P, {"YCCA;P"})
CREATE_MODE(RawMode, RAWMODE_YCC_P, {"YCC;P"})
CREATE_MODE(RawMode, RAWMODE_YCbCrK, {"YCbCrK"})
CREATE_MODE(RawMode, RAWMODE_YCbCrX, {"YCbCrX"})
CREATE_MODE(RawMode, RAWMODE_YCbCr_L, {"YCbCr;L"})
CREATE_MODE(RawMode, RAWMODE_Y_I, {"Y;I"})
CREATE_MODE(RawMode, RAWMODE_aBGR, {"aBGR"})
CREATE_MODE(RawMode, RAWMODE_aRGB, {"aRGB"})
const RawMode * const RAWMODES[] = { [IMAGING_RAWMODE_1_8] = {"1;8"},
IMAGING_RAWMODE_1, [IMAGING_RAWMODE_1_I] = {"1;I"},
IMAGING_RAWMODE_CMYK, [IMAGING_RAWMODE_1_IR] = {"1;IR"},
IMAGING_RAWMODE_F, [IMAGING_RAWMODE_1_R] = {"1;R"},
IMAGING_RAWMODE_HSV, [IMAGING_RAWMODE_A] = {"A"},
IMAGING_RAWMODE_I, [IMAGING_RAWMODE_ABGR] = {"ABGR"},
IMAGING_RAWMODE_L, [IMAGING_RAWMODE_ARGB] = {"ARGB"},
IMAGING_RAWMODE_LA, [IMAGING_RAWMODE_A_16B] = {"A;16B"},
IMAGING_RAWMODE_LAB, [IMAGING_RAWMODE_A_16L] = {"A;16L"},
IMAGING_RAWMODE_La, [IMAGING_RAWMODE_A_16N] = {"A;16N"},
IMAGING_RAWMODE_P, [IMAGING_RAWMODE_B] = {"B"},
IMAGING_RAWMODE_PA, [IMAGING_RAWMODE_BGAR] = {"BGAR"},
IMAGING_RAWMODE_RGB, [IMAGING_RAWMODE_BGR] = {"BGR"},
IMAGING_RAWMODE_RGBA, [IMAGING_RAWMODE_BGRA] = {"BGRA"},
IMAGING_RAWMODE_RGBX, [IMAGING_RAWMODE_BGRA_15] = {"BGRA;15"},
IMAGING_RAWMODE_RGBa, [IMAGING_RAWMODE_BGRA_15Z] = {"BGRA;15Z"},
IMAGING_RAWMODE_YCbCr, [IMAGING_RAWMODE_BGRA_16B] = {"BGRA;16B"},
[IMAGING_RAWMODE_BGRA_16L] = {"BGRA;16L"},
IMAGING_RAWMODE_BGR_15, [IMAGING_RAWMODE_BGRX] = {"BGRX"},
IMAGING_RAWMODE_BGR_16, [IMAGING_RAWMODE_BGR_5] = {"BGR;5"},
IMAGING_RAWMODE_BGR_24, [IMAGING_RAWMODE_BGRa] = {"BGRa"},
[IMAGING_RAWMODE_BGXR] = {"BGXR"},
IMAGING_RAWMODE_I_16, [IMAGING_RAWMODE_B_16B] = {"B;16B"},
IMAGING_RAWMODE_I_16L, [IMAGING_RAWMODE_B_16L] = {"B;16L"},
IMAGING_RAWMODE_I_16B, [IMAGING_RAWMODE_B_16N] = {"B;16N"},
IMAGING_RAWMODE_I_16N, [IMAGING_RAWMODE_C] = {"C"},
IMAGING_RAWMODE_I_32L, [IMAGING_RAWMODE_CMYKX] = {"CMYKX"},
IMAGING_RAWMODE_I_32B, [IMAGING_RAWMODE_CMYKXX] = {"CMYKXX"},
[IMAGING_RAWMODE_CMYK_16B] = {"CMYK;16B"},
IMAGING_RAWMODE_1_8, [IMAGING_RAWMODE_CMYK_16L] = {"CMYK;16L"},
IMAGING_RAWMODE_1_I, [IMAGING_RAWMODE_CMYK_16N] = {"CMYK;16N"},
IMAGING_RAWMODE_1_IR, [IMAGING_RAWMODE_CMYK_I] = {"CMYK;I"},
IMAGING_RAWMODE_1_R, [IMAGING_RAWMODE_CMYK_L] = {"CMYK;L"},
IMAGING_RAWMODE_A, [IMAGING_RAWMODE_C_I] = {"C;I"},
IMAGING_RAWMODE_ABGR, [IMAGING_RAWMODE_Cb] = {"Cb"},
IMAGING_RAWMODE_ARGB, [IMAGING_RAWMODE_Cr] = {"Cr"},
IMAGING_RAWMODE_A_16B, [IMAGING_RAWMODE_F_16] = {"F;16"},
IMAGING_RAWMODE_A_16L, [IMAGING_RAWMODE_F_16B] = {"F;16B"},
IMAGING_RAWMODE_A_16N, [IMAGING_RAWMODE_F_16BS] = {"F;16BS"},
IMAGING_RAWMODE_B, [IMAGING_RAWMODE_F_16N] = {"F;16N"},
IMAGING_RAWMODE_BGAR, [IMAGING_RAWMODE_F_16NS] = {"F;16NS"},
IMAGING_RAWMODE_BGR, [IMAGING_RAWMODE_F_16S] = {"F;16S"},
IMAGING_RAWMODE_BGRA, [IMAGING_RAWMODE_F_32] = {"F;32"},
IMAGING_RAWMODE_BGRA_15, [IMAGING_RAWMODE_F_32B] = {"F;32B"},
IMAGING_RAWMODE_BGRA_15Z, [IMAGING_RAWMODE_F_32BF] = {"F;32BF"},
IMAGING_RAWMODE_BGRA_16B, [IMAGING_RAWMODE_F_32BS] = {"F;32BS"},
IMAGING_RAWMODE_BGRA_16L, [IMAGING_RAWMODE_F_32F] = {"F;32F"},
IMAGING_RAWMODE_BGRX, [IMAGING_RAWMODE_F_32N] = {"F;32N"},
IMAGING_RAWMODE_BGR_5, [IMAGING_RAWMODE_F_32NF] = {"F;32NF"},
IMAGING_RAWMODE_BGRa, [IMAGING_RAWMODE_F_32NS] = {"F;32NS"},
IMAGING_RAWMODE_BGXR, [IMAGING_RAWMODE_F_32S] = {"F;32S"},
IMAGING_RAWMODE_B_16B, [IMAGING_RAWMODE_F_64BF] = {"F;64BF"},
IMAGING_RAWMODE_B_16L, [IMAGING_RAWMODE_F_64F] = {"F;64F"},
IMAGING_RAWMODE_B_16N, [IMAGING_RAWMODE_F_64NF] = {"F;64NF"},
IMAGING_RAWMODE_C, [IMAGING_RAWMODE_F_8] = {"F;8"},
IMAGING_RAWMODE_CMYKX, [IMAGING_RAWMODE_F_8S] = {"F;8S"},
IMAGING_RAWMODE_CMYKXX, [IMAGING_RAWMODE_G] = {"G"},
IMAGING_RAWMODE_CMYK_16B, [IMAGING_RAWMODE_G_16B] = {"G;16B"},
IMAGING_RAWMODE_CMYK_16L, [IMAGING_RAWMODE_G_16L] = {"G;16L"},
IMAGING_RAWMODE_CMYK_16N, [IMAGING_RAWMODE_G_16N] = {"G;16N"},
IMAGING_RAWMODE_CMYK_I, [IMAGING_RAWMODE_H] = {"H"},
IMAGING_RAWMODE_CMYK_L, [IMAGING_RAWMODE_I_12] = {"I;12"},
IMAGING_RAWMODE_C_I, [IMAGING_RAWMODE_I_16BS] = {"I;16BS"},
IMAGING_RAWMODE_Cb, [IMAGING_RAWMODE_I_16NS] = {"I;16NS"},
IMAGING_RAWMODE_Cr, [IMAGING_RAWMODE_I_16R] = {"I;16R"},
IMAGING_RAWMODE_F_16, [IMAGING_RAWMODE_I_16S] = {"I;16S"},
IMAGING_RAWMODE_F_16B, [IMAGING_RAWMODE_I_32] = {"I;32"},
IMAGING_RAWMODE_F_16BS, [IMAGING_RAWMODE_I_32BS] = {"I;32BS"},
IMAGING_RAWMODE_F_16N, [IMAGING_RAWMODE_I_32N] = {"I;32N"},
IMAGING_RAWMODE_F_16NS, [IMAGING_RAWMODE_I_32NS] = {"I;32NS"},
IMAGING_RAWMODE_F_16S, [IMAGING_RAWMODE_I_32S] = {"I;32S"},
IMAGING_RAWMODE_F_32, [IMAGING_RAWMODE_I_8] = {"I;8"},
IMAGING_RAWMODE_F_32B, [IMAGING_RAWMODE_I_8S] = {"I;8S"},
IMAGING_RAWMODE_F_32BF, [IMAGING_RAWMODE_K] = {"K"},
IMAGING_RAWMODE_F_32BS, [IMAGING_RAWMODE_K_I] = {"K;I"},
IMAGING_RAWMODE_F_32F, [IMAGING_RAWMODE_LA_16B] = {"LA;16B"},
IMAGING_RAWMODE_F_32N, [IMAGING_RAWMODE_LA_L] = {"LA;L"},
IMAGING_RAWMODE_F_32NF, [IMAGING_RAWMODE_L_16] = {"L;16"},
IMAGING_RAWMODE_F_32NS, [IMAGING_RAWMODE_L_16B] = {"L;16B"},
IMAGING_RAWMODE_F_32S, [IMAGING_RAWMODE_L_2] = {"L;2"},
IMAGING_RAWMODE_F_64BF, [IMAGING_RAWMODE_L_2I] = {"L;2I"},
IMAGING_RAWMODE_F_64F, [IMAGING_RAWMODE_L_2IR] = {"L;2IR"},
IMAGING_RAWMODE_F_64NF, [IMAGING_RAWMODE_L_2R] = {"L;2R"},
IMAGING_RAWMODE_F_8, [IMAGING_RAWMODE_L_4] = {"L;4"},
IMAGING_RAWMODE_F_8S, [IMAGING_RAWMODE_L_4I] = {"L;4I"},
IMAGING_RAWMODE_G, [IMAGING_RAWMODE_L_4IR] = {"L;4IR"},
IMAGING_RAWMODE_G_16B, [IMAGING_RAWMODE_L_4R] = {"L;4R"},
IMAGING_RAWMODE_G_16L, [IMAGING_RAWMODE_L_I] = {"L;I"},
IMAGING_RAWMODE_G_16N, [IMAGING_RAWMODE_L_R] = {"L;R"},
IMAGING_RAWMODE_H, [IMAGING_RAWMODE_M] = {"M"},
IMAGING_RAWMODE_I_12, [IMAGING_RAWMODE_M_I] = {"M;I"},
IMAGING_RAWMODE_I_16BS, [IMAGING_RAWMODE_PA_L] = {"PA;L"},
IMAGING_RAWMODE_I_16NS, [IMAGING_RAWMODE_PX] = {"PX"},
IMAGING_RAWMODE_I_16R, [IMAGING_RAWMODE_P_1] = {"P;1"},
IMAGING_RAWMODE_I_16S, [IMAGING_RAWMODE_P_2] = {"P;2"},
IMAGING_RAWMODE_I_32, [IMAGING_RAWMODE_P_2L] = {"P;2L"},
IMAGING_RAWMODE_I_32BS, [IMAGING_RAWMODE_P_4] = {"P;4"},
IMAGING_RAWMODE_I_32N, [IMAGING_RAWMODE_P_4L] = {"P;4L"},
IMAGING_RAWMODE_I_32NS, [IMAGING_RAWMODE_P_R] = {"P;R"},
IMAGING_RAWMODE_I_32S, [IMAGING_RAWMODE_R] = {"R"},
IMAGING_RAWMODE_I_8, [IMAGING_RAWMODE_RGBAX] = {"RGBAX"},
IMAGING_RAWMODE_I_8S, [IMAGING_RAWMODE_RGBAXX] = {"RGBAXX"},
IMAGING_RAWMODE_K, [IMAGING_RAWMODE_RGBA_15] = {"RGBA;15"},
IMAGING_RAWMODE_K_I, [IMAGING_RAWMODE_RGBA_16B] = {"RGBA;16B"},
IMAGING_RAWMODE_LA_16B, [IMAGING_RAWMODE_RGBA_16L] = {"RGBA;16L"},
IMAGING_RAWMODE_LA_L, [IMAGING_RAWMODE_RGBA_16N] = {"RGBA;16N"},
IMAGING_RAWMODE_L_16, [IMAGING_RAWMODE_RGBA_4B] = {"RGBA;4B"},
IMAGING_RAWMODE_L_16B, [IMAGING_RAWMODE_RGBA_I] = {"RGBA;I"},
IMAGING_RAWMODE_L_2, [IMAGING_RAWMODE_RGBA_L] = {"RGBA;L"},
IMAGING_RAWMODE_L_2I, [IMAGING_RAWMODE_RGBXX] = {"RGBXX"},
IMAGING_RAWMODE_L_2IR, [IMAGING_RAWMODE_RGBXXX] = {"RGBXXX"},
IMAGING_RAWMODE_L_2R, [IMAGING_RAWMODE_RGBX_16B] = {"RGBX;16B"},
IMAGING_RAWMODE_L_4, [IMAGING_RAWMODE_RGBX_16L] = {"RGBX;16L"},
IMAGING_RAWMODE_L_4I, [IMAGING_RAWMODE_RGBX_16N] = {"RGBX;16N"},
IMAGING_RAWMODE_L_4IR, [IMAGING_RAWMODE_RGBX_L] = {"RGBX;L"},
IMAGING_RAWMODE_L_4R, [IMAGING_RAWMODE_RGB_15] = {"RGB;15"},
IMAGING_RAWMODE_L_I, [IMAGING_RAWMODE_RGB_16] = {"RGB;16"},
IMAGING_RAWMODE_L_R, [IMAGING_RAWMODE_RGB_16B] = {"RGB;16B"},
IMAGING_RAWMODE_M, [IMAGING_RAWMODE_RGB_16L] = {"RGB;16L"},
IMAGING_RAWMODE_M_I, [IMAGING_RAWMODE_RGB_16N] = {"RGB;16N"},
IMAGING_RAWMODE_PA_L, [IMAGING_RAWMODE_RGB_4B] = {"RGB;4B"},
IMAGING_RAWMODE_PX, [IMAGING_RAWMODE_RGB_L] = {"RGB;L"},
IMAGING_RAWMODE_P_1, [IMAGING_RAWMODE_RGB_R] = {"RGB;R"},
IMAGING_RAWMODE_P_2, [IMAGING_RAWMODE_RGBaX] = {"RGBaX"},
IMAGING_RAWMODE_P_2L, [IMAGING_RAWMODE_RGBaXX] = {"RGBaXX"},
IMAGING_RAWMODE_P_4, [IMAGING_RAWMODE_RGBa_16B] = {"RGBa;16B"},
IMAGING_RAWMODE_P_4L, [IMAGING_RAWMODE_RGBa_16L] = {"RGBa;16L"},
IMAGING_RAWMODE_P_R, [IMAGING_RAWMODE_RGBa_16N] = {"RGBa;16N"},
IMAGING_RAWMODE_R, [IMAGING_RAWMODE_R_16B] = {"R;16B"},
IMAGING_RAWMODE_RGBAX, [IMAGING_RAWMODE_R_16L] = {"R;16L"},
IMAGING_RAWMODE_RGBAXX, [IMAGING_RAWMODE_R_16N] = {"R;16N"},
IMAGING_RAWMODE_RGBA_15, [IMAGING_RAWMODE_S] = {"S"},
IMAGING_RAWMODE_RGBA_16B, [IMAGING_RAWMODE_V] = {"V"},
IMAGING_RAWMODE_RGBA_16L, [IMAGING_RAWMODE_X] = {"X"},
IMAGING_RAWMODE_RGBA_16N, [IMAGING_RAWMODE_XBGR] = {"XBGR"},
IMAGING_RAWMODE_RGBA_4B, [IMAGING_RAWMODE_XRGB] = {"XRGB"},
IMAGING_RAWMODE_RGBA_I, [IMAGING_RAWMODE_Y] = {"Y"},
IMAGING_RAWMODE_RGBA_L, [IMAGING_RAWMODE_YCCA_P] = {"YCCA;P"},
IMAGING_RAWMODE_RGBXX, [IMAGING_RAWMODE_YCC_P] = {"YCC;P"},
IMAGING_RAWMODE_RGBXXX, [IMAGING_RAWMODE_YCbCrK] = {"YCbCrK"},
IMAGING_RAWMODE_RGBX_16B, [IMAGING_RAWMODE_YCbCrX] = {"YCbCrX"},
IMAGING_RAWMODE_RGBX_16L, [IMAGING_RAWMODE_YCbCr_L] = {"YCbCr;L"},
IMAGING_RAWMODE_RGBX_16N, [IMAGING_RAWMODE_Y_I] = {"Y;I"},
IMAGING_RAWMODE_RGBX_L, [IMAGING_RAWMODE_aBGR] = {"aBGR"},
IMAGING_RAWMODE_RGB_15, [IMAGING_RAWMODE_aRGB] = {"aRGB"},
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,
NULL
}; };
const RawMode * findRawMode(const char * const name) { const RawModeID findRawModeID(const char * const name) {
if (name == NULL) { if (name == NULL) {
return NULL; return IMAGING_RAWMODE_UNKNOWN;
} }
const RawMode * rawmode; for (size_t i = 0; i < sizeof(RAWMODES) / sizeof(*RAWMODES); i++) {
for (int i = 0; (rawmode = RAWMODES[i]); i++) { if (strcmp(RAWMODES[i].name, name) == 0) {
if (strcmp(rawmode->name, name) == 0) { return (RawModeID)i;
return rawmode;
} }
} }
return NULL; return IMAGING_RAWMODE_UNKNOWN;
} }
int isModeI16(const Mode * const mode) { 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 return mode == IMAGING_MODE_I_16
|| mode == IMAGING_MODE_I_16L || mode == IMAGING_MODE_I_16L
|| mode == IMAGING_MODE_I_16B || mode == IMAGING_MODE_I_16B

436
src/libImaging/Mode.h
View File

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

292
src/libImaging/Pack.c
View File

@ -524,17 +524,146 @@ band3(UINT8 *out, const UINT8 *in, int pixels) {
} }
} }
static struct Packer { static struct {
const Mode *mode; const ModeID mode;
const RawMode *rawmode; const RawModeID rawmode;
int bits; int bits;
ImagingShuffler pack; ImagingShuffler pack;
} *packers = NULL; } packers[] = {
/* bilevel */
{IMAGING_MODE_1, IMAGING_RAWMODE_1, 1, pack1},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_I, 1, pack1I},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_R, 1, pack1R},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_IR, 1, pack1IR},
{IMAGING_MODE_1, IMAGING_RAWMODE_L, 8, pack1L},
/* grayscale */
{IMAGING_MODE_L, IMAGING_RAWMODE_L, 8, copy1},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16, 16, packL16},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16B, 16, packL16B},
/* grayscale w. alpha */
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA, 16, packLA},
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA_L, 16, packLAL},
/* grayscale w. alpha premultiplied */
{IMAGING_MODE_La, IMAGING_RAWMODE_La, 16, packLA},
/* palette */
{IMAGING_MODE_P, IMAGING_RAWMODE_P_1, 1, pack1},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_2, 2, packP2},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_4, 4, packP4},
{IMAGING_MODE_P, IMAGING_RAWMODE_P, 8, copy1},
/* palette w. alpha */
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA, 16, packLA},
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA_L, 16, packLAL},
/* true colour */
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA, 32, copy4},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XRGB, 32, ImagingPackXRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGRX, 32, ImagingPackBGRX},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XBGR, 32, ImagingPackXBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_L, 24, packRGBL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B, 8, band2},
/* true colour w. alpha */
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA, 32, copy4},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_L, 32, packRGBXL},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA, 32, ImagingPackBGRA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_ABGR, 32, ImagingPackABGR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRa, 32, ImagingPackBGRa},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A, 8, band3},
/* true colour w. alpha premultiplied */
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_RGBa, 32, copy4},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_BGRa, 32, ImagingPackBGRA},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_aBGR, 32, ImagingPackABGR},
/* true colour w. padding */
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_L, 32, packRGBXL},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGRX, 32, ImagingPackBGRX},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_XBGR, 32, ImagingPackXBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_X, 8, band3},
/* colour separation */
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK, 32, copy4},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_I, 32, copy4I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_L, 32, packRGBXL},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_C, 8, band0},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_M, 8, band1},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y, 8, band2},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_K, 8, band3},
/* video (YCbCr) */
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr, 24, ImagingPackRGB},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr_L, 24, packRGBL},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrX, 32, copy4},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrK, 32, copy4},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Y, 8, band0},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Cb, 8, band1},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Cr, 8, band2},
/* LAB Color */
{IMAGING_MODE_LAB, IMAGING_RAWMODE_LAB, 24, ImagingPackLAB},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_L, 8, band0},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_A, 8, band1},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_B, 8, band2},
/* HSV */
{IMAGING_MODE_HSV, IMAGING_RAWMODE_HSV, 24, ImagingPackRGB},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_H, 8, band0},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_S, 8, band1},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_V, 8, band2},
/* integer */
{IMAGING_MODE_I, IMAGING_RAWMODE_I, 32, copy4},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16B, 16, packI16B},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32S, 32, packI32S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32NS, 32, copy4},
/* floating point */
{IMAGING_MODE_F, IMAGING_RAWMODE_F, 32, copy4},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32F, 32, packI32S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32NF, 32, copy4},
/* storage modes */
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16, 16, copy2},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, packI16N_I16},
#else
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, packI16N_I16B},
#endif
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16B, 16, copy2},
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16L, 16, copy2},
{IMAGING_MODE_I_16N, IMAGING_RAWMODE_I_16N, 16, copy2},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16N, 16, packI16N_I16}, // LibTiff native->image endian.
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16N, 16, packI16N_I16},
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16N, 16, packI16N_I16B},
{IMAGING_MODE_BGR_15, IMAGING_RAWMODE_BGR_15, 16, copy2},
{IMAGING_MODE_BGR_16, IMAGING_RAWMODE_BGR_16, 16, copy2},
{IMAGING_MODE_BGR_24, IMAGING_RAWMODE_BGR_24, 24, copy3}
};
ImagingShuffler ImagingShuffler
ImagingFindPacker(const Mode *mode, const RawMode *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++) {
for (i = 0; packers[i].mode; i++) {
if (packers[i].mode == mode && packers[i].rawmode == rawmode) { if (packers[i].mode == mode && packers[i].rawmode == rawmode) {
if (bits_out) { if (bits_out) {
*bits_out = packers[i].bits; *bits_out = packers[i].bits;
@ -544,152 +673,3 @@ ImagingFindPacker(const Mode *mode, const RawMode *rawmode, int *bits_out) {
} }
return NULL; return NULL;
} }
void
ImagingPackInit(void) {
const struct Packer temp[] = {
/* bilevel */
{IMAGING_MODE_1, IMAGING_RAWMODE_1, 1, pack1},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_I, 1, pack1I},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_R, 1, pack1R},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_IR, 1, pack1IR},
{IMAGING_MODE_1, IMAGING_RAWMODE_L, 8, pack1L},
/* grayscale */
{IMAGING_MODE_L, IMAGING_RAWMODE_L, 8, copy1},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16, 16, packL16},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16B, 16, packL16B},
/* grayscale w. alpha */
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA, 16, packLA},
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA_L, 16, packLAL},
/* grayscale w. alpha premultiplied */
{IMAGING_MODE_La, IMAGING_RAWMODE_La, 16, packLA},
/* palette */
{IMAGING_MODE_P, IMAGING_RAWMODE_P_1, 1, pack1},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_2, 2, packP2},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_4, 4, packP4},
{IMAGING_MODE_P, IMAGING_RAWMODE_P, 8, copy1},
/* palette w. alpha */
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA, 16, packLA},
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA_L, 16, packLAL},
/* true colour */
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA, 32, copy4},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XRGB, 32, ImagingPackXRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGRX, 32, ImagingPackBGRX},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XBGR, 32, ImagingPackXBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_L, 24, packRGBL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B, 8, band2},
/* true colour w. alpha */
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA, 32, copy4},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_L, 32, packRGBXL},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA, 32, ImagingPackBGRA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_ABGR, 32, ImagingPackABGR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRa, 32, ImagingPackBGRa},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A, 8, band3},
/* true colour w. alpha premultiplied */
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_RGBa, 32, copy4},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_BGRa, 32, ImagingPackBGRA},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_aBGR, 32, ImagingPackABGR},
/* true colour w. padding */
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_L, 32, packRGBXL},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB, 24, ImagingPackRGB},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR, 24, ImagingPackBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGRX, 32, ImagingPackBGRX},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_XBGR, 32, ImagingPackXBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_X, 8, band3},
/* colour separation */
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK, 32, copy4},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_I, 32, copy4I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_L, 32, packRGBXL},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_C, 8, band0},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_M, 8, band1},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y, 8, band2},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_K, 8, band3},
/* video (YCbCr) */
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr, 24, ImagingPackRGB},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr_L, 24, packRGBL},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrX, 32, copy4},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrK, 32, copy4},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Y, 8, band0},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Cb, 8, band1},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_Cr, 8, band2},
/* LAB Color */
{IMAGING_MODE_LAB, IMAGING_RAWMODE_LAB, 24, ImagingPackLAB},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_L, 8, band0},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_A, 8, band1},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_B, 8, band2},
/* HSV */
{IMAGING_MODE_HSV, IMAGING_RAWMODE_HSV, 24, ImagingPackRGB},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_H, 8, band0},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_S, 8, band1},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_V, 8, band2},
/* integer */
{IMAGING_MODE_I, IMAGING_RAWMODE_I, 32, copy4},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16B, 16, packI16B},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32S, 32, packI32S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32NS, 32, copy4},
/* floating point */
{IMAGING_MODE_F, IMAGING_RAWMODE_F, 32, copy4},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32F, 32, packI32S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32NF, 32, copy4},
/* storage modes */
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16, 16, copy2},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, packI16N_I16},
#else
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, packI16N_I16B},
#endif
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16B, 16, copy2},
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16L, 16, copy2},
{IMAGING_MODE_I_16N, IMAGING_RAWMODE_I_16N, 16, copy2},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16N, 16, packI16N_I16}, // LibTiff native->image endian.
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16N, 16, packI16N_I16},
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16N, 16, packI16N_I16B},
{IMAGING_MODE_BGR_15, IMAGING_RAWMODE_BGR_15, 16, copy2},
{IMAGING_MODE_BGR_16, IMAGING_RAWMODE_BGR_16, 16, copy2},
{IMAGING_MODE_BGR_24, IMAGING_RAWMODE_BGR_24, 24, copy3},
{NULL} /* sentinel */
};
packers = malloc(sizeof(temp));
if (packers == NULL) {
fprintf(stderr, "PackInit: failed to allocate memory for packers table\n");
exit(1);
}
memcpy(packers, temp, sizeof(temp));
}
void
ImagingPackFree(void) {
free(packers);
packers = NULL;
}

2
src/libImaging/Palette.c
View File

@ -21,7 +21,7 @@
#include <math.h> #include <math.h>
ImagingPalette ImagingPalette
ImagingPaletteNew(const Mode *mode) { ImagingPaletteNew(const ModeID mode) {
/* Create a palette object */ /* Create a palette object */
int i; int i;

4
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 Mode *mode, const void *table) { ImagingPoint(Imaging imIn, ModeID mode, const void *table) {
/* lookup table transform */ /* lookup table transform */
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
@ -140,7 +140,7 @@ ImagingPoint(Imaging imIn, const Mode *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;
} }

14
src/libImaging/Storage.c
View File

@ -42,7 +42,7 @@
*/ */
Imaging Imaging
ImagingNewPrologueSubtype(const Mode *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 */
@ -225,7 +225,7 @@ ImagingNewPrologueSubtype(const Mode *mode, int xsize, int ysize, int size) {
} }
Imaging Imaging
ImagingNewPrologue(const Mode *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)
); );
@ -491,7 +491,7 @@ ImagingAllocateBlock(Imaging im) {
*/ */
Imaging Imaging
ImagingNewInternal(const Mode *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) {
@ -527,17 +527,17 @@ ImagingNewInternal(const Mode *mode, int xsize, int ysize, int dirty) {
} }
Imaging Imaging
ImagingNew(const Mode *mode, int xsize, int ysize) { ImagingNew(const ModeID mode, int xsize, int ysize) {
return ImagingNewInternal(mode, xsize, ysize, 0); return ImagingNewInternal(mode, xsize, ysize, 0);
} }
Imaging Imaging
ImagingNewDirty(const Mode *mode, int xsize, int ysize) { ImagingNewDirty(const ModeID mode, int xsize, int ysize) {
return ImagingNewInternal(mode, xsize, ysize, 1); return ImagingNewInternal(mode, xsize, ysize, 1);
} }
Imaging Imaging
ImagingNewBlock(const Mode *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) {
@ -558,7 +558,7 @@ ImagingNewBlock(const Mode *mode, int xsize, int ysize) {
} }
Imaging Imaging
ImagingNew2Dirty(const Mode *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) {

4
src/libImaging/TiffDecode.c
View File

@ -638,7 +638,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->name, getModeData(im->mode)->name,
im->type, im->type,
im->bands, im->bands,
im->xsize, im->xsize,
@ -972,7 +972,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->name, getModeData(im->mode)->name,
im->type, im->type,
im->bands, im->bands,
im->xsize, im->xsize,

624
src/libImaging/Unpack.c
View File

@ -1547,19 +1547,311 @@ band316L(UINT8 *out, const UINT8 *in, int pixels) {
} }
} }
static struct Unpacker { static struct {
const Mode *mode; const ModeID mode;
const RawMode *rawmode; const RawModeID rawmode;
int bits; int bits;
ImagingShuffler unpack; ImagingShuffler unpack;
} *unpackers = NULL; } unpackers[] = {
/* raw mode syntax is "<mode>;<bits><flags>" where "bits" defaults
depending on mode (1 for "1", 8 for "P" and "L", etc), and
"flags" should be given in alphabetical order. if both bits
and flags have their default values, the ; should be left out */
/* flags: "I" inverted data; "R" reversed bit order; "B" big
endian byte order (default is little endian); "L" line
interleave, "S" signed, "F" floating point, "Z" inverted alpha */
/* exception: rawmodes "I" and "F" are always native endian byte order */
/* bilevel */
{IMAGING_MODE_1, IMAGING_RAWMODE_1, 1, unpack1},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_I, 1, unpack1I},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_R, 1, unpack1R},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_IR, 1, unpack1IR},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_8, 8, unpack18},
/* grayscale */
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2, 2, unpackL2},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2I, 2, unpackL2I},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2R, 2, unpackL2R},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2IR, 2, unpackL2IR},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4, 4, unpackL4},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4I, 4, unpackL4I},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4R, 4, unpackL4R},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4IR, 4, unpackL4IR},
{IMAGING_MODE_L, IMAGING_RAWMODE_L, 8, copy1},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_I, 8, unpackLI},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_R, 8, unpackLR},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16, 16, unpackL16},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16B, 16, unpackL16B},
/* grayscale w. alpha */
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA, 16, unpackLA},
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA_L, 16, unpackLAL},
/* grayscale w. alpha premultiplied */
{IMAGING_MODE_La, IMAGING_RAWMODE_La, 16, unpackLA},
/* palette */
{IMAGING_MODE_P, IMAGING_RAWMODE_P_1, 1, unpackP1},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_2, 2, unpackP2},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_2L, 2, unpackP2L},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_4, 4, unpackP4},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_4L, 4, unpackP4L},
{IMAGING_MODE_P, IMAGING_RAWMODE_P, 8, copy1},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_R, 8, unpackLR},
{IMAGING_MODE_P, IMAGING_RAWMODE_L, 8, copy1},
{IMAGING_MODE_P, IMAGING_RAWMODE_PX, 16, unpackL16B},
/* palette w. alpha */
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA, 16, unpackLA},
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA_L, 16, unpackLAL},
{IMAGING_MODE_PA, IMAGING_RAWMODE_LA, 16, unpackLA},
/* true colour */
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB, 24, ImagingUnpackRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_L, 24, unpackRGBL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_R, 24, unpackRGBR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16L, 48, unpackRGB16L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16B, 48, unpackRGB16B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR, 24, ImagingUnpackBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_15, 16, ImagingUnpackRGB15},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_15, 16, ImagingUnpackBGR15},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16, 16, ImagingUnpackRGB16},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_16, 16, ImagingUnpackBGR16},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16L, 64, unpackRGBA16L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16B, 64, unpackRGBA16B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_4B, 16, ImagingUnpackRGB4B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_5, 16, ImagingUnpackBGR15}, /* compat */
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_L, 32, unpackRGBAL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBXX, 40, copy4skip1},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBXXX, 48, copy4skip2},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA_L, 32, unpackRGBAL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA_15, 16, ImagingUnpackRGBA15},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGRX, 32, ImagingUnpackBGRX},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGXR, 32, ImagingUnpackBGXR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XRGB, 32, ImagingUnpackXRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XBGR, 32, ImagingUnpackXBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_YCC_P, 24, ImagingUnpackYCC},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16L, 16, band016L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16L, 16, band116L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16L, 16, band216L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16B, 16, band016B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16B, 16, band116B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16B, 16, band216B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_CMYK, 32, cmyk2rgb},
{IMAGING_MODE_BGR_15, IMAGING_RAWMODE_BGR_15, 16, copy2},
{IMAGING_MODE_BGR_16, IMAGING_RAWMODE_BGR_16, 16, copy2},
{IMAGING_MODE_BGR_24, IMAGING_RAWMODE_BGR_24, 24, copy3},
/* true colour w. alpha */
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_LA, 16, unpackRGBALA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_LA_16B, 32, unpackRGBALA16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA, 32, copy4},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBAX, 40, copy4skip1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBAXX, 48, copy4skip2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa, 32, unpackRGBa},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBaX, 40, unpackRGBaskip1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBaXX, 48, unpackRGBaskip2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16L, 64, unpackRGBa16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16B, 64, unpackRGBa16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRa, 32, unpackBGRa},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_I, 32, unpackRGBAI},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_L, 32, unpackRGBAL},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_15, 16, ImagingUnpackRGBA15},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_15, 16, ImagingUnpackBGRA15},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_15Z, 16, ImagingUnpackBGRA15Z},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_4B, 16, ImagingUnpackRGBA4B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16L, 64, unpackRGBA16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16B, 64, unpackRGBA16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA, 32, unpackBGRA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_16L, 64, unpackBGRA16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_16B, 64, unpackBGRA16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGAR, 32, unpackBGAR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_ARGB, 32, unpackARGB},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_ABGR, 32, unpackABGR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_YCCA_P, 32, ImagingUnpackYCCA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A, 8, band3},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16L, 16, band016L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16L, 16, band116L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16L, 16, band216L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16L, 16, band316L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16B, 16, band016B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16B, 16, band116B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16B, 16, band216B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16B, 16, band316B},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16N, 48, unpackRGB16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16N, 64, unpackRGBa16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16N, 64, unpackRGBA16B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16N, 16, band016B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16N, 16, band116B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16N, 16, band216B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16N, 16, band016B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16N, 16, band116B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16N, 16, band216B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16N, 16, band316B},
#else
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16N, 48, unpackRGB16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16N, 64, unpackRGBa16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16N, 64, unpackRGBA16L},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16N, 16, band016L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16N, 16, band116L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16N, 16, band216L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16N, 16, band016L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16N, 16, band116L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16N, 16, band216L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16N, 16, band316L},
#endif
/* true colour w. alpha premultiplied */
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_RGBa, 32, copy4},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_BGRa, 32, unpackBGRA},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_aRGB, 32, unpackARGB},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_aBGR, 32, unpackABGR},
/* true colour w. padding */
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB, 24, ImagingUnpackRGB},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_L, 24, unpackRGBL},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_16B, 48, unpackRGB16B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR, 24, ImagingUnpackBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_15, 16, ImagingUnpackRGB15},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR_15, 16, ImagingUnpackBGR15},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_4B, 16, ImagingUnpackRGB4B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR_5, 16, ImagingUnpackBGR15}, /* compat */
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBXX, 40, copy4skip1},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBXXX, 48, copy4skip2},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_L, 32, unpackRGBAL},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16L, 64, unpackRGBA16L},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16B, 64, unpackRGBA16B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGRX, 32, ImagingUnpackBGRX},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_XRGB, 32, ImagingUnpackXRGB},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_XBGR, 32, ImagingUnpackXBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_YCC_P, 24, ImagingUnpackYCC},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_X, 8, band3},
/* colour separation */
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK, 32, copy4},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYKX, 40, copy4skip1},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYKXX, 48, copy4skip2},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_I, 32, unpackCMYKI},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_L, 32, unpackRGBAL},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16L, 64, unpackRGBA16L},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16B, 64, unpackRGBA16B},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_C, 8, band0},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_M, 8, band1},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y, 8, band2},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_K, 8, band3},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_C_I, 8, band0I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_M_I, 8, band1I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y_I, 8, band2I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_K_I, 8, band3I},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16N, 64, unpackRGBA16B},
#else
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16N, 64, unpackRGBA16L},
#endif
/* video (YCbCr) */
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr, 24, ImagingUnpackRGB},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr_L, 24, unpackRGBL},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrX, 32, copy4},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrK, 32, copy4},
/* LAB Color */
{IMAGING_MODE_LAB, IMAGING_RAWMODE_LAB, 24, ImagingUnpackLAB},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_L, 8, band0},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_A, 8, band1},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_B, 8, band2},
/* HSV Color */
{IMAGING_MODE_HSV, IMAGING_RAWMODE_HSV, 24, ImagingUnpackRGB},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_H, 8, band0},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_S, 8, band1},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_V, 8, band2},
/* integer variations */
{IMAGING_MODE_I, IMAGING_RAWMODE_I, 32, copy4},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_8, 8, unpackI8},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_8S, 8, unpackI8S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16, 16, unpackI16},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16S, 16, unpackI16S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16B, 16, unpackI16B},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16BS, 16, unpackI16BS},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16N, 16, unpackI16N},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16NS, 16, unpackI16NS},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32, 32, unpackI32},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32S, 32, unpackI32S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32B, 32, unpackI32B},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32BS, 32, unpackI32BS},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32N, 32, unpackI32N},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32NS, 32, unpackI32NS},
/* floating point variations */
{IMAGING_MODE_F, IMAGING_RAWMODE_F, 32, copy4},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_8, 8, unpackF8},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_8S, 8, unpackF8S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16, 16, unpackF16},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16S, 16, unpackF16S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16B, 16, unpackF16B},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16BS, 16, unpackF16BS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16N, 16, unpackF16N},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16NS, 16, unpackF16NS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32, 32, unpackF32},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32S, 32, unpackF32S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32B, 32, unpackF32B},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32BS, 32, unpackF32BS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32N, 32, unpackF32N},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32NS, 32, unpackF32NS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32F, 32, unpackF32F},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32BF, 32, unpackF32BF},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32NF, 32, unpackF32NF},
#ifdef FLOAT64
{IMAGING_MODE_F, IMAGING_RAWMODE_F_64F, 64, unpackF64F},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_64BF, 64, unpackF64BF},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_64NF, 64, unpackF64NF},
#endif
/* storage modes */
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16, 16, copy2},
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16B, 16, copy2},
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16L, 16, copy2},
{IMAGING_MODE_I_16N, IMAGING_RAWMODE_I_16N, 16, copy2},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, unpackI16B_I16},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16}, // LibTiff native->image endian.
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16}, // LibTiff native->image endian.
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16B},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16R, 16, unpackI16R_I16},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_12, 12, unpackI12_I16} // 12 bit Tiffs stored in 16bits.
};
ImagingShuffler ImagingShuffler
ImagingFindUnpacker(const Mode *mode, const RawMode *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++) {
/* find a suitable pixel unpacker */
for (i = 0; unpackers[i].rawmode; i++) {
if (unpackers[i].mode == mode && unpackers[i].rawmode == rawmode) { if (unpackers[i].mode == mode && unpackers[i].rawmode == rawmode) {
if (bits_out) { if (bits_out) {
*bits_out = unpackers[i].bits; *bits_out = unpackers[i].bits;
@ -1572,317 +1864,3 @@ ImagingFindUnpacker(const Mode *mode, const RawMode *rawmode, int *bits_out) {
return NULL; return NULL;
} }
void
ImagingUnpackInit(void) {
const struct Unpacker temp[] = {
/* raw mode syntax is "<mode>;<bits><flags>" where "bits" defaults
depending on mode (1 for "1", 8 for "P" and "L", etc), and
"flags" should be given in alphabetical order. if both bits
and flags have their default values, the ; should be left out */
/* flags: "I" inverted data; "R" reversed bit order; "B" big
endian byte order (default is little endian); "L" line
interleave, "S" signed, "F" floating point, "Z" inverted alpha */
/* exception: rawmodes "I" and "F" are always native endian byte order */
/* bilevel */
{IMAGING_MODE_1, IMAGING_RAWMODE_1, 1, unpack1},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_I, 1, unpack1I},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_R, 1, unpack1R},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_IR, 1, unpack1IR},
{IMAGING_MODE_1, IMAGING_RAWMODE_1_8, 8, unpack18},
/* grayscale */
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2, 2, unpackL2},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2I, 2, unpackL2I},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2R, 2, unpackL2R},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_2IR, 2, unpackL2IR},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4, 4, unpackL4},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4I, 4, unpackL4I},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4R, 4, unpackL4R},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_4IR, 4, unpackL4IR},
{IMAGING_MODE_L, IMAGING_RAWMODE_L, 8, copy1},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_I, 8, unpackLI},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_R, 8, unpackLR},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16, 16, unpackL16},
{IMAGING_MODE_L, IMAGING_RAWMODE_L_16B, 16, unpackL16B},
/* grayscale w. alpha */
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA, 16, unpackLA},
{IMAGING_MODE_LA, IMAGING_RAWMODE_LA_L, 16, unpackLAL},
/* grayscale w. alpha premultiplied */
{IMAGING_MODE_La, IMAGING_RAWMODE_La, 16, unpackLA},
/* palette */
{IMAGING_MODE_P, IMAGING_RAWMODE_P_1, 1, unpackP1},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_2, 2, unpackP2},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_2L, 2, unpackP2L},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_4, 4, unpackP4},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_4L, 4, unpackP4L},
{IMAGING_MODE_P, IMAGING_RAWMODE_P, 8, copy1},
{IMAGING_MODE_P, IMAGING_RAWMODE_P_R, 8, unpackLR},
{IMAGING_MODE_P, IMAGING_RAWMODE_L, 8, copy1},
{IMAGING_MODE_P, IMAGING_RAWMODE_PX, 16, unpackL16B},
/* palette w. alpha */
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA, 16, unpackLA},
{IMAGING_MODE_PA, IMAGING_RAWMODE_PA_L, 16, unpackLAL},
{IMAGING_MODE_PA, IMAGING_RAWMODE_LA, 16, unpackLA},
/* true colour */
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB, 24, ImagingUnpackRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_L, 24, unpackRGBL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_R, 24, unpackRGBR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16L, 48, unpackRGB16L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16B, 48, unpackRGB16B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR, 24, ImagingUnpackBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_15, 16, ImagingUnpackRGB15},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_15, 16, ImagingUnpackBGR15},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16, 16, ImagingUnpackRGB16},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_16, 16, ImagingUnpackBGR16},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16L, 64, unpackRGBA16L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_16B, 64, unpackRGBA16B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_4B, 16, ImagingUnpackRGB4B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGR_5, 16, ImagingUnpackBGR15}, /* compat */
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBX_L, 32, unpackRGBAL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBXX, 40, copy4skip1},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBXXX, 48, copy4skip2},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA_L, 32, unpackRGBAL},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGBA_15, 16, ImagingUnpackRGBA15},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGRX, 32, ImagingUnpackBGRX},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_BGXR, 32, ImagingUnpackBGXR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XRGB, 32, ImagingUnpackXRGB},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_XBGR, 32, ImagingUnpackXBGR},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_YCC_P, 24, ImagingUnpackYCC},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16L, 16, band016L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16L, 16, band116L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16L, 16, band216L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16B, 16, band016B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16B, 16, band116B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16B, 16, band216B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_CMYK, 32, cmyk2rgb},
{IMAGING_MODE_BGR_15, IMAGING_RAWMODE_BGR_15, 16, copy2},
{IMAGING_MODE_BGR_16, IMAGING_RAWMODE_BGR_16, 16, copy2},
{IMAGING_MODE_BGR_24, IMAGING_RAWMODE_BGR_24, 24, copy3},
/* true colour w. alpha */
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_LA, 16, unpackRGBALA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_LA_16B, 32, unpackRGBALA16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA, 32, copy4},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBAX, 40, copy4skip1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBAXX, 48, copy4skip2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa, 32, unpackRGBa},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBaX, 40, unpackRGBaskip1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBaXX, 48, unpackRGBaskip2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16L, 64, unpackRGBa16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16B, 64, unpackRGBa16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRa, 32, unpackBGRa},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_I, 32, unpackRGBAI},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_L, 32, unpackRGBAL},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_15, 16, ImagingUnpackRGBA15},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_15, 16, ImagingUnpackBGRA15},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_15Z, 16, ImagingUnpackBGRA15Z},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_4B, 16, ImagingUnpackRGBA4B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16L, 64, unpackRGBA16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16B, 64, unpackRGBA16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA, 32, unpackBGRA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_16L, 64, unpackBGRA16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGRA_16B, 64, unpackBGRA16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_BGAR, 32, unpackBGAR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_ARGB, 32, unpackARGB},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_ABGR, 32, unpackABGR},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_YCCA_P, 32, ImagingUnpackYCCA},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A, 8, band3},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16L, 16, band016L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16L, 16, band116L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16L, 16, band216L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16L, 16, band316L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16B, 16, band016B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16B, 16, band116B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16B, 16, band216B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16B, 16, band316B},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16N, 48, unpackRGB16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16N, 64, unpackRGBa16B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16N, 64, unpackRGBA16B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16N, 16, band016B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16N, 16, band116B},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16N, 16, band216B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16N, 16, band016B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16N, 16, band116B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16N, 16, band216B},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16N, 16, band316B},
#else
{IMAGING_MODE_RGB, IMAGING_RAWMODE_RGB_16N, 48, unpackRGB16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBa_16N, 64, unpackRGBa16L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_RGBA_16N, 64, unpackRGBA16L},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16N, 64, unpackRGBA16L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_R_16N, 16, band016L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_G_16N, 16, band116L},
{IMAGING_MODE_RGB, IMAGING_RAWMODE_B_16N, 16, band216L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_R_16N, 16, band016L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_G_16N, 16, band116L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_B_16N, 16, band216L},
{IMAGING_MODE_RGBA, IMAGING_RAWMODE_A_16N, 16, band316L},
#endif
/* true colour w. alpha premultiplied */
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_RGBa, 32, copy4},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_BGRa, 32, unpackBGRA},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_aRGB, 32, unpackARGB},
{IMAGING_MODE_RGBa, IMAGING_RAWMODE_aBGR, 32, unpackABGR},
/* true colour w. padding */
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB, 24, ImagingUnpackRGB},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_L, 24, unpackRGBL},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_16B, 48, unpackRGB16B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR, 24, ImagingUnpackBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_15, 16, ImagingUnpackRGB15},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR_15, 16, ImagingUnpackBGR15},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGB_4B, 16, ImagingUnpackRGB4B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGR_5, 16, ImagingUnpackBGR15}, /* compat */
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX, 32, copy4},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBXX, 40, copy4skip1},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBXXX, 48, copy4skip2},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_L, 32, unpackRGBAL},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16L, 64, unpackRGBA16L},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_RGBX_16B, 64, unpackRGBA16B},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_BGRX, 32, ImagingUnpackBGRX},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_XRGB, 32, ImagingUnpackXRGB},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_XBGR, 32, ImagingUnpackXBGR},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_YCC_P, 24, ImagingUnpackYCC},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_R, 8, band0},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_G, 8, band1},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_B, 8, band2},
{IMAGING_MODE_RGBX, IMAGING_RAWMODE_X, 8, band3},
/* colour separation */
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK, 32, copy4},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYKX, 40, copy4skip1},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYKXX, 48, copy4skip2},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_I, 32, unpackCMYKI},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_L, 32, unpackRGBAL},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16L, 64, unpackRGBA16L},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16B, 64, unpackRGBA16B},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_C, 8, band0},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_M, 8, band1},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y, 8, band2},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_K, 8, band3},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_C_I, 8, band0I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_M_I, 8, band1I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_Y_I, 8, band2I},
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_K_I, 8, band3I},
#ifdef WORDS_BIGENDIAN
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16N, 64, unpackRGBA16B},
#else
{IMAGING_MODE_CMYK, IMAGING_RAWMODE_CMYK_16N, 64, unpackRGBA16L},
#endif
/* video (YCbCr) */
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr, 24, ImagingUnpackRGB},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCr_L, 24, unpackRGBL},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrX, 32, copy4},
{IMAGING_MODE_YCbCr, IMAGING_RAWMODE_YCbCrK, 32, copy4},
/* LAB Color */
{IMAGING_MODE_LAB, IMAGING_RAWMODE_LAB, 24, ImagingUnpackLAB},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_L, 8, band0},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_A, 8, band1},
{IMAGING_MODE_LAB, IMAGING_RAWMODE_B, 8, band2},
/* HSV Color */
{IMAGING_MODE_HSV, IMAGING_RAWMODE_HSV, 24, ImagingUnpackRGB},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_H, 8, band0},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_S, 8, band1},
{IMAGING_MODE_HSV, IMAGING_RAWMODE_V, 8, band2},
/* integer variations */
{IMAGING_MODE_I, IMAGING_RAWMODE_I, 32, copy4},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_8, 8, unpackI8},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_8S, 8, unpackI8S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16, 16, unpackI16},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16S, 16, unpackI16S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16B, 16, unpackI16B},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16BS, 16, unpackI16BS},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16N, 16, unpackI16N},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_16NS, 16, unpackI16NS},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32, 32, unpackI32},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32S, 32, unpackI32S},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32B, 32, unpackI32B},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32BS, 32, unpackI32BS},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32N, 32, unpackI32N},
{IMAGING_MODE_I, IMAGING_RAWMODE_I_32NS, 32, unpackI32NS},
/* floating point variations */
{IMAGING_MODE_F, IMAGING_RAWMODE_F, 32, copy4},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_8, 8, unpackF8},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_8S, 8, unpackF8S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16, 16, unpackF16},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16S, 16, unpackF16S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16B, 16, unpackF16B},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16BS, 16, unpackF16BS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16N, 16, unpackF16N},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_16NS, 16, unpackF16NS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32, 32, unpackF32},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32S, 32, unpackF32S},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32B, 32, unpackF32B},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32BS, 32, unpackF32BS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32N, 32, unpackF32N},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32NS, 32, unpackF32NS},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32F, 32, unpackF32F},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32BF, 32, unpackF32BF},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_32NF, 32, unpackF32NF},
#ifdef FLOAT64
{IMAGING_MODE_F, IMAGING_RAWMODE_F_64F, 64, unpackF64F},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_64BF, 64, unpackF64BF},
{IMAGING_MODE_F, IMAGING_RAWMODE_F_64NF, 64, unpackF64NF},
#endif
/* storage modes */
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16, 16, copy2},
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16B, 16, copy2},
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16L, 16, copy2},
{IMAGING_MODE_I_16N, IMAGING_RAWMODE_I_16N, 16, copy2},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16B, 16, unpackI16B_I16},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16}, // LibTiff native->image endian.
{IMAGING_MODE_I_16L, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16}, // LibTiff native->image endian.
{IMAGING_MODE_I_16B, IMAGING_RAWMODE_I_16N, 16, unpackI16N_I16B},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_16R, 16, unpackI16R_I16},
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_12, 12, unpackI12_I16}, // 12 bit Tiffs stored in 16bits.
{NULL} /* sentinel */
};
unpackers = malloc(sizeof(temp));
if (unpackers == NULL) {
fprintf(stderr, "UnpackInit: failed to allocate memory for unpackers table\n");
exit(1);
}
memcpy(unpackers, temp, sizeof(temp));
}
void
ImagingUnpackFree(void) {
free(unpackers);
unpackers = NULL;
}

2
src/map.c
View File

@ -82,7 +82,7 @@ PyImaging_MapBuffer(PyObject *self, PyObject *args) {
return NULL; return NULL;
} }
const Mode * const mode = findMode(mode_name); const ModeID mode = findModeID(mode_name);
if (stride <= 0) { if (stride <= 0) {
if (mode == IMAGING_MODE_L || mode == IMAGING_MODE_P) { if (mode == IMAGING_MODE_L || mode == IMAGING_MODE_P) {