mirror of
https://github.com/python-pillow/Pillow.git
synced 2025-02-11 17:10:58 +03:00
change mode structs to enums
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
parent
20986c82aa
commit
9c02ccd0db
|
|
@ -285,7 +285,7 @@ ImagingError_Clear(void) {
|
|||
/* -------------------------------------------------------------------- */
|
||||
|
||||
static int
|
||||
getbands(const Mode *mode) {
|
||||
getbands(const ModeID mode) {
|
||||
Imaging im;
|
||||
int bands;
|
||||
|
||||
|
|
@ -649,7 +649,7 @@ _fill(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
im = ImagingNewDirty(mode, xsize, ysize);
|
||||
if (!im) {
|
||||
|
|
@ -678,7 +678,7 @@ _new(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
return PyImagingNew(ImagingNew(mode, xsize, ysize));
|
||||
}
|
||||
|
|
@ -692,7 +692,7 @@ _new_block(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
return PyImagingNew(ImagingNewBlock(mode, xsize, ysize));
|
||||
}
|
||||
|
|
@ -705,7 +705,7 @@ _linear_gradient(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
return PyImagingNew(ImagingFillLinearGradient(mode));
|
||||
}
|
||||
|
|
@ -718,7 +718,7 @@ _radial_gradient(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
return PyImagingNew(ImagingFillRadialGradient(mode));
|
||||
}
|
||||
|
|
@ -882,7 +882,7 @@ _color_lut_3d(ImagingObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
/* actually, it is trilinear */
|
||||
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(
|
||||
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));
|
||||
}
|
||||
|
|
@ -1013,12 +1013,12 @@ _convert_transparent(ImagingObject *self, PyObject *args) {
|
|||
char *mode_name;
|
||||
int 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));
|
||||
}
|
||||
PyErr_Clear();
|
||||
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 NULL;
|
||||
|
|
@ -1132,8 +1132,8 @@ _getpalette(ImagingObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
pack = ImagingFindPacker(mode, rawmode, &bits);
|
||||
if (!pack) {
|
||||
|
|
@ -1161,7 +1161,7 @@ _getpalettemode(ImagingObject *self) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
return PyUnicode_FromString(self->image->palette->mode->name);
|
||||
return PyUnicode_FromString(getModeData(self->image->palette->mode)->name);
|
||||
}
|
||||
|
||||
static inline int
|
||||
|
|
@ -1449,7 +1449,7 @@ _point(ImagingObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
if (mode == IMAGING_MODE_F) {
|
||||
FLOAT32 *data;
|
||||
|
|
@ -1746,14 +1746,14 @@ _putpalette(ImagingObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const palette_mode = findMode(palette_mode_name);
|
||||
if (palette_mode == NULL) {
|
||||
const ModeID palette_mode = findModeID(palette_mode_name);
|
||||
if (palette_mode == IMAGING_MODE_UNKNOWN) {
|
||||
PyErr_SetString(PyExc_ValueError, wrong_mode);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
if (rawmode == NULL) {
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
if (rawmode == IMAGING_RAWMODE_UNKNOWN) {
|
||||
PyErr_SetString(PyExc_ValueError, wrong_raw_mode);
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -2003,7 +2003,7 @@ _reduce(ImagingObject *self, PyObject *args) {
|
|||
}
|
||||
|
||||
static int
|
||||
isRGB(const Mode * const mode) {
|
||||
isRGB(const ModeID mode) {
|
||||
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;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
im = self->image;
|
||||
|
||||
|
|
@ -2428,7 +2428,7 @@ _merge(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
|
||||
if (band0) {
|
||||
bands[0] = band0->image;
|
||||
|
|
@ -3730,7 +3730,7 @@ static struct PyMethodDef methods[] = {
|
|||
|
||||
static PyObject *
|
||||
_getattr_mode(ImagingObject *self, void *closure) {
|
||||
return PyUnicode_FromString(self->image->mode->name);
|
||||
return PyUnicode_FromString(getModeData(self->image->mode)->name);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
|
|
@ -4374,11 +4374,6 @@ setup_module(PyObject *m) {
|
|||
return -1;
|
||||
}
|
||||
|
||||
ImagingAccessInit();
|
||||
ImagingConvertInit();
|
||||
ImagingPackInit();
|
||||
ImagingUnpackInit();
|
||||
|
||||
#ifdef HAVE_LIBJPEG
|
||||
{
|
||||
extern const char *ImagingJpegVersion(void);
|
||||
|
|
@ -4482,14 +4477,6 @@ setup_module(PyObject *m) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
free_module(void *m) {
|
||||
ImagingAccessFree();
|
||||
ImagingConvertFree();
|
||||
ImagingPackFree();
|
||||
ImagingUnpackFree();
|
||||
}
|
||||
|
||||
PyMODINIT_FUNC
|
||||
PyInit__imaging(void) {
|
||||
PyObject *m;
|
||||
|
|
@ -4500,10 +4487,6 @@ PyInit__imaging(void) {
|
|||
NULL, /* m_doc */
|
||||
-1, /* m_size */
|
||||
functions, /* m_methods */
|
||||
NULL, /* m_slots */
|
||||
NULL, /* m_traverse */
|
||||
NULL, /* m_clear */
|
||||
free_module /* m_free */
|
||||
};
|
||||
|
||||
m = PyModule_Create(&module_def);
|
||||
|
|
|
|||
44
src/decode.c
44
src/decode.c
|
|
@ -293,7 +293,7 @@ static PyTypeObject ImagingDecoderType = {
|
|||
/* -------------------------------------------------------------------- */
|
||||
|
||||
int
|
||||
get_unpacker(ImagingDecoderObject *decoder, const Mode *mode, const RawMode *rawmode) {
|
||||
get_unpacker(ImagingDecoderObject *decoder, const ModeID mode, const RawModeID rawmode) {
|
||||
int bits;
|
||||
ImagingShuffler unpack;
|
||||
|
||||
|
|
@ -468,8 +468,8 @@ PyImaging_HexDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(0);
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -508,8 +508,8 @@ PyImaging_LibTiffDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
TRACE(("new tiff decoder %s\n", compname));
|
||||
|
||||
|
|
@ -549,8 +549,8 @@ PyImaging_PackbitsDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(0);
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -603,8 +603,8 @@ PyImaging_PcxDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(0);
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -637,8 +637,8 @@ PyImaging_RawDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(sizeof(RAWSTATE));
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -673,8 +673,8 @@ PyImaging_SgiRleDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(sizeof(SGISTATE));
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -707,8 +707,8 @@ PyImaging_SunRleDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(0);
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -739,8 +739,8 @@ PyImaging_TgaRleDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(0);
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -799,8 +799,8 @@ PyImaging_ZipDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE));
|
||||
if (decoder == NULL) {
|
||||
|
|
@ -855,9 +855,9 @@ PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * rawmode = findRawMode(rawmode_name);
|
||||
const RawMode * const jpegmode = findRawMode(jpegmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
const RawModeID jpegmode = findRawModeID(jpegmode_name);
|
||||
|
||||
decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE));
|
||||
if (decoder == NULL) {
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ typedef struct {
|
|||
static PyTypeObject ImagingDisplayType;
|
||||
|
||||
static ImagingDisplayObject *
|
||||
_new(const Mode * const mode, int xsize, int ysize) {
|
||||
_new(const ModeID mode, int xsize, int ysize) {
|
||||
ImagingDisplayObject *display;
|
||||
|
||||
if (PyType_Ready(&ImagingDisplayType) < 0) {
|
||||
|
|
@ -240,7 +240,7 @@ static struct PyMethodDef methods[] = {
|
|||
|
||||
static PyObject *
|
||||
_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 *
|
||||
|
|
@ -295,7 +295,7 @@ PyImaging_DisplayWin32(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
display = _new(mode, xsize, ysize);
|
||||
if (display == NULL) {
|
||||
return NULL;
|
||||
|
|
@ -307,8 +307,8 @@ PyImaging_DisplayWin32(PyObject *self, PyObject *args) {
|
|||
PyObject *
|
||||
PyImaging_DisplayModeWin32(PyObject *self, PyObject *args) {
|
||||
int size[2];
|
||||
const Mode * const mode = ImagingGetModeDIB(size);
|
||||
return Py_BuildValue("s(ii)", mode->name, size[0], size[1]);
|
||||
const ModeID mode = ImagingGetModeDIB(size);
|
||||
return Py_BuildValue("s(ii)", getModeData(mode)->name, size[0], size[1]);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
|
|
|||
34
src/encode.c
34
src/encode.c
|
|
@ -360,7 +360,7 @@ static PyTypeObject ImagingEncoderType = {
|
|||
/* -------------------------------------------------------------------- */
|
||||
|
||||
int
|
||||
get_packer(ImagingEncoderObject *encoder, const Mode *mode, const RawMode *rawmode) {
|
||||
get_packer(ImagingEncoderObject *encoder, const ModeID mode, const RawModeID rawmode) {
|
||||
int bits;
|
||||
ImagingShuffler pack;
|
||||
|
||||
|
|
@ -370,8 +370,8 @@ get_packer(ImagingEncoderObject *encoder, const Mode *mode, const RawMode *rawmo
|
|||
PyErr_Format(
|
||||
PyExc_ValueError,
|
||||
"No packer found from %s to %s",
|
||||
mode->name,
|
||||
rawmode->name
|
||||
getModeData(mode)->name,
|
||||
getRawModeData(rawmode)->name
|
||||
);
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -421,8 +421,8 @@ PyImaging_GifEncoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
if (get_packer(encoder, mode, rawmode) < 0) {
|
||||
return NULL;
|
||||
|
|
@ -457,8 +457,8 @@ PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
if (get_packer(encoder, mode, rawmode) < 0) {
|
||||
return NULL;
|
||||
|
|
@ -491,8 +491,8 @@ PyImaging_RawEncoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
if (get_packer(encoder, mode, rawmode) < 0) {
|
||||
return NULL;
|
||||
|
|
@ -527,8 +527,8 @@ PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
if (get_packer(encoder, mode, rawmode) < 0) {
|
||||
return NULL;
|
||||
|
|
@ -615,8 +615,8 @@ PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
if (get_packer(encoder, mode, rawmode) < 0) {
|
||||
free(dictionary);
|
||||
|
|
@ -722,8 +722,8 @@ PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * const rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
const RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
if (get_packer(encoder, mode, rawmode) < 0) {
|
||||
return NULL;
|
||||
|
|
@ -1156,8 +1156,8 @@ PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const Mode * const mode = findMode(mode_name);
|
||||
const RawMode * rawmode = findRawMode(rawmode_name);
|
||||
const ModeID mode = findModeID(mode_name);
|
||||
RawModeID rawmode = findRawModeID(rawmode_name);
|
||||
|
||||
// libjpeg-turbo supports different output formats.
|
||||
// We are choosing Pillow's native format (3 color bytes + 1 padding)
|
||||
|
|
|
|||
|
|
@ -151,11 +151,7 @@ put_pixel_32(Imaging im, int x, int y, const void *color) {
|
|||
memcpy(&im->image32[y][x], color, sizeof(INT32));
|
||||
}
|
||||
|
||||
static struct ImagingAccessInstance *accessors = NULL;
|
||||
|
||||
void
|
||||
ImagingAccessInit(void) {
|
||||
const struct ImagingAccessInstance temp[] = {
|
||||
static struct ImagingAccessInstance accessors[] = {
|
||||
{IMAGING_MODE_1, get_pixel_8, put_pixel_8},
|
||||
{IMAGING_MODE_L, get_pixel_8, put_pixel_8},
|
||||
{IMAGING_MODE_LA, get_pixel_32_2bands, put_pixel_32},
|
||||
|
|
@ -184,21 +180,12 @@ ImagingAccessInit(void) {
|
|||
{IMAGING_MODE_CMYK, 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_HSV, get_pixel_32, put_pixel_32},
|
||||
{NULL}
|
||||
{IMAGING_MODE_HSV, get_pixel_32, put_pixel_32}
|
||||
};
|
||||
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
|
||||
ImagingAccessNew(const Imaging im) {
|
||||
int i;
|
||||
for (i = 0; accessors[i].mode; i++) {
|
||||
for (size_t i = 0; i < sizeof(accessors) / sizeof(*accessors); i++) {
|
||||
if (im->mode == accessors[i].mode) {
|
||||
return &accessors[i];
|
||||
}
|
||||
|
|
@ -208,9 +195,3 @@ ImagingAccessNew(const Imaging im) {
|
|||
|
||||
void
|
||||
_ImagingAccessDelete(Imaging im, ImagingAccess access) {}
|
||||
|
||||
void
|
||||
ImagingAccessFree(void) {
|
||||
free(accessors);
|
||||
accessors = NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -240,7 +240,7 @@ ImagingFillBand(Imaging imOut, int band, int color) {
|
|||
}
|
||||
|
||||
Imaging
|
||||
ImagingMerge(const Mode *mode, Imaging bands[4]) {
|
||||
ImagingMerge(const ModeID mode, Imaging bands[4]) {
|
||||
int i, x, y;
|
||||
int bandsCount = 0;
|
||||
Imaging imOut;
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
#define CHOP(operation) \
|
||||
int x, y; \
|
||||
Imaging imOut; \
|
||||
imOut = create(imIn1, imIn2, NULL); \
|
||||
imOut = create(imIn1, imIn2, IMAGING_MODE_UNKNOWN); \
|
||||
if (!imOut) { \
|
||||
return NULL; \
|
||||
} \
|
||||
|
|
@ -60,11 +60,11 @@
|
|||
return imOut;
|
||||
|
||||
static Imaging
|
||||
create(Imaging im1, Imaging im2, const Mode *mode) {
|
||||
create(Imaging im1, Imaging im2, const ModeID mode) {
|
||||
int xsize, ysize;
|
||||
|
||||
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();
|
||||
}
|
||||
if (im1->type != im2->type || im1->bands != im2->bands) {
|
||||
|
|
@ -129,12 +129,12 @@ ImagingChopXor(Imaging imIn1, Imaging imIn2) {
|
|||
|
||||
Imaging
|
||||
ImagingChopAddModulo(Imaging imIn1, Imaging imIn2) {
|
||||
CHOP2(in1[x] + in2[x], NULL);
|
||||
CHOP2(in1[x] + in2[x], IMAGING_MODE_UNKNOWN);
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingChopSubtractModulo(Imaging imIn1, Imaging imIn2) {
|
||||
CHOP2(in1[x] - in2[x], NULL);
|
||||
CHOP2(in1[x] - in2[x], IMAGING_MODE_UNKNOWN);
|
||||
}
|
||||
|
||||
Imaging
|
||||
|
|
@ -142,7 +142,7 @@ ImagingChopSoftLight(Imaging imIn1, Imaging imIn2) {
|
|||
CHOP2(
|
||||
(((255 - in1[x]) * (in1[x] * in2[x])) / 65536) +
|
||||
(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(
|
||||
(in2[x] < 128) ? ((in1[x] * in2[x]) / 127)
|
||||
: 255 - (((255 - in2[x]) * (255 - in1[x])) / 127),
|
||||
NULL
|
||||
IMAGING_MODE_UNKNOWN
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -160,6 +160,6 @@ ImagingOverlay(Imaging imIn1, Imaging imIn2) {
|
|||
CHOP2(
|
||||
(in1[x] < 128) ? ((in1[x] * in2[x]) / 127)
|
||||
: 255 - (((255 - in1[x]) * (255 - in2[x])) / 127),
|
||||
NULL
|
||||
IMAGING_MODE_UNKNOWN
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1122,7 +1122,7 @@ pa2ycbcr(UINT8 *out, const UINT8 *in, int xsize, ImagingPalette palette) {
|
|||
}
|
||||
|
||||
static Imaging
|
||||
frompalette(Imaging imOut, Imaging imIn, const Mode *mode) {
|
||||
frompalette(Imaging imOut, Imaging imIn, const ModeID mode) {
|
||||
ImagingSectionCookie cookie;
|
||||
int alpha;
|
||||
int y;
|
||||
|
|
@ -1192,7 +1192,7 @@ frompalette(Imaging imOut, Imaging imIn, const Mode *mode) {
|
|||
#endif
|
||||
static Imaging
|
||||
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;
|
||||
int alpha;
|
||||
|
|
@ -1488,202 +1488,11 @@ tobilevel(Imaging imOut, Imaging imIn) {
|
|||
/* Conversion handlers */
|
||||
/* ------------------- */
|
||||
|
||||
static struct Converter {
|
||||
const Mode *from;
|
||||
const Mode *to;
|
||||
static struct {
|
||||
const ModeID from;
|
||||
const ModeID to;
|
||||
ImagingShuffler convert;
|
||||
} *converters = NULL;
|
||||
|
||||
static Imaging
|
||||
convert(
|
||||
Imaging imOut, Imaging imIn, const Mode *mode, ImagingPalette palette, int dither
|
||||
) {
|
||||
ImagingSectionCookie cookie;
|
||||
ImagingShuffler convert;
|
||||
int y;
|
||||
|
||||
if (!imIn) {
|
||||
return (Imaging)ImagingError_ModeError();
|
||||
}
|
||||
|
||||
if (!mode) {
|
||||
/* Map palette image to full depth */
|
||||
if (!imIn->palette) {
|
||||
return (Imaging)ImagingError_ModeError();
|
||||
}
|
||||
mode = imIn->palette->mode;
|
||||
} else {
|
||||
/* Same mode? */
|
||||
if (imIn->mode == mode) {
|
||||
return ImagingCopy2(imOut, imIn);
|
||||
}
|
||||
}
|
||||
|
||||
/* test for special conversions */
|
||||
|
||||
if (imIn->mode == IMAGING_MODE_P || imIn->mode == IMAGING_MODE_PA) {
|
||||
return frompalette(imOut, imIn, mode);
|
||||
}
|
||||
|
||||
if (mode == IMAGING_MODE_P || mode == IMAGING_MODE_PA) {
|
||||
return topalette(imOut, imIn, mode, palette, dither);
|
||||
}
|
||||
|
||||
if (dither && mode == IMAGING_MODE_1) {
|
||||
return tobilevel(imOut, imIn);
|
||||
}
|
||||
|
||||
/* standard conversion machinery */
|
||||
|
||||
convert = NULL;
|
||||
|
||||
for (y = 0; converters[y].from; y++) {
|
||||
if (imIn->mode == converters[y].from && mode == converters[y].to) {
|
||||
convert = converters[y].convert;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!convert) {
|
||||
#ifdef notdef
|
||||
return (Imaging)ImagingError_ValueError("conversion not supported");
|
||||
#else
|
||||
static char buf[100];
|
||||
snprintf(
|
||||
buf, 100, "conversion from %.10s to %.10s not supported", imIn->mode->name, mode->name
|
||||
);
|
||||
return (Imaging)ImagingError_ValueError(buf);
|
||||
#endif
|
||||
}
|
||||
|
||||
imOut = ImagingNew2Dirty(mode, imOut, imIn);
|
||||
if (!imOut) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ImagingSectionEnter(&cookie);
|
||||
for (y = 0; y < imIn->ysize; y++) {
|
||||
(*convert)((UINT8 *)imOut->image[y], (UINT8 *)imIn->image[y], imIn->xsize);
|
||||
}
|
||||
ImagingSectionLeave(&cookie);
|
||||
|
||||
return imOut;
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvert(Imaging imIn, const Mode *mode, ImagingPalette palette, int dither) {
|
||||
return convert(NULL, imIn, mode, palette, dither);
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvert2(Imaging imOut, Imaging imIn) {
|
||||
return convert(imOut, imIn, imOut->mode, NULL, 0);
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvertTransparent(Imaging imIn, const Mode *mode, int r, int g, int b) {
|
||||
ImagingSectionCookie cookie;
|
||||
ImagingShuffler convert;
|
||||
Imaging imOut = NULL;
|
||||
int premultiplied = 0;
|
||||
// If the transparency matches pixels in the source image, not the converted image
|
||||
UINT8 *source;
|
||||
int source_transparency = 0;
|
||||
int y;
|
||||
|
||||
if (!imIn) {
|
||||
return (Imaging)ImagingError_ModeError();
|
||||
}
|
||||
|
||||
if (imIn->mode == IMAGING_MODE_RGB && (mode == IMAGING_MODE_RGBA || mode == IMAGING_MODE_RGBa)) {
|
||||
convert = rgb2rgba;
|
||||
if (mode == IMAGING_MODE_RGBa) {
|
||||
premultiplied = 1;
|
||||
}
|
||||
} else if (imIn->mode == IMAGING_MODE_RGB && (mode == IMAGING_MODE_LA || mode == IMAGING_MODE_La)) {
|
||||
convert = rgb2la;
|
||||
source_transparency = 1;
|
||||
if (mode == IMAGING_MODE_La) {
|
||||
premultiplied = 1;
|
||||
}
|
||||
} else if ((imIn->mode == IMAGING_MODE_1 ||
|
||||
imIn->mode == IMAGING_MODE_I ||
|
||||
imIn->mode == IMAGING_MODE_I_16 ||
|
||||
imIn->mode == IMAGING_MODE_L
|
||||
) && (
|
||||
mode == IMAGING_MODE_RGBA ||
|
||||
mode == IMAGING_MODE_LA
|
||||
)) {
|
||||
if (imIn->mode == IMAGING_MODE_1) {
|
||||
convert = bit2rgb;
|
||||
} else if (imIn->mode == IMAGING_MODE_I) {
|
||||
convert = i2rgb;
|
||||
} else if (imIn->mode == IMAGING_MODE_I_16) {
|
||||
convert = I16_RGB;
|
||||
} else {
|
||||
convert = l2rgb;
|
||||
}
|
||||
g = b = r;
|
||||
} else {
|
||||
static char buf[100];
|
||||
snprintf(
|
||||
buf,
|
||||
100,
|
||||
"conversion from %.10s to %.10s not supported in convert_transparent",
|
||||
imIn->mode->name,
|
||||
mode->name
|
||||
);
|
||||
return (Imaging)ImagingError_ValueError(buf);
|
||||
}
|
||||
|
||||
imOut = ImagingNew2Dirty(mode, imOut, imIn);
|
||||
if (!imOut) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ImagingSectionEnter(&cookie);
|
||||
for (y = 0; y < imIn->ysize; y++) {
|
||||
(*convert)((UINT8 *)imOut->image[y], (UINT8 *)imIn->image[y], imIn->xsize);
|
||||
|
||||
source = source_transparency ? (UINT8 *)imIn->image[y] : NULL;
|
||||
rgbT2a((UINT8 *)imOut->image[y], source, imIn->xsize, r, g, b, premultiplied);
|
||||
}
|
||||
ImagingSectionLeave(&cookie);
|
||||
|
||||
return imOut;
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvertInPlace(Imaging imIn, const Mode *mode) {
|
||||
ImagingSectionCookie cookie;
|
||||
ImagingShuffler convert;
|
||||
int y;
|
||||
|
||||
/* limited support for inplace conversion */
|
||||
if (imIn->mode == IMAGING_MODE_L && mode == IMAGING_MODE_1) {
|
||||
convert = l2bit;
|
||||
} else if (imIn->mode == IMAGING_MODE_1 && mode == IMAGING_MODE_L) {
|
||||
convert = bit2l;
|
||||
} else {
|
||||
return ImagingError_ModeError();
|
||||
}
|
||||
|
||||
ImagingSectionEnter(&cookie);
|
||||
for (y = 0; y < imIn->ysize; y++) {
|
||||
(*convert)((UINT8 *)imIn->image[y], (UINT8 *)imIn->image[y], imIn->xsize);
|
||||
}
|
||||
ImagingSectionLeave(&cookie);
|
||||
|
||||
return imIn;
|
||||
}
|
||||
|
||||
/* ------------------ */
|
||||
/* Converter mappings */
|
||||
/* ------------------ */
|
||||
|
||||
void
|
||||
ImagingConvertInit(void) {
|
||||
const struct Converter temp[] = {
|
||||
} converters[] = {
|
||||
{IMAGING_MODE_1, IMAGING_MODE_L, bit2l},
|
||||
{IMAGING_MODE_1, IMAGING_MODE_I, bit2i},
|
||||
{IMAGING_MODE_1, IMAGING_MODE_F, bit2f},
|
||||
|
|
@ -1811,20 +1620,188 @@ ImagingConvertInit(void) {
|
|||
|
||||
{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}
|
||||
{IMAGING_MODE_I_16B, IMAGING_MODE_F, I16B_F}
|
||||
};
|
||||
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));
|
||||
|
||||
static Imaging
|
||||
convert(Imaging imOut, Imaging imIn, ModeID mode, ImagingPalette palette, int dither) {
|
||||
ImagingSectionCookie cookie;
|
||||
ImagingShuffler convert;
|
||||
|
||||
if (!imIn) {
|
||||
return (Imaging)ImagingError_ModeError();
|
||||
}
|
||||
|
||||
void
|
||||
ImagingConvertFree(void) {
|
||||
free(converters);
|
||||
converters = NULL;
|
||||
if (mode == IMAGING_MODE_UNKNOWN) {
|
||||
/* Map palette image to full depth */
|
||||
if (!imIn->palette) {
|
||||
return (Imaging)ImagingError_ModeError();
|
||||
}
|
||||
mode = imIn->palette->mode;
|
||||
} else {
|
||||
/* Same mode? */
|
||||
if (imIn->mode == mode) {
|
||||
return ImagingCopy2(imOut, imIn);
|
||||
}
|
||||
}
|
||||
|
||||
/* test for special conversions */
|
||||
|
||||
if (imIn->mode == IMAGING_MODE_P || imIn->mode == IMAGING_MODE_PA) {
|
||||
return frompalette(imOut, imIn, mode);
|
||||
}
|
||||
|
||||
if (mode == IMAGING_MODE_P || mode == IMAGING_MODE_PA) {
|
||||
return topalette(imOut, imIn, mode, palette, dither);
|
||||
}
|
||||
|
||||
if (dither && mode == IMAGING_MODE_1) {
|
||||
return tobilevel(imOut, imIn);
|
||||
}
|
||||
|
||||
/* standard conversion machinery */
|
||||
|
||||
convert = NULL;
|
||||
for (size_t i = 0; i < sizeof(converters) / sizeof(*converters); i++) {
|
||||
if (imIn->mode == converters[i].from && mode == converters[i].to) {
|
||||
convert = converters[i].convert;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!convert) {
|
||||
#ifdef notdef
|
||||
return (Imaging)ImagingError_ValueError("conversion not supported");
|
||||
#else
|
||||
static char buf[100];
|
||||
snprintf(
|
||||
buf,
|
||||
100,
|
||||
"conversion from %.10s to %.10s not supported",
|
||||
getModeData(imIn->mode)->name,
|
||||
getModeData(mode)->name
|
||||
);
|
||||
return (Imaging)ImagingError_ValueError(buf);
|
||||
#endif
|
||||
}
|
||||
|
||||
imOut = ImagingNew2Dirty(mode, imOut, imIn);
|
||||
if (!imOut) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ImagingSectionEnter(&cookie);
|
||||
for (int y = 0; y < imIn->ysize; y++) {
|
||||
(*convert)((UINT8 *)imOut->image[y], (UINT8 *)imIn->image[y], imIn->xsize);
|
||||
}
|
||||
ImagingSectionLeave(&cookie);
|
||||
|
||||
return imOut;
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvert(Imaging imIn, const ModeID mode, ImagingPalette palette, int dither) {
|
||||
return convert(NULL, imIn, mode, palette, dither);
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvert2(Imaging imOut, Imaging imIn) {
|
||||
return convert(imOut, imIn, imOut->mode, NULL, 0);
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvertTransparent(Imaging imIn, const ModeID mode, int r, int g, int b) {
|
||||
ImagingSectionCookie cookie;
|
||||
ImagingShuffler convert;
|
||||
Imaging imOut = NULL;
|
||||
int premultiplied = 0;
|
||||
// If the transparency matches pixels in the source image, not the converted image
|
||||
UINT8 *source;
|
||||
int source_transparency = 0;
|
||||
int y;
|
||||
|
||||
if (!imIn) {
|
||||
return (Imaging)ImagingError_ModeError();
|
||||
}
|
||||
|
||||
if (imIn->mode == IMAGING_MODE_RGB && (mode == IMAGING_MODE_RGBA || mode == IMAGING_MODE_RGBa)) {
|
||||
convert = rgb2rgba;
|
||||
if (mode == IMAGING_MODE_RGBa) {
|
||||
premultiplied = 1;
|
||||
}
|
||||
} else if (imIn->mode == IMAGING_MODE_RGB && (mode == IMAGING_MODE_LA || mode == IMAGING_MODE_La)) {
|
||||
convert = rgb2la;
|
||||
source_transparency = 1;
|
||||
if (mode == IMAGING_MODE_La) {
|
||||
premultiplied = 1;
|
||||
}
|
||||
} else if ((imIn->mode == IMAGING_MODE_1 ||
|
||||
imIn->mode == IMAGING_MODE_I ||
|
||||
imIn->mode == IMAGING_MODE_I_16 ||
|
||||
imIn->mode == IMAGING_MODE_L
|
||||
) && (
|
||||
mode == IMAGING_MODE_RGBA ||
|
||||
mode == IMAGING_MODE_LA
|
||||
)) {
|
||||
if (imIn->mode == IMAGING_MODE_1) {
|
||||
convert = bit2rgb;
|
||||
} else if (imIn->mode == IMAGING_MODE_I) {
|
||||
convert = i2rgb;
|
||||
} else if (imIn->mode == IMAGING_MODE_I_16) {
|
||||
convert = I16_RGB;
|
||||
} else {
|
||||
convert = l2rgb;
|
||||
}
|
||||
g = b = r;
|
||||
} else {
|
||||
static char buf[100];
|
||||
snprintf(
|
||||
buf,
|
||||
100,
|
||||
"conversion from %.10s to %.10s not supported in convert_transparent",
|
||||
getModeData(imIn->mode)->name,
|
||||
getModeData(mode)->name
|
||||
);
|
||||
return (Imaging)ImagingError_ValueError(buf);
|
||||
}
|
||||
|
||||
imOut = ImagingNew2Dirty(mode, imOut, imIn);
|
||||
if (!imOut) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ImagingSectionEnter(&cookie);
|
||||
for (y = 0; y < imIn->ysize; y++) {
|
||||
(*convert)((UINT8 *)imOut->image[y], (UINT8 *)imIn->image[y], imIn->xsize);
|
||||
|
||||
source = source_transparency ? (UINT8 *)imIn->image[y] : NULL;
|
||||
rgbT2a((UINT8 *)imOut->image[y], source, imIn->xsize, r, g, b, premultiplied);
|
||||
}
|
||||
ImagingSectionLeave(&cookie);
|
||||
|
||||
return imOut;
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingConvertInPlace(Imaging imIn, const ModeID mode) {
|
||||
ImagingSectionCookie cookie;
|
||||
ImagingShuffler convert;
|
||||
int y;
|
||||
|
||||
/* limited support for inplace conversion */
|
||||
if (imIn->mode == IMAGING_MODE_L && mode == IMAGING_MODE_1) {
|
||||
convert = l2bit;
|
||||
} else if (imIn->mode == IMAGING_MODE_1 && mode == IMAGING_MODE_L) {
|
||||
convert = bit2l;
|
||||
} else {
|
||||
return ImagingError_ModeError();
|
||||
}
|
||||
|
||||
ImagingSectionEnter(&cookie);
|
||||
for (y = 0; y < imIn->ysize; y++) {
|
||||
(*convert)((UINT8 *)imIn->image[y], (UINT8 *)imIn->image[y], imIn->xsize);
|
||||
}
|
||||
ImagingSectionLeave(&cookie);
|
||||
|
||||
return imIn;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,13 +25,13 @@
|
|||
|
||||
#include "ImDib.h"
|
||||
|
||||
const Mode *
|
||||
ModeID
|
||||
ImagingGetModeDIB(int size_out[2]) {
|
||||
/* Get device characteristics */
|
||||
|
||||
const HDC dc = CreateCompatibleDC(NULL);
|
||||
|
||||
const Mode *mode = IMAGING_MODE_P;
|
||||
ModeID mode = IMAGING_MODE_P;
|
||||
if (!(GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)) {
|
||||
mode = IMAGING_MODE_RGB;
|
||||
if (GetDeviceCaps(dc, BITSPIXEL) == 1) {
|
||||
|
|
@ -50,7 +50,7 @@ ImagingGetModeDIB(int size_out[2]) {
|
|||
}
|
||||
|
||||
ImagingDIB
|
||||
ImagingNewDIB(const Mode * const mode, int xsize, int ysize) {
|
||||
ImagingNewDIB(const ModeID mode, int xsize, int ysize) {
|
||||
/* Create a Windows bitmap */
|
||||
|
||||
ImagingDIB dib;
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ ImagingFill(Imaging im, const void *colour) {
|
|||
}
|
||||
|
||||
Imaging
|
||||
ImagingFillLinearGradient(const Mode *mode) {
|
||||
ImagingFillLinearGradient(const ModeID mode) {
|
||||
Imaging im;
|
||||
int y;
|
||||
|
||||
|
|
@ -105,7 +105,7 @@ ImagingFillLinearGradient(const Mode *mode) {
|
|||
}
|
||||
|
||||
Imaging
|
||||
ImagingFillRadialGradient(const Mode *mode) {
|
||||
ImagingFillRadialGradient(const ModeID mode) {
|
||||
Imaging im;
|
||||
int x, y;
|
||||
int d;
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ struct ImagingDIBInstance {
|
|||
UINT8 *bits;
|
||||
HPALETTE palette;
|
||||
/* Used by cut and paste */
|
||||
const Mode *mode;
|
||||
ModeID mode;
|
||||
int xsize, ysize;
|
||||
int pixelsize;
|
||||
int linesize;
|
||||
|
|
@ -37,11 +37,11 @@ struct ImagingDIBInstance {
|
|||
|
||||
typedef struct ImagingDIBInstance *ImagingDIB;
|
||||
|
||||
extern const Mode *
|
||||
extern ModeID
|
||||
ImagingGetModeDIB(int size_out[2]);
|
||||
|
||||
extern ImagingDIB
|
||||
ImagingNewDIB(const Mode * const mode, int xsize, int ysize);
|
||||
ImagingNewDIB(ModeID mode, int xsize, int ysize);
|
||||
|
||||
extern void
|
||||
ImagingDeleteDIB(ImagingDIB im);
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ typedef struct {
|
|||
|
||||
struct ImagingMemoryInstance {
|
||||
/* Format */
|
||||
const Mode *mode; /* Image mode (IMAGING_MODE_*) */
|
||||
ModeID mode; /* Image mode (IMAGING_MODE_*) */
|
||||
int type; /* Data type (IMAGING_TYPE_*) */
|
||||
int depth; /* Depth (ignored in this version) */
|
||||
int bands; /* Number of bands (1, 2, 3, or 4) */
|
||||
|
|
@ -120,14 +120,14 @@ struct ImagingMemoryInstance {
|
|||
#define IMAGING_PIXEL_FLOAT32(im, x, y) (((FLOAT32 *)(im)->image32[y])[x])
|
||||
|
||||
struct ImagingAccessInstance {
|
||||
const Mode *mode;
|
||||
ModeID mode;
|
||||
void (*get_pixel)(Imaging im, int x, int y, void *pixel);
|
||||
void (*put_pixel)(Imaging im, int x, int y, const void *pixel);
|
||||
};
|
||||
|
||||
struct ImagingHistogramInstance {
|
||||
/* 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) */
|
||||
|
||||
/* Data */
|
||||
|
|
@ -136,7 +136,7 @@ struct ImagingHistogramInstance {
|
|||
|
||||
struct ImagingPaletteInstance {
|
||||
/* Format */
|
||||
const Mode *mode;
|
||||
ModeID mode;
|
||||
|
||||
/* Data */
|
||||
int size;
|
||||
|
|
@ -163,29 +163,6 @@ typedef struct ImagingMemoryArena {
|
|||
#endif
|
||||
} *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 */
|
||||
/* ------- */
|
||||
|
||||
|
|
@ -196,21 +173,21 @@ extern void
|
|||
ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size);
|
||||
|
||||
extern Imaging
|
||||
ImagingNew(const Mode *mode, int xsize, int ysize);
|
||||
ImagingNew(ModeID mode, int xsize, int ysize);
|
||||
extern Imaging
|
||||
ImagingNewDirty(const Mode *mode, int xsize, int ysize);
|
||||
ImagingNewDirty(ModeID mode, int xsize, int ysize);
|
||||
extern Imaging
|
||||
ImagingNew2Dirty(const Mode *mode, Imaging imOut, Imaging imIn);
|
||||
ImagingNew2Dirty(ModeID mode, Imaging imOut, Imaging imIn);
|
||||
extern void
|
||||
ImagingDelete(Imaging im);
|
||||
|
||||
extern Imaging
|
||||
ImagingNewBlock(const Mode *mode, int xsize, int ysize);
|
||||
ImagingNewBlock(ModeID mode, int xsize, int ysize);
|
||||
|
||||
extern Imaging
|
||||
ImagingNewPrologue(const Mode *mode, int xsize, int ysize);
|
||||
ImagingNewPrologue(ModeID mode, int xsize, int ysize);
|
||||
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
|
||||
ImagingCopyPalette(Imaging destination, Imaging source);
|
||||
|
|
@ -225,7 +202,7 @@ _ImagingAccessDelete(Imaging im, ImagingAccess access);
|
|||
#define ImagingAccessDelete(im, access) /* nop, for now */
|
||||
|
||||
extern ImagingPalette
|
||||
ImagingPaletteNew(const Mode *mode);
|
||||
ImagingPaletteNew(ModeID mode);
|
||||
extern ImagingPalette
|
||||
ImagingPaletteNewBrowser(void);
|
||||
extern ImagingPalette
|
||||
|
|
@ -301,13 +278,13 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha);
|
|||
extern Imaging
|
||||
ImagingCopy(Imaging im);
|
||||
extern Imaging
|
||||
ImagingConvert(Imaging im, const Mode *mode, ImagingPalette palette, int dither);
|
||||
ImagingConvert(Imaging im, ModeID mode, ImagingPalette palette, int dither);
|
||||
extern Imaging
|
||||
ImagingConvertInPlace(Imaging im, const Mode *mode);
|
||||
ImagingConvertInPlace(Imaging im, ModeID mode);
|
||||
extern Imaging
|
||||
ImagingConvertMatrix(Imaging im, const Mode *mode, float m[]);
|
||||
ImagingConvertMatrix(Imaging im, ModeID mode, float m[]);
|
||||
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
|
||||
ImagingCrop(Imaging im, int x0, int y0, int x1, int y1);
|
||||
extern Imaging
|
||||
|
|
@ -321,9 +298,9 @@ ImagingFill2(
|
|||
extern Imaging
|
||||
ImagingFillBand(Imaging im, int band, int color);
|
||||
extern Imaging
|
||||
ImagingFillLinearGradient(const Mode *mode);
|
||||
ImagingFillLinearGradient(ModeID mode);
|
||||
extern Imaging
|
||||
ImagingFillRadialGradient(const Mode *mode);
|
||||
ImagingFillRadialGradient(ModeID mode);
|
||||
extern Imaging
|
||||
ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32 *kernel, FLOAT32 offset);
|
||||
extern Imaging
|
||||
|
|
@ -337,7 +314,7 @@ ImagingGaussianBlur(
|
|||
extern Imaging
|
||||
ImagingGetBand(Imaging im, int band);
|
||||
extern Imaging
|
||||
ImagingMerge(const Mode *mode, Imaging bands[4]);
|
||||
ImagingMerge(ModeID mode, Imaging bands[4]);
|
||||
extern int
|
||||
ImagingSplit(Imaging im, Imaging bands[4]);
|
||||
extern int
|
||||
|
|
@ -364,7 +341,7 @@ ImagingOffset(Imaging im, int xoffset, int yoffset);
|
|||
extern int
|
||||
ImagingPaste(Imaging into, Imaging im, Imaging mask, int x0, int y0, int x1, int y1);
|
||||
extern Imaging
|
||||
ImagingPoint(Imaging im, const Mode *tablemode, const void *table);
|
||||
ImagingPoint(Imaging im, ModeID tablemode, const void *table);
|
||||
extern Imaging
|
||||
ImagingPointTransform(Imaging imIn, double scale, double offset);
|
||||
extern Imaging
|
||||
|
|
@ -692,9 +669,9 @@ extern void
|
|||
ImagingConvertYCbCr2RGB(UINT8 *out, const UINT8 *in, int pixels);
|
||||
|
||||
extern ImagingShuffler
|
||||
ImagingFindUnpacker(const Mode *mode, const RawMode *rawmode, int *bits_out);
|
||||
ImagingFindUnpacker(ModeID mode, RawModeID rawmode, int *bits_out);
|
||||
extern ImagingShuffler
|
||||
ImagingFindPacker(const Mode *mode, const RawMode *rawmode, int *bits_out);
|
||||
ImagingFindPacker(ModeID mode, RawModeID rawmode, int *bits_out);
|
||||
|
||||
struct ImagingCodecStateInstance {
|
||||
int count;
|
||||
|
|
|
|||
|
|
@ -28,12 +28,12 @@ typedef struct {
|
|||
typedef struct {
|
||||
/* CONFIGURATION */
|
||||
|
||||
/* Jpeg file mode (NULL if not known) */
|
||||
const RawMode *jpegmode;
|
||||
/* Jpeg file mode */
|
||||
RawModeID jpegmode;
|
||||
|
||||
/* Converter output mode (input to the shuffler) */
|
||||
/* If NULL, convert conversions are disabled */
|
||||
const RawMode *rawmode;
|
||||
/* If not a valid mode, convert conversions are disabled */
|
||||
RawModeID rawmode;
|
||||
|
||||
/* If set, trade quality for speed */
|
||||
int draft;
|
||||
|
|
@ -91,7 +91,7 @@ typedef struct {
|
|||
unsigned int restart_marker_rows;
|
||||
|
||||
/* Converter input mode (input to the shuffler) */
|
||||
const RawMode *rawmode;
|
||||
RawModeID rawmode;
|
||||
|
||||
/* Custom quantization tables () */
|
||||
unsigned int *qtables;
|
||||
|
|
|
|||
|
|
@ -770,7 +770,7 @@ j2k_decode_entry(Imaging im, ImagingCodecState state) {
|
|||
if (color_space == j2k_unpackers[n].color_space &&
|
||||
image->numcomps == j2k_unpackers[n].components &&
|
||||
(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;
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -180,8 +180,8 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t by
|
|||
|
||||
/* Decoder settings */
|
||||
|
||||
/* jpegmode indicates what's in the file; if not set, we'll
|
||||
trust the decoder */
|
||||
/* jpegmode indicates what's in the file. */
|
||||
/* If not valid, we'll trust the decoder. */
|
||||
if (context->jpegmode == IMAGING_RAWMODE_L) {
|
||||
context->cinfo.jpeg_color_space = JCS_GRAYSCALE;
|
||||
} 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;
|
||||
}
|
||||
|
||||
/* rawmode indicates what we want from the decoder. if not
|
||||
set, conversions are disabled */
|
||||
/* rawmode indicates what we want from the decoder. */
|
||||
/* If not valid, conversions are disabled. */
|
||||
if (context->rawmode == IMAGING_RAWMODE_L) {
|
||||
context->cinfo.out_color_space = JCS_GRAYSCALE;
|
||||
} 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) {
|
||||
context->cinfo.out_color_space = JCS_YCCK;
|
||||
} else {
|
||||
/* Disable decoder conversions */
|
||||
/* Disable decoder conversions. */
|
||||
context->cinfo.jpeg_color_space = JCS_UNKNOWN;
|
||||
context->cinfo.out_color_space = JCS_UNKNOWN;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
#define CLIPF(v) ((v <= 0.0) ? 0 : (v >= 255.0F) ? 255 : (UINT8)v)
|
||||
|
||||
Imaging
|
||||
ImagingConvertMatrix(Imaging im, const Mode *mode, float m[]) {
|
||||
ImagingConvertMatrix(Imaging im, const ModeID mode, float m[]) {
|
||||
Imaging imOut;
|
||||
int x, y;
|
||||
ImagingSectionCookie cookie;
|
||||
|
|
|
|||
|
|
@ -2,453 +2,258 @@
|
|||
#include <string.h>
|
||||
|
||||
|
||||
#define CREATE_MODE(TYPE, NAME, INIT) \
|
||||
const TYPE IMAGING_##NAME##_VAL = INIT;\
|
||||
const TYPE * const IMAGING_##NAME = &IMAGING_##NAME##_VAL;
|
||||
const ModeData MODES[] = {
|
||||
[IMAGING_MODE_UNKNOWN] = {""},
|
||||
|
||||
[IMAGING_MODE_1] = {"1"},
|
||||
[IMAGING_MODE_CMYK] = {"CMYK"},
|
||||
[IMAGING_MODE_F] = {"F"},
|
||||
[IMAGING_MODE_HSV] = {"HSV"},
|
||||
[IMAGING_MODE_I] = {"I"},
|
||||
[IMAGING_MODE_L] = {"L"},
|
||||
[IMAGING_MODE_LA] = {"LA"},
|
||||
[IMAGING_MODE_LAB] = {"LAB"},
|
||||
[IMAGING_MODE_La] = {"La"},
|
||||
[IMAGING_MODE_P] = {"P"},
|
||||
[IMAGING_MODE_PA] = {"PA"},
|
||||
[IMAGING_MODE_RGB] = {"RGB"},
|
||||
[IMAGING_MODE_RGBA] = {"RGBA"},
|
||||
[IMAGING_MODE_RGBX] = {"RGBX"},
|
||||
[IMAGING_MODE_RGBa] = {"RGBa"},
|
||||
[IMAGING_MODE_YCbCr] = {"YCbCr"},
|
||||
|
||||
CREATE_MODE(Mode, MODE_1, {"1"})
|
||||
CREATE_MODE(Mode, MODE_CMYK, {"CMYK"})
|
||||
CREATE_MODE(Mode, MODE_F, {"F"})
|
||||
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"})
|
||||
[IMAGING_MODE_BGR_15] = {"BGR;15"},
|
||||
[IMAGING_MODE_BGR_16] = {"BGR;16"},
|
||||
[IMAGING_MODE_BGR_24] = {"BGR;24"},
|
||||
|
||||
CREATE_MODE(Mode, MODE_BGR_15, {"BGR;15"})
|
||||
CREATE_MODE(Mode, MODE_BGR_16, {"BGR;16"})
|
||||
CREATE_MODE(Mode, MODE_BGR_24, {"BGR;24"})
|
||||
|
||||
CREATE_MODE(Mode, MODE_I_16, {"I;16"})
|
||||
CREATE_MODE(Mode, MODE_I_16L, {"I;16L"})
|
||||
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
|
||||
[IMAGING_MODE_I_16] = {"I;16"},
|
||||
[IMAGING_MODE_I_16L] = {"I;16L"},
|
||||
[IMAGING_MODE_I_16B] = {"I;16B"},
|
||||
[IMAGING_MODE_I_16N] = {"I;16N"},
|
||||
[IMAGING_MODE_I_32L] = {"I;32L"},
|
||||
[IMAGING_MODE_I_32B] = {"I;32B"},
|
||||
};
|
||||
|
||||
const Mode * findMode(const char * const name) {
|
||||
const ModeID findModeID(const char * const name) {
|
||||
if (name == NULL) {
|
||||
return NULL;
|
||||
return IMAGING_MODE_UNKNOWN;
|
||||
}
|
||||
const Mode * mode;
|
||||
for (int i = 0; (mode = MODES[i]); i++) {
|
||||
if (strcmp(mode->name, name) == 0) {
|
||||
return mode;
|
||||
for (size_t i = 0; i < sizeof(MODES) / sizeof(*MODES); i++) {
|
||||
if (strcmp(MODES[i].name, name) == 0) {
|
||||
return (ModeID)i;
|
||||
}
|
||||
}
|
||||
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.
|
||||
#define ALIAS_MODE_AS_RAWMODE(NAME) const RawMode * const IMAGING_RAWMODE_##NAME = (const RawMode * const)IMAGING_MODE_##NAME;
|
||||
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)
|
||||
const RawModeData RAWMODES[] = {
|
||||
[IMAGING_RAWMODE_UNKNOWN] = {""},
|
||||
|
||||
ALIAS_MODE_AS_RAWMODE(BGR_15)
|
||||
ALIAS_MODE_AS_RAWMODE(BGR_16)
|
||||
ALIAS_MODE_AS_RAWMODE(BGR_24)
|
||||
[IMAGING_RAWMODE_1] = {"1"},
|
||||
[IMAGING_RAWMODE_CMYK] = {"CMYK"},
|
||||
[IMAGING_RAWMODE_F] = {"F"},
|
||||
[IMAGING_RAWMODE_HSV] = {"HSV"},
|
||||
[IMAGING_RAWMODE_I] = {"I"},
|
||||
[IMAGING_RAWMODE_L] = {"L"},
|
||||
[IMAGING_RAWMODE_LA] = {"LA"},
|
||||
[IMAGING_RAWMODE_LAB] = {"LAB"},
|
||||
[IMAGING_RAWMODE_La] = {"La"},
|
||||
[IMAGING_RAWMODE_P] = {"P"},
|
||||
[IMAGING_RAWMODE_PA] = {"PA"},
|
||||
[IMAGING_RAWMODE_RGB] = {"RGB"},
|
||||
[IMAGING_RAWMODE_RGBA] = {"RGBA"},
|
||||
[IMAGING_RAWMODE_RGBX] = {"RGBX"},
|
||||
[IMAGING_RAWMODE_RGBa] = {"RGBa"},
|
||||
[IMAGING_RAWMODE_YCbCr] = {"YCbCr"},
|
||||
|
||||
ALIAS_MODE_AS_RAWMODE(I_16)
|
||||
ALIAS_MODE_AS_RAWMODE(I_16L)
|
||||
ALIAS_MODE_AS_RAWMODE(I_16B)
|
||||
ALIAS_MODE_AS_RAWMODE(I_16N)
|
||||
ALIAS_MODE_AS_RAWMODE(I_32L)
|
||||
ALIAS_MODE_AS_RAWMODE(I_32B)
|
||||
[IMAGING_RAWMODE_BGR_15] = {"BGR;15"},
|
||||
[IMAGING_RAWMODE_BGR_16] = {"BGR;16"},
|
||||
[IMAGING_RAWMODE_BGR_24] = {"BGR;24"},
|
||||
[IMAGING_RAWMODE_BGR_32] = {"BGR;32"},
|
||||
|
||||
CREATE_MODE(RawMode, RAWMODE_1_8, {"1;8"})
|
||||
CREATE_MODE(RawMode, RAWMODE_1_I, {"1;I"})
|
||||
CREATE_MODE(RawMode, RAWMODE_1_IR, {"1;IR"})
|
||||
CREATE_MODE(RawMode, RAWMODE_1_R, {"1;R"})
|
||||
CREATE_MODE(RawMode, RAWMODE_A, {"A"})
|
||||
CREATE_MODE(RawMode, RAWMODE_ABGR, {"ABGR"})
|
||||
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"})
|
||||
[IMAGING_RAWMODE_I_16] = {"I;16"},
|
||||
[IMAGING_RAWMODE_I_16L] = {"I;16L"},
|
||||
[IMAGING_RAWMODE_I_16B] = {"I;16B"},
|
||||
[IMAGING_RAWMODE_I_16N] = {"I;16N"},
|
||||
[IMAGING_RAWMODE_I_32L] = {"I;32L"},
|
||||
[IMAGING_RAWMODE_I_32B] = {"I;32B"},
|
||||
|
||||
const RawMode * const RAWMODES[] = {
|
||||
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,
|
||||
|
||||
IMAGING_RAWMODE_BGR_15,
|
||||
IMAGING_RAWMODE_BGR_16,
|
||||
IMAGING_RAWMODE_BGR_24,
|
||||
|
||||
IMAGING_RAWMODE_I_16,
|
||||
IMAGING_RAWMODE_I_16L,
|
||||
IMAGING_RAWMODE_I_16B,
|
||||
IMAGING_RAWMODE_I_16N,
|
||||
IMAGING_RAWMODE_I_32L,
|
||||
IMAGING_RAWMODE_I_32B,
|
||||
|
||||
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,
|
||||
|
||||
NULL
|
||||
[IMAGING_RAWMODE_1_8] = {"1;8"},
|
||||
[IMAGING_RAWMODE_1_I] = {"1;I"},
|
||||
[IMAGING_RAWMODE_1_IR] = {"1;IR"},
|
||||
[IMAGING_RAWMODE_1_R] = {"1;R"},
|
||||
[IMAGING_RAWMODE_A] = {"A"},
|
||||
[IMAGING_RAWMODE_ABGR] = {"ABGR"},
|
||||
[IMAGING_RAWMODE_ARGB] = {"ARGB"},
|
||||
[IMAGING_RAWMODE_A_16B] = {"A;16B"},
|
||||
[IMAGING_RAWMODE_A_16L] = {"A;16L"},
|
||||
[IMAGING_RAWMODE_A_16N] = {"A;16N"},
|
||||
[IMAGING_RAWMODE_B] = {"B"},
|
||||
[IMAGING_RAWMODE_BGAR] = {"BGAR"},
|
||||
[IMAGING_RAWMODE_BGR] = {"BGR"},
|
||||
[IMAGING_RAWMODE_BGRA] = {"BGRA"},
|
||||
[IMAGING_RAWMODE_BGRA_15] = {"BGRA;15"},
|
||||
[IMAGING_RAWMODE_BGRA_15Z] = {"BGRA;15Z"},
|
||||
[IMAGING_RAWMODE_BGRA_16B] = {"BGRA;16B"},
|
||||
[IMAGING_RAWMODE_BGRA_16L] = {"BGRA;16L"},
|
||||
[IMAGING_RAWMODE_BGRX] = {"BGRX"},
|
||||
[IMAGING_RAWMODE_BGR_5] = {"BGR;5"},
|
||||
[IMAGING_RAWMODE_BGRa] = {"BGRa"},
|
||||
[IMAGING_RAWMODE_BGXR] = {"BGXR"},
|
||||
[IMAGING_RAWMODE_B_16B] = {"B;16B"},
|
||||
[IMAGING_RAWMODE_B_16L] = {"B;16L"},
|
||||
[IMAGING_RAWMODE_B_16N] = {"B;16N"},
|
||||
[IMAGING_RAWMODE_C] = {"C"},
|
||||
[IMAGING_RAWMODE_CMYKX] = {"CMYKX"},
|
||||
[IMAGING_RAWMODE_CMYKXX] = {"CMYKXX"},
|
||||
[IMAGING_RAWMODE_CMYK_16B] = {"CMYK;16B"},
|
||||
[IMAGING_RAWMODE_CMYK_16L] = {"CMYK;16L"},
|
||||
[IMAGING_RAWMODE_CMYK_16N] = {"CMYK;16N"},
|
||||
[IMAGING_RAWMODE_CMYK_I] = {"CMYK;I"},
|
||||
[IMAGING_RAWMODE_CMYK_L] = {"CMYK;L"},
|
||||
[IMAGING_RAWMODE_C_I] = {"C;I"},
|
||||
[IMAGING_RAWMODE_Cb] = {"Cb"},
|
||||
[IMAGING_RAWMODE_Cr] = {"Cr"},
|
||||
[IMAGING_RAWMODE_F_16] = {"F;16"},
|
||||
[IMAGING_RAWMODE_F_16B] = {"F;16B"},
|
||||
[IMAGING_RAWMODE_F_16BS] = {"F;16BS"},
|
||||
[IMAGING_RAWMODE_F_16N] = {"F;16N"},
|
||||
[IMAGING_RAWMODE_F_16NS] = {"F;16NS"},
|
||||
[IMAGING_RAWMODE_F_16S] = {"F;16S"},
|
||||
[IMAGING_RAWMODE_F_32] = {"F;32"},
|
||||
[IMAGING_RAWMODE_F_32B] = {"F;32B"},
|
||||
[IMAGING_RAWMODE_F_32BF] = {"F;32BF"},
|
||||
[IMAGING_RAWMODE_F_32BS] = {"F;32BS"},
|
||||
[IMAGING_RAWMODE_F_32F] = {"F;32F"},
|
||||
[IMAGING_RAWMODE_F_32N] = {"F;32N"},
|
||||
[IMAGING_RAWMODE_F_32NF] = {"F;32NF"},
|
||||
[IMAGING_RAWMODE_F_32NS] = {"F;32NS"},
|
||||
[IMAGING_RAWMODE_F_32S] = {"F;32S"},
|
||||
[IMAGING_RAWMODE_F_64BF] = {"F;64BF"},
|
||||
[IMAGING_RAWMODE_F_64F] = {"F;64F"},
|
||||
[IMAGING_RAWMODE_F_64NF] = {"F;64NF"},
|
||||
[IMAGING_RAWMODE_F_8] = {"F;8"},
|
||||
[IMAGING_RAWMODE_F_8S] = {"F;8S"},
|
||||
[IMAGING_RAWMODE_G] = {"G"},
|
||||
[IMAGING_RAWMODE_G_16B] = {"G;16B"},
|
||||
[IMAGING_RAWMODE_G_16L] = {"G;16L"},
|
||||
[IMAGING_RAWMODE_G_16N] = {"G;16N"},
|
||||
[IMAGING_RAWMODE_H] = {"H"},
|
||||
[IMAGING_RAWMODE_I_12] = {"I;12"},
|
||||
[IMAGING_RAWMODE_I_16BS] = {"I;16BS"},
|
||||
[IMAGING_RAWMODE_I_16NS] = {"I;16NS"},
|
||||
[IMAGING_RAWMODE_I_16R] = {"I;16R"},
|
||||
[IMAGING_RAWMODE_I_16S] = {"I;16S"},
|
||||
[IMAGING_RAWMODE_I_32] = {"I;32"},
|
||||
[IMAGING_RAWMODE_I_32BS] = {"I;32BS"},
|
||||
[IMAGING_RAWMODE_I_32N] = {"I;32N"},
|
||||
[IMAGING_RAWMODE_I_32NS] = {"I;32NS"},
|
||||
[IMAGING_RAWMODE_I_32S] = {"I;32S"},
|
||||
[IMAGING_RAWMODE_I_8] = {"I;8"},
|
||||
[IMAGING_RAWMODE_I_8S] = {"I;8S"},
|
||||
[IMAGING_RAWMODE_K] = {"K"},
|
||||
[IMAGING_RAWMODE_K_I] = {"K;I"},
|
||||
[IMAGING_RAWMODE_LA_16B] = {"LA;16B"},
|
||||
[IMAGING_RAWMODE_LA_L] = {"LA;L"},
|
||||
[IMAGING_RAWMODE_L_16] = {"L;16"},
|
||||
[IMAGING_RAWMODE_L_16B] = {"L;16B"},
|
||||
[IMAGING_RAWMODE_L_2] = {"L;2"},
|
||||
[IMAGING_RAWMODE_L_2I] = {"L;2I"},
|
||||
[IMAGING_RAWMODE_L_2IR] = {"L;2IR"},
|
||||
[IMAGING_RAWMODE_L_2R] = {"L;2R"},
|
||||
[IMAGING_RAWMODE_L_4] = {"L;4"},
|
||||
[IMAGING_RAWMODE_L_4I] = {"L;4I"},
|
||||
[IMAGING_RAWMODE_L_4IR] = {"L;4IR"},
|
||||
[IMAGING_RAWMODE_L_4R] = {"L;4R"},
|
||||
[IMAGING_RAWMODE_L_I] = {"L;I"},
|
||||
[IMAGING_RAWMODE_L_R] = {"L;R"},
|
||||
[IMAGING_RAWMODE_M] = {"M"},
|
||||
[IMAGING_RAWMODE_M_I] = {"M;I"},
|
||||
[IMAGING_RAWMODE_PA_L] = {"PA;L"},
|
||||
[IMAGING_RAWMODE_PX] = {"PX"},
|
||||
[IMAGING_RAWMODE_P_1] = {"P;1"},
|
||||
[IMAGING_RAWMODE_P_2] = {"P;2"},
|
||||
[IMAGING_RAWMODE_P_2L] = {"P;2L"},
|
||||
[IMAGING_RAWMODE_P_4] = {"P;4"},
|
||||
[IMAGING_RAWMODE_P_4L] = {"P;4L"},
|
||||
[IMAGING_RAWMODE_P_R] = {"P;R"},
|
||||
[IMAGING_RAWMODE_R] = {"R"},
|
||||
[IMAGING_RAWMODE_RGBAX] = {"RGBAX"},
|
||||
[IMAGING_RAWMODE_RGBAXX] = {"RGBAXX"},
|
||||
[IMAGING_RAWMODE_RGBA_15] = {"RGBA;15"},
|
||||
[IMAGING_RAWMODE_RGBA_16B] = {"RGBA;16B"},
|
||||
[IMAGING_RAWMODE_RGBA_16L] = {"RGBA;16L"},
|
||||
[IMAGING_RAWMODE_RGBA_16N] = {"RGBA;16N"},
|
||||
[IMAGING_RAWMODE_RGBA_4B] = {"RGBA;4B"},
|
||||
[IMAGING_RAWMODE_RGBA_I] = {"RGBA;I"},
|
||||
[IMAGING_RAWMODE_RGBA_L] = {"RGBA;L"},
|
||||
[IMAGING_RAWMODE_RGBXX] = {"RGBXX"},
|
||||
[IMAGING_RAWMODE_RGBXXX] = {"RGBXXX"},
|
||||
[IMAGING_RAWMODE_RGBX_16B] = {"RGBX;16B"},
|
||||
[IMAGING_RAWMODE_RGBX_16L] = {"RGBX;16L"},
|
||||
[IMAGING_RAWMODE_RGBX_16N] = {"RGBX;16N"},
|
||||
[IMAGING_RAWMODE_RGBX_L] = {"RGBX;L"},
|
||||
[IMAGING_RAWMODE_RGB_15] = {"RGB;15"},
|
||||
[IMAGING_RAWMODE_RGB_16] = {"RGB;16"},
|
||||
[IMAGING_RAWMODE_RGB_16B] = {"RGB;16B"},
|
||||
[IMAGING_RAWMODE_RGB_16L] = {"RGB;16L"},
|
||||
[IMAGING_RAWMODE_RGB_16N] = {"RGB;16N"},
|
||||
[IMAGING_RAWMODE_RGB_4B] = {"RGB;4B"},
|
||||
[IMAGING_RAWMODE_RGB_L] = {"RGB;L"},
|
||||
[IMAGING_RAWMODE_RGB_R] = {"RGB;R"},
|
||||
[IMAGING_RAWMODE_RGBaX] = {"RGBaX"},
|
||||
[IMAGING_RAWMODE_RGBaXX] = {"RGBaXX"},
|
||||
[IMAGING_RAWMODE_RGBa_16B] = {"RGBa;16B"},
|
||||
[IMAGING_RAWMODE_RGBa_16L] = {"RGBa;16L"},
|
||||
[IMAGING_RAWMODE_RGBa_16N] = {"RGBa;16N"},
|
||||
[IMAGING_RAWMODE_R_16B] = {"R;16B"},
|
||||
[IMAGING_RAWMODE_R_16L] = {"R;16L"},
|
||||
[IMAGING_RAWMODE_R_16N] = {"R;16N"},
|
||||
[IMAGING_RAWMODE_S] = {"S"},
|
||||
[IMAGING_RAWMODE_V] = {"V"},
|
||||
[IMAGING_RAWMODE_X] = {"X"},
|
||||
[IMAGING_RAWMODE_XBGR] = {"XBGR"},
|
||||
[IMAGING_RAWMODE_XRGB] = {"XRGB"},
|
||||
[IMAGING_RAWMODE_Y] = {"Y"},
|
||||
[IMAGING_RAWMODE_YCCA_P] = {"YCCA;P"},
|
||||
[IMAGING_RAWMODE_YCC_P] = {"YCC;P"},
|
||||
[IMAGING_RAWMODE_YCbCrK] = {"YCbCrK"},
|
||||
[IMAGING_RAWMODE_YCbCrX] = {"YCbCrX"},
|
||||
[IMAGING_RAWMODE_YCbCr_L] = {"YCbCr;L"},
|
||||
[IMAGING_RAWMODE_Y_I] = {"Y;I"},
|
||||
[IMAGING_RAWMODE_aBGR] = {"aBGR"},
|
||||
[IMAGING_RAWMODE_aRGB] = {"aRGB"},
|
||||
};
|
||||
|
||||
const RawMode * findRawMode(const char * const name) {
|
||||
const RawModeID findRawModeID(const char * const name) {
|
||||
if (name == NULL) {
|
||||
return NULL;
|
||||
return IMAGING_RAWMODE_UNKNOWN;
|
||||
}
|
||||
const RawMode * rawmode;
|
||||
for (int i = 0; (rawmode = RAWMODES[i]); i++) {
|
||||
if (strcmp(rawmode->name, name) == 0) {
|
||||
return rawmode;
|
||||
for (size_t i = 0; i < sizeof(RAWMODES) / sizeof(*RAWMODES); i++) {
|
||||
if (strcmp(RAWMODES[i].name, name) == 0) {
|
||||
return (RawModeID)i;
|
||||
}
|
||||
}
|
||||
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
|
||||
|| mode == IMAGING_MODE_I_16L
|
||||
|| mode == IMAGING_MODE_I_16B
|
||||
|
|
|
|||
|
|
@ -2,227 +2,237 @@
|
|||
#define __MODE_H__
|
||||
|
||||
|
||||
typedef struct {
|
||||
const char * const name;
|
||||
} Mode;
|
||||
typedef enum {
|
||||
IMAGING_MODE_UNKNOWN,
|
||||
|
||||
extern const Mode * const IMAGING_MODE_1;
|
||||
extern const Mode * const IMAGING_MODE_CMYK;
|
||||
extern const Mode * const IMAGING_MODE_F;
|
||||
extern const Mode * const IMAGING_MODE_HSV;
|
||||
extern const Mode * const IMAGING_MODE_I;
|
||||
extern const Mode * const IMAGING_MODE_L;
|
||||
extern const Mode * const IMAGING_MODE_LA;
|
||||
extern const Mode * const IMAGING_MODE_LAB;
|
||||
extern const Mode * const IMAGING_MODE_La;
|
||||
extern const Mode * const IMAGING_MODE_P;
|
||||
extern const Mode * const IMAGING_MODE_PA;
|
||||
extern const Mode * const IMAGING_MODE_RGB;
|
||||
extern const Mode * const IMAGING_MODE_RGBA;
|
||||
extern const Mode * const IMAGING_MODE_RGBX;
|
||||
extern const Mode * const IMAGING_MODE_RGBa;
|
||||
extern const Mode * const IMAGING_MODE_YCbCr;
|
||||
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,
|
||||
|
||||
extern const Mode * const IMAGING_MODE_BGR_15;
|
||||
extern const Mode * const IMAGING_MODE_BGR_16;
|
||||
extern const Mode * const 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_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,
|
||||
} ModeID;
|
||||
|
||||
typedef struct {
|
||||
const char * const name;
|
||||
} RawMode;
|
||||
} ModeData;
|
||||
|
||||
const ModeID findModeID(const char * const name);
|
||||
const ModeData * const getModeData(const ModeID id);
|
||||
|
||||
|
||||
typedef enum {
|
||||
IMAGING_RAWMODE_UNKNOWN,
|
||||
|
||||
// Non-rawmode aliases.
|
||||
extern const RawMode * const IMAGING_RAWMODE_1;
|
||||
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;
|
||||
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.
|
||||
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;
|
||||
IMAGING_RAWMODE_BGR_15,
|
||||
IMAGING_RAWMODE_BGR_16,
|
||||
IMAGING_RAWMODE_BGR_24,
|
||||
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;
|
||||
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
|
||||
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;
|
||||
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;
|
||||
|
||||
const RawMode * findRawMode(const char * const name);
|
||||
typedef struct {
|
||||
const char * const name;
|
||||
} RawModeData;
|
||||
|
||||
const RawModeID findRawModeID(const char * const name);
|
||||
const RawModeData * const getRawModeData(const RawModeID id);
|
||||
|
||||
|
||||
int isModeI16(const Mode * const mode);
|
||||
int isModeI16(const ModeID mode);
|
||||
|
||||
#endif // __MODE_H__
|
||||
|
|
|
|||
|
|
@ -524,30 +524,12 @@ band3(UINT8 *out, const UINT8 *in, int pixels) {
|
|||
}
|
||||
}
|
||||
|
||||
static struct Packer {
|
||||
const Mode *mode;
|
||||
const RawMode *rawmode;
|
||||
static struct {
|
||||
const ModeID mode;
|
||||
const RawModeID rawmode;
|
||||
int bits;
|
||||
ImagingShuffler pack;
|
||||
} *packers = NULL;
|
||||
|
||||
ImagingShuffler
|
||||
ImagingFindPacker(const Mode *mode, const RawMode *rawmode, int *bits_out) {
|
||||
int i;
|
||||
for (i = 0; packers[i].mode; i++) {
|
||||
if (packers[i].mode == mode && packers[i].rawmode == rawmode) {
|
||||
if (bits_out) {
|
||||
*bits_out = packers[i].bits;
|
||||
}
|
||||
return packers[i].pack;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
ImagingPackInit(void) {
|
||||
const struct Packer temp[] = {
|
||||
} packers[] = {
|
||||
/* bilevel */
|
||||
{IMAGING_MODE_1, IMAGING_RAWMODE_1, 1, pack1},
|
||||
{IMAGING_MODE_1, IMAGING_RAWMODE_1_I, 1, pack1I},
|
||||
|
|
@ -676,20 +658,18 @@ ImagingPackInit(void) {
|
|||
{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 */
|
||||
{IMAGING_MODE_BGR_24, IMAGING_RAWMODE_BGR_24, 24, copy3}
|
||||
};
|
||||
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;
|
||||
ImagingShuffler
|
||||
ImagingFindPacker(const ModeID mode, const RawModeID rawmode, int *bits_out) {
|
||||
for (size_t i = 0; i < sizeof(packers) / sizeof(*packers); i++) {
|
||||
if (packers[i].mode == mode && packers[i].rawmode == rawmode) {
|
||||
if (bits_out) {
|
||||
*bits_out = packers[i].bits;
|
||||
}
|
||||
return packers[i].pack;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
#include <math.h>
|
||||
|
||||
ImagingPalette
|
||||
ImagingPaletteNew(const Mode *mode) {
|
||||
ImagingPaletteNew(const ModeID mode) {
|
||||
/* Create a palette object */
|
||||
|
||||
int i;
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ im_point_32_8(Imaging imOut, Imaging imIn, im_point_context *context) {
|
|||
}
|
||||
|
||||
Imaging
|
||||
ImagingPoint(Imaging imIn, const Mode *mode, const void *table) {
|
||||
ImagingPoint(Imaging imIn, ModeID mode, const void *table) {
|
||||
/* lookup table transform */
|
||||
|
||||
ImagingSectionCookie cookie;
|
||||
|
|
@ -140,7 +140,7 @@ ImagingPoint(Imaging imIn, const Mode *mode, const void *table) {
|
|||
return (Imaging)ImagingError_ModeError();
|
||||
}
|
||||
|
||||
if (!mode) {
|
||||
if (mode == IMAGING_MODE_UNKNOWN) {
|
||||
mode = imIn->mode;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@
|
|||
*/
|
||||
|
||||
Imaging
|
||||
ImagingNewPrologueSubtype(const Mode *mode, int xsize, int ysize, int size) {
|
||||
ImagingNewPrologueSubtype(const ModeID mode, int xsize, int ysize, int size) {
|
||||
Imaging im;
|
||||
|
||||
/* 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
|
||||
ImagingNewPrologue(const Mode *mode, int xsize, int ysize) {
|
||||
ImagingNewPrologue(const ModeID mode, int xsize, int ysize) {
|
||||
return ImagingNewPrologueSubtype(
|
||||
mode, xsize, ysize, sizeof(struct ImagingMemoryInstance)
|
||||
);
|
||||
|
|
@ -491,7 +491,7 @@ ImagingAllocateBlock(Imaging im) {
|
|||
*/
|
||||
|
||||
Imaging
|
||||
ImagingNewInternal(const Mode *mode, int xsize, int ysize, int dirty) {
|
||||
ImagingNewInternal(const ModeID mode, int xsize, int ysize, int dirty) {
|
||||
Imaging im;
|
||||
|
||||
if (xsize < 0 || ysize < 0) {
|
||||
|
|
@ -527,17 +527,17 @@ ImagingNewInternal(const Mode *mode, int xsize, int ysize, int dirty) {
|
|||
}
|
||||
|
||||
Imaging
|
||||
ImagingNew(const Mode *mode, int xsize, int ysize) {
|
||||
ImagingNew(const ModeID mode, int xsize, int ysize) {
|
||||
return ImagingNewInternal(mode, xsize, ysize, 0);
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingNewDirty(const Mode *mode, int xsize, int ysize) {
|
||||
ImagingNewDirty(const ModeID mode, int xsize, int ysize) {
|
||||
return ImagingNewInternal(mode, xsize, ysize, 1);
|
||||
}
|
||||
|
||||
Imaging
|
||||
ImagingNewBlock(const Mode *mode, int xsize, int ysize) {
|
||||
ImagingNewBlock(const ModeID mode, int xsize, int ysize) {
|
||||
Imaging im;
|
||||
|
||||
if (xsize < 0 || ysize < 0) {
|
||||
|
|
@ -558,7 +558,7 @@ ImagingNewBlock(const Mode *mode, int xsize, int ysize) {
|
|||
}
|
||||
|
||||
Imaging
|
||||
ImagingNew2Dirty(const Mode *mode, Imaging imOut, Imaging imIn) {
|
||||
ImagingNew2Dirty(const ModeID mode, Imaging imOut, Imaging imIn) {
|
||||
/* allocate or validate output image */
|
||||
|
||||
if (imOut) {
|
||||
|
|
|
|||
|
|
@ -638,7 +638,7 @@ ImagingLibTiffDecode(
|
|||
);
|
||||
TRACE(
|
||||
("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
|
||||
im->mode->name,
|
||||
getModeData(im->mode)->name,
|
||||
im->type,
|
||||
im->bands,
|
||||
im->xsize,
|
||||
|
|
@ -972,7 +972,7 @@ ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int byt
|
|||
);
|
||||
TRACE(
|
||||
("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
|
||||
im->mode->name,
|
||||
getModeData(im->mode)->name,
|
||||
im->type,
|
||||
im->bands,
|
||||
im->xsize,
|
||||
|
|
|
|||
|
|
@ -1547,35 +1547,12 @@ band316L(UINT8 *out, const UINT8 *in, int pixels) {
|
|||
}
|
||||
}
|
||||
|
||||
static struct Unpacker {
|
||||
const Mode *mode;
|
||||
const RawMode *rawmode;
|
||||
static struct {
|
||||
const ModeID mode;
|
||||
const RawModeID rawmode;
|
||||
int bits;
|
||||
ImagingShuffler unpack;
|
||||
} *unpackers = NULL;
|
||||
|
||||
ImagingShuffler
|
||||
ImagingFindUnpacker(const Mode *mode, const RawMode *rawmode, int *bits_out) {
|
||||
int i;
|
||||
|
||||
/* find a suitable pixel unpacker */
|
||||
for (i = 0; unpackers[i].rawmode; i++) {
|
||||
if (unpackers[i].mode == mode && unpackers[i].rawmode == rawmode) {
|
||||
if (bits_out) {
|
||||
*bits_out = unpackers[i].bits;
|
||||
}
|
||||
return unpackers[i].unpack;
|
||||
}
|
||||
}
|
||||
|
||||
/* FIXME: configure a general unpacker based on the type codes... */
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
ImagingUnpackInit(void) {
|
||||
const struct Unpacker temp[] = {
|
||||
} 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
|
||||
|
|
@ -1869,20 +1846,21 @@ ImagingUnpackInit(void) {
|
|||
|
||||
{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 */
|
||||
{IMAGING_MODE_I_16, IMAGING_RAWMODE_I_12, 12, unpackI12_I16} // 12 bit Tiffs stored in 16bits.
|
||||
};
|
||||
unpackers = malloc(sizeof(temp));
|
||||
if (unpackers == NULL) {
|
||||
fprintf(stderr, "UnpackInit: failed to allocate memory for unpackers table\n");
|
||||
exit(1);
|
||||
|
||||
ImagingShuffler
|
||||
ImagingFindUnpacker(const ModeID mode, const RawModeID rawmode, int *bits_out) {
|
||||
for (size_t i = 0; i < sizeof(unpackers) / sizeof(*unpackers); i++) {
|
||||
if (unpackers[i].mode == mode && unpackers[i].rawmode == rawmode) {
|
||||
if (bits_out) {
|
||||
*bits_out = unpackers[i].bits;
|
||||
}
|
||||
return unpackers[i].unpack;
|
||||
}
|
||||
memcpy(unpackers, temp, sizeof(temp));
|
||||
}
|
||||
|
||||
void
|
||||
ImagingUnpackFree(void) {
|
||||
free(unpackers);
|
||||
unpackers = NULL;
|
||||
/* FIXME: configure a general unpacker based on the type codes... */
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user