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

Format with ClangFormat

Browse Source
This commit is contained in:
Andrew Murray 2021-01-03 14:17:51 +11:00
parent e2d00f8cf8
commit 46b7e86bab
101 changed files with 14097 additions and 13889 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/Tk/_tkmini.h
View File

@ -79,14 +79,16 @@ typedef struct Tcl_Interp Tcl_Interp;
typedef struct Tcl_Command_ *Tcl_Command;
typedef void *ClientData;
typedef int (Tcl_CmdProc) (ClientData clientData, Tcl_Interp
*interp, int argc, const char *argv[]);
typedef int(Tcl_CmdProc)(
ClientData clientData, Tcl_Interp *interp, int argc, const char *argv[]);
typedef void(Tcl_CmdDeleteProc)(ClientData clientData);
/* Typedefs derived from function signatures in Tcl header */
/* Tcl_CreateCommand */
typedef Tcl_Command (*Tcl_CreateCommand_t)(Tcl_Interp *interp,
const char *cmdName, Tcl_CmdProc *proc,
typedef Tcl_Command (*Tcl_CreateCommand_t)(
Tcl_Interp *interp,
const char *cmdName,
Tcl_CmdProc *proc,
ClientData clientData,
Tcl_CmdDeleteProc *deleteProc);
/* Tcl_AppendResult */
@ -107,8 +109,7 @@ typedef struct Tk_Window_ *Tk_Window;
typedef void *Tk_PhotoHandle;
typedef struct Tk_PhotoImageBlock
{
typedef struct Tk_PhotoImageBlock {
unsigned char *pixelPtr;
int width;
int height;
@ -119,23 +120,30 @@ typedef struct Tk_PhotoImageBlock
/* Typedefs derived from function signatures in Tk header */
/* Tk_PhotoPutBlock for Tk <= 8.4 */
typedef void (*Tk_PhotoPutBlock_84_t) (Tk_PhotoHandle handle,
Tk_PhotoImageBlock *blockPtr, int x, int y,
int width, int height, int compRule);
/* Tk_PhotoPutBlock for Tk >= 8.5 */
typedef int (*Tk_PhotoPutBlock_85_t) (Tcl_Interp * interp,
typedef void (*Tk_PhotoPutBlock_84_t)(
Tk_PhotoHandle handle,
Tk_PhotoImageBlock * blockPtr, int x, int y,
int width, int height, int compRule);
Tk_PhotoImageBlock *blockPtr,
int x,
int y,
int width,
int height,
int compRule);
/* Tk_PhotoPutBlock for Tk >= 8.5 */
typedef int (*Tk_PhotoPutBlock_85_t)(
Tcl_Interp *interp,
Tk_PhotoHandle handle,
Tk_PhotoImageBlock *blockPtr,
int x,
int y,
int width,
int height,
int compRule);
/* Tk_PhotoSetSize for Tk <= 8.4 */
typedef void (*Tk_PhotoSetSize_84_t) (Tk_PhotoHandle handle,
int width, int height);
typedef void (*Tk_PhotoSetSize_84_t)(Tk_PhotoHandle handle, int width, int height);
/* Tk_FindPhoto */
typedef Tk_PhotoHandle (*Tk_FindPhoto_t) (Tcl_Interp *interp,
const char *imageName);
typedef Tk_PhotoHandle (*Tk_FindPhoto_t)(Tcl_Interp *interp, const char *imageName);
/* Tk_PhotoGetImage */
typedef int (*Tk_PhotoGetImage_t) (Tk_PhotoHandle handle,
Tk_PhotoImageBlock * blockPtr);
typedef int (*Tk_PhotoGetImage_t)(Tk_PhotoHandle handle, Tk_PhotoImageBlock *blockPtr);
/*
* end block for C++

164
src/Tk/tkImaging.c
View File

@ -58,8 +58,7 @@ static Tk_PhotoSetSize_84_t TK_PHOTO_SET_SIZE_84;
static Tk_PhotoPutBlock_85_t TK_PHOTO_PUT_BLOCK_85;
static Imaging
ImagingFind(const char* name)
{
ImagingFind(const char *name) {
Py_ssize_t id;
/* FIXME: use CObject instead? */
@ -75,27 +74,23 @@ ImagingFind(const char* name)
return (Imaging)id;
}
static int
PyImagingPhotoPut(ClientData clientdata, Tcl_Interp* interp,
int argc, const char **argv)
{
PyImagingPhotoPut(
ClientData clientdata, Tcl_Interp *interp, int argc, const char **argv) {
Imaging im;
Tk_PhotoHandle photo;
Tk_PhotoImageBlock block;
if (argc != 3) {
TCL_APPEND_RESULT(interp, "usage: ", argv[0],
" destPhoto srcImage", (char *) NULL);
TCL_APPEND_RESULT(
interp, "usage: ", argv[0], " destPhoto srcImage", (char *)NULL);
return TCL_ERROR;
}
/* get Tcl PhotoImage handle */
photo = TK_FIND_PHOTO(interp, argv[1]);
if (photo == NULL) {
TCL_APPEND_RESULT(
interp, "destination photo must exist", (char *) NULL
);
TCL_APPEND_RESULT(interp, "destination photo must exist", (char *)NULL);
return TCL_ERROR;
}
@ -136,8 +131,8 @@ PyImagingPhotoPut(ClientData clientdata, Tcl_Interp* interp,
block.pixelPtr = (unsigned char *)im->block;
if (TK_LT_85) { /* Tk 8.4 */
TK_PHOTO_PUT_BLOCK_84(photo, &block, 0, 0, block.width, block.height,
TK_PHOTO_COMPOSITE_SET);
TK_PHOTO_PUT_BLOCK_84(
photo, &block, 0, 0, block.width, block.height, TK_PHOTO_COMPOSITE_SET);
if (strcmp(im->mode, "RGBA") == 0) {
/* Tk workaround: we need apply ToggleComplexAlphaIfNeeded */
/* (fixed in Tk 8.5a3) */
@ -145,34 +140,38 @@ PyImagingPhotoPut(ClientData clientdata, Tcl_Interp* interp,
}
} else {
/* Tk >=8.5 */
TK_PHOTO_PUT_BLOCK_85(interp, photo, &block, 0, 0, block.width,
block.height, TK_PHOTO_COMPOSITE_SET);
TK_PHOTO_PUT_BLOCK_85(
interp,
photo,
&block,
0,
0,
block.width,
block.height,
TK_PHOTO_COMPOSITE_SET);
}
return TCL_OK;
}
static int
PyImagingPhotoGet(ClientData clientdata, Tcl_Interp* interp,
int argc, const char **argv)
{
PyImagingPhotoGet(
ClientData clientdata, Tcl_Interp *interp, int argc, const char **argv) {
Imaging im;
Tk_PhotoHandle photo;
Tk_PhotoImageBlock block;
int x, y, z;
if (argc != 3) {
TCL_APPEND_RESULT(interp, "usage: ", argv[0],
" srcPhoto destImage", (char *) NULL);
TCL_APPEND_RESULT(
interp, "usage: ", argv[0], " srcPhoto destImage", (char *)NULL);
return TCL_ERROR;
}
/* get Tcl PhotoImage handle */
photo = TK_FIND_PHOTO(interp, argv[1]);
if (photo == NULL) {
TCL_APPEND_RESULT(
interp, "source photo must exist", (char *) NULL
);
TCL_APPEND_RESULT(interp, "source photo must exist", (char *)NULL);
return TCL_ERROR;
}
@ -198,14 +197,20 @@ PyImagingPhotoGet(ClientData clientdata, Tcl_Interp* interp,
return TCL_OK;
}
void
TkImaging_Init(Tcl_Interp* interp)
{
TCL_CREATE_COMMAND(interp, "PyImagingPhoto", PyImagingPhotoPut,
(ClientData) 0, (Tcl_CmdDeleteProc*) NULL);
TCL_CREATE_COMMAND(interp, "PyImagingPhotoGet", PyImagingPhotoGet,
(ClientData) 0, (Tcl_CmdDeleteProc*) NULL);
TkImaging_Init(Tcl_Interp *interp) {
TCL_CREATE_COMMAND(
interp,
"PyImagingPhoto",
PyImagingPhotoPut,
(ClientData)0,
(Tcl_CmdDeleteProc *)NULL);
TCL_CREATE_COMMAND(
interp,
"PyImagingPhotoGet",
PyImagingPhotoGet,
(ClientData)0,
(Tcl_CmdDeleteProc *)NULL);
}
/*
@ -230,8 +235,8 @@ TkImaging_Init(Tcl_Interp* interp)
#define TKINTER_PKG "tkinter"
FARPROC _dfunc(HMODULE lib_handle, const char *func_name)
{
FARPROC
_dfunc(HMODULE lib_handle, const char *func_name) {
/*
* Load function `func_name` from `lib_handle`.
* Set Python exception if we can't find `func_name` in `lib_handle`.
@ -248,24 +253,26 @@ FARPROC _dfunc(HMODULE lib_handle, const char *func_name)
return func;
}
int get_tcl(HMODULE hMod)
{
int
get_tcl(HMODULE hMod) {
/*
* Try to fill Tcl global vars with function pointers. Return 0 for no
* functions found, 1 for all functions found, -1 for some but not all
* functions found.
*/
if ((TCL_CREATE_COMMAND = (Tcl_CreateCommand_t)
GetProcAddress(hMod, "Tcl_CreateCommand")) == NULL) {
if ((TCL_CREATE_COMMAND =
(Tcl_CreateCommand_t)GetProcAddress(hMod, "Tcl_CreateCommand")) == NULL) {
return 0; /* Maybe not Tcl module */
}
return ((TCL_APPEND_RESULT = (Tcl_AppendResult_t) _dfunc(hMod,
"Tcl_AppendResult")) == NULL) ? -1 : 1;
return ((TCL_APPEND_RESULT =
(Tcl_AppendResult_t)_dfunc(hMod, "Tcl_AppendResult")) == NULL)
? -1
: 1;
}
int get_tk(HMODULE hMod)
{
int
get_tk(HMODULE hMod) {
/*
* Try to fill Tk global vars with function pointers. Return 0 for no
* functions found, 1 for all functions found, -1 for some but not all
@ -276,23 +283,28 @@ int get_tk(HMODULE hMod)
if (func == NULL) { /* Maybe not Tk module */
return 0;
}
if ((TK_PHOTO_GET_IMAGE = (Tk_PhotoGetImage_t)
_dfunc(hMod, "Tk_PhotoGetImage")) == NULL) { return -1; };
if ((TK_FIND_PHOTO = (Tk_FindPhoto_t)
_dfunc(hMod, "Tk_FindPhoto")) == NULL) { return -1; };
if ((TK_PHOTO_GET_IMAGE = (Tk_PhotoGetImage_t)_dfunc(hMod, "Tk_PhotoGetImage")) ==
NULL) {
return -1;
};
if ((TK_FIND_PHOTO = (Tk_FindPhoto_t)_dfunc(hMod, "Tk_FindPhoto")) == NULL) {
return -1;
};
TK_LT_85 = GetProcAddress(hMod, "Tk_PhotoPutBlock_Panic") == NULL;
/* Tk_PhotoPutBlock_Panic defined as of 8.5.0 */
if (TK_LT_85) {
TK_PHOTO_PUT_BLOCK_84 = (Tk_PhotoPutBlock_84_t)func;
return ((TK_PHOTO_SET_SIZE_84 = (Tk_PhotoSetSize_84_t)
_dfunc(hMod, "Tk_PhotoSetSize")) == NULL) ? -1 : 1;
return ((TK_PHOTO_SET_SIZE_84 =
(Tk_PhotoSetSize_84_t)_dfunc(hMod, "Tk_PhotoSetSize")) == NULL)
? -1
: 1;
}
TK_PHOTO_PUT_BLOCK_85 = (Tk_PhotoPutBlock_85_t)func;
return 1;
}
int load_tkinter_funcs(void)
{
int
load_tkinter_funcs(void) {
/*
* Load Tcl and Tk functions by searching all modules in current process.
* Return 0 for success, non-zero for failure.
@ -353,8 +365,8 @@ int load_tkinter_funcs(void)
*/
/* From module __file__ attribute to char *string for dlopen. */
char *fname2char(PyObject *fname)
{
char *
fname2char(PyObject *fname) {
PyObject *bytes;
bytes = PyUnicode_EncodeFSDefault(fname);
if (bytes == NULL) {
@ -365,8 +377,8 @@ char *fname2char(PyObject *fname)
#include <dlfcn.h>
void *_dfunc(void *lib_handle, const char *func_name)
{
void *
_dfunc(void *lib_handle, const char *func_name) {
/*
* Load function `func_name` from `lib_handle`.
* Set Python exception if we can't find `func_name` in `lib_handle`.
@ -384,35 +396,44 @@ void *_dfunc(void *lib_handle, const char *func_name)
return func;
}
int _func_loader(void *lib)
{
int
_func_loader(void *lib) {
/*
* Fill global function pointers from dynamic lib.
* Return 1 if any pointer is NULL, 0 otherwise.
*/
if ((TCL_CREATE_COMMAND = (Tcl_CreateCommand_t)
_dfunc(lib, "Tcl_CreateCommand")) == NULL) { return 1; }
if ((TCL_APPEND_RESULT = (Tcl_AppendResult_t) _dfunc(lib,
"Tcl_AppendResult")) == NULL) { return 1; }
if ((TK_PHOTO_GET_IMAGE = (Tk_PhotoGetImage_t)
_dfunc(lib, "Tk_PhotoGetImage")) == NULL) { return 1; }
if ((TK_FIND_PHOTO = (Tk_FindPhoto_t)
_dfunc(lib, "Tk_FindPhoto")) == NULL) { return 1; }
if ((TCL_CREATE_COMMAND = (Tcl_CreateCommand_t)_dfunc(lib, "Tcl_CreateCommand")) ==
NULL) {
return 1;
}
if ((TCL_APPEND_RESULT = (Tcl_AppendResult_t)_dfunc(lib, "Tcl_AppendResult")) ==
NULL) {
return 1;
}
if ((TK_PHOTO_GET_IMAGE = (Tk_PhotoGetImage_t)_dfunc(lib, "Tk_PhotoGetImage")) ==
NULL) {
return 1;
}
if ((TK_FIND_PHOTO = (Tk_FindPhoto_t)_dfunc(lib, "Tk_FindPhoto")) == NULL) {
return 1;
}
/* Tk_PhotoPutBlock_Panic defined as of 8.5.0 */
TK_LT_85 = (dlsym(lib, "Tk_PhotoPutBlock_Panic") == NULL);
if (TK_LT_85) {
return (((TK_PHOTO_PUT_BLOCK_84 = (Tk_PhotoPutBlock_84_t)
_dfunc(lib, "Tk_PhotoPutBlock")) == NULL) ||
((TK_PHOTO_SET_SIZE_84 = (Tk_PhotoSetSize_84_t)
_dfunc(lib, "Tk_PhotoSetSize")) == NULL));
return (
((TK_PHOTO_PUT_BLOCK_84 =
(Tk_PhotoPutBlock_84_t)_dfunc(lib, "Tk_PhotoPutBlock")) == NULL) ||
((TK_PHOTO_SET_SIZE_84 =
(Tk_PhotoSetSize_84_t)_dfunc(lib, "Tk_PhotoSetSize")) == NULL));
}
return ((TK_PHOTO_PUT_BLOCK_85 = (Tk_PhotoPutBlock_85_t)
_dfunc(lib, "Tk_PhotoPutBlock")) == NULL);
return (
(TK_PHOTO_PUT_BLOCK_85 =
(Tk_PhotoPutBlock_85_t)_dfunc(lib, "Tk_PhotoPutBlock")) == NULL);
}
int load_tkinter_funcs(void)
{
int
load_tkinter_funcs(void) {
/*
* Load tkinter global funcs from tkinter compiled module.
* Return 0 for success, non-zero for failure.
@ -447,8 +468,7 @@ int load_tkinter_funcs(void)
}
tkinter_lib = dlopen(tkinter_libname, RTLD_LAZY);
if (tkinter_lib == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"Cannot dlopen tkinter module file");
PyErr_SetString(PyExc_RuntimeError, "Cannot dlopen tkinter module file");
goto exit;
}
ret = _func_loader(tkinter_lib);

1525
src/_imaging.c
View File

File diff suppressed because it is too large Load Diff

549
src/_imagingcms.c
View File

File diff suppressed because it is too large Load Diff

381
src/_imagingft.c
View File

@ -51,15 +51,17 @@
#define FT_ERRORDEF(e, v, s) {e, s},
#define FT_ERROR_START_LIST {
#define FT_ERROR_END_LIST { 0, 0 } };
#define FT_ERROR_END_LIST \
{ 0, 0 } \
} \
;
#include "libImaging/raqm.h"
#define LAYOUT_FALLBACK 0
#define LAYOUT_RAQM 1
typedef struct
{
typedef struct {
int index, x_offset, x_advance, y_offset, y_advance;
unsigned int cluster;
} GlyphInfo;
@ -77,8 +79,7 @@ struct {
static FT_Library library;
typedef struct {
PyObject_HEAD
FT_Face face;
PyObject_HEAD FT_Face face;
unsigned char *font_bytes;
int layout_engine;
} FontObject;
@ -86,32 +87,19 @@ typedef struct {
static PyTypeObject Font_Type;
typedef const char *(*t_raqm_version_string)(void);
typedef bool (*t_raqm_version_atleast)(unsigned int major,
unsigned int minor,
unsigned int micro);
typedef bool (*t_raqm_version_atleast)(
unsigned int major, unsigned int minor, unsigned int micro);
typedef raqm_t *(*t_raqm_create)(void);
typedef int (*t_raqm_set_text)(raqm_t *rq,
const uint32_t *text,
size_t len);
typedef bool (*t_raqm_set_text_utf8) (raqm_t *rq,
const char *text,
size_t len);
typedef bool (*t_raqm_set_par_direction) (raqm_t *rq,
raqm_direction_t dir);
typedef bool (*t_raqm_set_language) (raqm_t *rq,
const char *lang,
size_t start,
size_t len);
typedef bool (*t_raqm_add_font_feature) (raqm_t *rq,
const char *feature,
int len);
typedef bool (*t_raqm_set_freetype_face) (raqm_t *rq,
FT_Face face);
typedef int (*t_raqm_set_text)(raqm_t *rq, const uint32_t *text, size_t len);
typedef bool (*t_raqm_set_text_utf8)(raqm_t *rq, const char *text, size_t len);
typedef bool (*t_raqm_set_par_direction)(raqm_t *rq, raqm_direction_t dir);
typedef bool (*t_raqm_set_language)(
raqm_t *rq, const char *lang, size_t start, size_t len);
typedef bool (*t_raqm_add_font_feature)(raqm_t *rq, const char *feature, int len);
typedef bool (*t_raqm_set_freetype_face)(raqm_t *rq, FT_Face face);
typedef bool (*t_raqm_layout)(raqm_t *rq);
typedef raqm_glyph_t* (*t_raqm_get_glyphs) (raqm_t *rq,
size_t *length);
typedef raqm_glyph_t_01* (*t_raqm_get_glyphs_01) (raqm_t *rq,
size_t *length);
typedef raqm_glyph_t *(*t_raqm_get_glyphs)(raqm_t *rq, size_t *length);
typedef raqm_glyph_t_01 *(*t_raqm_get_glyphs_01)(raqm_t *rq, size_t *length);
typedef void (*t_raqm_destroy)(raqm_t *rq);
typedef struct {
@ -134,13 +122,11 @@ typedef struct {
static p_raqm_func p_raqm;
/* round a 26.6 pixel coordinate to the nearest integer */
#define PIXEL(x) ((((x) + 32) & -64) >> 6)
static PyObject *
geterror(int code)
{
geterror(int code) {
int i;
for (i = 0; ft_errors[i].message; i++) {
@ -155,8 +141,7 @@ geterror(int code)
}
static int
setraqm(void)
{
setraqm(void) {
/* set the static function pointers for dynamic raqm linking */
p_raqm.raqm = NULL;
@ -179,15 +164,21 @@ setraqm(void)
}
#ifndef _WIN32
p_raqm.version_string = (t_raqm_version_string)dlsym(p_raqm.raqm, "raqm_version_string");
p_raqm.version_atleast = (t_raqm_version_atleast)dlsym(p_raqm.raqm, "raqm_version_atleast");
p_raqm.version_string =
(t_raqm_version_string)dlsym(p_raqm.raqm, "raqm_version_string");
p_raqm.version_atleast =
(t_raqm_version_atleast)dlsym(p_raqm.raqm, "raqm_version_atleast");
p_raqm.create = (t_raqm_create)dlsym(p_raqm.raqm, "raqm_create");
p_raqm.set_text = (t_raqm_set_text)dlsym(p_raqm.raqm, "raqm_set_text");
p_raqm.set_text_utf8 = (t_raqm_set_text_utf8)dlsym(p_raqm.raqm, "raqm_set_text_utf8");
p_raqm.set_par_direction = (t_raqm_set_par_direction)dlsym(p_raqm.raqm, "raqm_set_par_direction");
p_raqm.set_text_utf8 =
(t_raqm_set_text_utf8)dlsym(p_raqm.raqm, "raqm_set_text_utf8");
p_raqm.set_par_direction =
(t_raqm_set_par_direction)dlsym(p_raqm.raqm, "raqm_set_par_direction");
p_raqm.set_language = (t_raqm_set_language)dlsym(p_raqm.raqm, "raqm_set_language");
p_raqm.add_font_feature = (t_raqm_add_font_feature)dlsym(p_raqm.raqm, "raqm_add_font_feature");
p_raqm.set_freetype_face = (t_raqm_set_freetype_face)dlsym(p_raqm.raqm, "raqm_set_freetype_face");
p_raqm.add_font_feature =
(t_raqm_add_font_feature)dlsym(p_raqm.raqm, "raqm_add_font_feature");
p_raqm.set_freetype_face =
(t_raqm_set_freetype_face)dlsym(p_raqm.raqm, "raqm_set_freetype_face");
p_raqm.layout = (t_raqm_layout)dlsym(p_raqm.raqm, "raqm_layout");
p_raqm.destroy = (t_raqm_destroy)dlsym(p_raqm.raqm, "raqm_destroy");
if (dlsym(p_raqm.raqm, "raqm_index_to_position")) {
@ -195,52 +186,50 @@ setraqm(void)
p_raqm.version = 2;
} else {
p_raqm.version = 1;
p_raqm.get_glyphs_01 = (t_raqm_get_glyphs_01)dlsym(p_raqm.raqm, "raqm_get_glyphs");
p_raqm.get_glyphs_01 =
(t_raqm_get_glyphs_01)dlsym(p_raqm.raqm, "raqm_get_glyphs");
}
if (dlerror() ||
!(p_raqm.create &&
p_raqm.set_text &&
p_raqm.set_text_utf8 &&
p_raqm.set_par_direction &&
p_raqm.set_language &&
p_raqm.add_font_feature &&
p_raqm.set_freetype_face &&
p_raqm.layout &&
(p_raqm.get_glyphs || p_raqm.get_glyphs_01) &&
p_raqm.destroy)) {
!(p_raqm.create && p_raqm.set_text && p_raqm.set_text_utf8 &&
p_raqm.set_par_direction && p_raqm.set_language && p_raqm.add_font_feature &&
p_raqm.set_freetype_face && p_raqm.layout &&
(p_raqm.get_glyphs || p_raqm.get_glyphs_01) && p_raqm.destroy)) {
dlclose(p_raqm.raqm);
p_raqm.raqm = NULL;
return 2;
}
#else
p_raqm.version_string = (t_raqm_version_string)GetProcAddress(p_raqm.raqm, "raqm_version_string");
p_raqm.version_atleast = (t_raqm_version_atleast)GetProcAddress(p_raqm.raqm, "raqm_version_atleast");
p_raqm.version_string =
(t_raqm_version_string)GetProcAddress(p_raqm.raqm, "raqm_version_string");
p_raqm.version_atleast =
(t_raqm_version_atleast)GetProcAddress(p_raqm.raqm, "raqm_version_atleast");
p_raqm.create = (t_raqm_create)GetProcAddress(p_raqm.raqm, "raqm_create");
p_raqm.set_text = (t_raqm_set_text)GetProcAddress(p_raqm.raqm, "raqm_set_text");
p_raqm.set_text_utf8 = (t_raqm_set_text_utf8)GetProcAddress(p_raqm.raqm, "raqm_set_text_utf8");
p_raqm.set_par_direction = (t_raqm_set_par_direction)GetProcAddress(p_raqm.raqm, "raqm_set_par_direction");
p_raqm.set_language = (t_raqm_set_language)GetProcAddress(p_raqm.raqm, "raqm_set_language");
p_raqm.add_font_feature = (t_raqm_add_font_feature)GetProcAddress(p_raqm.raqm, "raqm_add_font_feature");
p_raqm.set_freetype_face = (t_raqm_set_freetype_face)GetProcAddress(p_raqm.raqm, "raqm_set_freetype_face");
p_raqm.set_text_utf8 =
(t_raqm_set_text_utf8)GetProcAddress(p_raqm.raqm, "raqm_set_text_utf8");
p_raqm.set_par_direction =
(t_raqm_set_par_direction)GetProcAddress(p_raqm.raqm, "raqm_set_par_direction");
p_raqm.set_language =
(t_raqm_set_language)GetProcAddress(p_raqm.raqm, "raqm_set_language");
p_raqm.add_font_feature =
(t_raqm_add_font_feature)GetProcAddress(p_raqm.raqm, "raqm_add_font_feature");
p_raqm.set_freetype_face =
(t_raqm_set_freetype_face)GetProcAddress(p_raqm.raqm, "raqm_set_freetype_face");
p_raqm.layout = (t_raqm_layout)GetProcAddress(p_raqm.raqm, "raqm_layout");
p_raqm.destroy = (t_raqm_destroy)GetProcAddress(p_raqm.raqm, "raqm_destroy");
if (GetProcAddress(p_raqm.raqm, "raqm_index_to_position")) {
p_raqm.get_glyphs = (t_raqm_get_glyphs)GetProcAddress(p_raqm.raqm, "raqm_get_glyphs");
p_raqm.get_glyphs =
(t_raqm_get_glyphs)GetProcAddress(p_raqm.raqm, "raqm_get_glyphs");
p_raqm.version = 2;
} else {
p_raqm.version = 1;
p_raqm.get_glyphs_01 = (t_raqm_get_glyphs_01)GetProcAddress(p_raqm.raqm, "raqm_get_glyphs");
p_raqm.get_glyphs_01 =
(t_raqm_get_glyphs_01)GetProcAddress(p_raqm.raqm, "raqm_get_glyphs");
}
if (!(p_raqm.create &&
p_raqm.set_text &&
p_raqm.set_text_utf8 &&
p_raqm.set_par_direction &&
p_raqm.set_language &&
p_raqm.add_font_feature &&
p_raqm.set_freetype_face &&
p_raqm.layout &&
(p_raqm.get_glyphs || p_raqm.get_glyphs_01) &&
p_raqm.destroy)) {
if (!(p_raqm.create && p_raqm.set_text && p_raqm.set_text_utf8 &&
p_raqm.set_par_direction && p_raqm.set_language && p_raqm.add_font_feature &&
p_raqm.set_freetype_face && p_raqm.layout &&
(p_raqm.get_glyphs || p_raqm.get_glyphs_01) && p_raqm.destroy)) {
FreeLibrary(p_raqm.raqm);
p_raqm.raqm = NULL;
return 2;
@ -251,8 +240,7 @@ setraqm(void)
}
static PyObject *
getfont(PyObject* self_, PyObject* args, PyObject* kw)
{
getfont(PyObject *self_, PyObject *args, PyObject *kw) {
/* create a font object from a file name and a size (in pixels) */
FontObject *self;
@ -266,22 +254,26 @@ getfont(PyObject* self_, PyObject* args, PyObject* kw)
unsigned char *font_bytes;
Py_ssize_t font_bytes_size = 0;
static char *kwlist[] = {
"filename", "size", "index", "encoding", "font_bytes",
"layout_engine", NULL
};
"filename", "size", "index", "encoding", "font_bytes", "layout_engine", NULL};
if (!library) {
PyErr_SetString(
PyExc_OSError,
"failed to initialize FreeType library"
);
PyErr_SetString(PyExc_OSError, "failed to initialize FreeType library");
return NULL;
}
if (!PyArg_ParseTupleAndKeywords(args, kw, "etn|nsy#n", kwlist,
Py_FileSystemDefaultEncoding, &filename,
&size, &index, &encoding, &font_bytes,
&font_bytes_size, &layout_engine)) {
if (!PyArg_ParseTupleAndKeywords(
args,
kw,
"etn|nsy#n",
kwlist,
Py_FileSystemDefaultEncoding,
&filename,
&size,
&index,
&encoding,
&font_bytes,
&font_bytes_size,
&layout_engine)) {
return NULL;
}
@ -308,8 +300,12 @@ getfont(PyObject* self_, PyObject* args, PyObject* kw)
}
if (!error) {
memcpy(self->font_bytes, font_bytes, (size_t)font_bytes_size);
error = FT_New_Memory_Face(library, (FT_Byte*)self->font_bytes,
font_bytes_size, index, &self->face);
error = FT_New_Memory_Face(
library,
(FT_Byte *)self->font_bytes,
font_bytes_size,
index,
&self->face);
}
}
@ -318,9 +314,8 @@ getfont(PyObject* self_, PyObject* args, PyObject* kw)
}
if (!error && encoding && strlen((char *)encoding) == 4) {
FT_Encoding encoding_tag = FT_MAKE_TAG(
encoding[0], encoding[1], encoding[2], encoding[3]
);
FT_Encoding encoding_tag =
FT_MAKE_TAG(encoding[0], encoding[1], encoding[2], encoding[3]);
error = FT_Select_Charmap(self->face, encoding_tag);
}
if (filename) {
@ -340,8 +335,7 @@ getfont(PyObject* self_, PyObject* args, PyObject* kw)
}
static int
font_getchar(PyObject* string, int index, FT_ULong* char_out)
{
font_getchar(PyObject *string, int index, FT_ULong *char_out) {
if (PyUnicode_Check(string)) {
if (index >= PyUnicode_GET_LENGTH(string)) {
return 0;
@ -353,9 +347,15 @@ font_getchar(PyObject* string, int index, FT_ULong* char_out)
}
static size_t
text_layout_raqm(PyObject* string, FontObject* self, const char* dir, PyObject *features,
const char* lang, GlyphInfo **glyph_info, int mask, int color)
{
text_layout_raqm(
PyObject *string,
FontObject *self,
const char *dir,
PyObject *features,
const char *lang,
GlyphInfo **glyph_info,
int mask,
int color) {
size_t i = 0, count = 0, start = 0;
raqm_t *rq;
raqm_glyph_t *glyphs = NULL;
@ -388,8 +388,7 @@ text_layout_raqm(PyObject* string, FontObject* self, const char* dir, PyObject *
goto failed;
}
}
}
else {
} else {
PyErr_SetString(PyExc_TypeError, "expected string");
goto failed;
}
@ -403,11 +402,14 @@ text_layout_raqm(PyObject* string, FontObject* self, const char* dir, PyObject *
} else if (strcmp(dir, "ttb") == 0) {
direction = RAQM_DIRECTION_TTB;
if (p_raqm.version_atleast == NULL || !(*p_raqm.version_atleast)(0, 7, 0)) {
PyErr_SetString(PyExc_ValueError, "libraqm 0.7 or greater required for 'ttb' direction");
PyErr_SetString(
PyExc_ValueError,
"libraqm 0.7 or greater required for 'ttb' direction");
goto failed;
}
} else {
PyErr_SetString(PyExc_ValueError, "direction must be either 'rtl', 'ltr' or 'ttb'");
PyErr_SetString(
PyExc_ValueError, "direction must be either 'rtl', 'ltr' or 'ttb'");
goto failed;
}
}
@ -510,9 +512,15 @@ failed:
}
static size_t
text_layout_fallback(PyObject* string, FontObject* self, const char* dir, PyObject *features,
const char* lang, GlyphInfo **glyph_info, int mask, int color)
{
text_layout_fallback(
PyObject *string,
FontObject *self,
const char *dir,
PyObject *features,
const char *lang,
GlyphInfo **glyph_info,
int mask,
int color) {
int error, load_flags;
FT_ULong ch;
Py_ssize_t count;
@ -522,7 +530,10 @@ text_layout_fallback(PyObject* string, FontObject* self, const char* dir, PyObje
int i;
if (features != Py_None || dir != NULL || lang != NULL) {
PyErr_SetString(PyExc_KeyError, "setting text direction, language or font features is not supported without libraqm");
PyErr_SetString(
PyExc_KeyError,
"setting text direction, language or font features is not supported "
"without libraqm");
}
if (!PyUnicode_Check(string)) {
PyErr_SetString(PyExc_TypeError, "expected string");
@ -564,8 +575,12 @@ text_layout_fallback(PyObject* string, FontObject* self, const char* dir, PyObje
(*glyph_info)[i].y_offset = 0;
if (kerning && last_index && (*glyph_info)[i].index) {
FT_Vector delta;
if (FT_Get_Kerning(self->face, last_index, (*glyph_info)[i].index,
ft_kerning_default,&delta) == 0) {
if (FT_Get_Kerning(
self->face,
last_index,
(*glyph_info)[i].index,
ft_kerning_default,
&delta) == 0) {
(*glyph_info)[i - 1].x_advance += PIXEL(delta.x);
(*glyph_info)[i - 1].y_advance += PIXEL(delta.y);
}
@ -581,22 +596,29 @@ text_layout_fallback(PyObject* string, FontObject* self, const char* dir, PyObje
}
static size_t
text_layout(PyObject* string, FontObject* self, const char* dir, PyObject *features,
const char* lang, GlyphInfo **glyph_info, int mask, int color)
{
text_layout(
PyObject *string,
FontObject *self,
const char *dir,
PyObject *features,
const char *lang,
GlyphInfo **glyph_info,
int mask,
int color) {
size_t count;
if (p_raqm.raqm && self->layout_engine == LAYOUT_RAQM) {
count = text_layout_raqm(string, self, dir, features, lang, glyph_info, mask, color);
count = text_layout_raqm(
string, self, dir, features, lang, glyph_info, mask, color);
} else {
count = text_layout_fallback(string, self, dir, features, lang, glyph_info, mask, color);
count = text_layout_fallback(
string, self, dir, features, lang, glyph_info, mask, color);
}
return count;
}
static PyObject *
font_getlength(FontObject* self, PyObject* args)
{
font_getlength(FontObject *self, PyObject *args) {
int length; /* length along primary axis, in 26.6 precision */
GlyphInfo *glyph_info = NULL; /* computed text layout */
size_t i, count; /* glyph_info index and length */
@ -611,7 +633,8 @@ font_getlength(FontObject* self, PyObject* args)
/* calculate size and bearing for a given string */
if (!PyArg_ParseTuple(args, "O|zzOz:getlength", &string, &mode, &dir, &features, &lang)) {
if (!PyArg_ParseTuple(
args, "O|zzOz:getlength", &string, &mode, &dir, &features, &lang)) {
return NULL;
}
@ -643,8 +666,7 @@ font_getlength(FontObject* self, PyObject* args)
}
static PyObject *
font_getsize(FontObject* self, PyObject* args)
{
font_getsize(FontObject *self, PyObject *args) {
int position; /* pen position along primary axis, in 26.6 precision */
int advanced; /* pen position along primary axis, in pixels */
int px, py; /* position of current glyph, in pixels */
@ -669,7 +691,8 @@ font_getsize(FontObject* self, PyObject* args)
/* calculate size and bearing for a given string */
if (!PyArg_ParseTuple(args, "O|zzOzz:getsize", &string, &mode, &dir, &features, &lang, &anchor)) {
if (!PyArg_ParseTuple(
args, "O|zzOzz:getsize", &string, &mode, &dir, &features, &lang, &anchor)) {
return NULL;
}
@ -792,7 +815,10 @@ font_getsize(FontObject* self, PyObject* args)
y_anchor = y_max;
break;
case 'm': // middle (ascender + descender) / 2
y_anchor = PIXEL((self->face->size->metrics.ascender + self->face->size->metrics.descender) / 2);
y_anchor = PIXEL(
(self->face->size->metrics.ascender +
self->face->size->metrics.descender) /
2);
break;
case 's': // horizontal baseline
y_anchor = 0;
@ -844,9 +870,10 @@ font_getsize(FontObject* self, PyObject* args)
return Py_BuildValue(
"(ii)(ii)",
(x_max - x_min), (y_max - y_min),
(-x_anchor + x_min), -(-y_anchor + y_max)
);
(x_max - x_min),
(y_max - y_min),
(-x_anchor + x_min),
-(-y_anchor + y_max));
bad_anchor:
PyErr_Format(PyExc_ValueError, "bad anchor specified: %s", anchor);
@ -854,8 +881,7 @@ bad_anchor:
}
static PyObject *
font_render(FontObject* self, PyObject* args)
{
font_render(FontObject *self, PyObject *args) {
int x, y; /* pen position, in 26.6 precision */
int px, py; /* position of current glyph, in pixels */
int x_min, y_max; /* text offset in 26.6 precision */
@ -891,8 +917,17 @@ font_render(FontObject* self, PyObject* args)
/* render string into given buffer (the buffer *must* have
the right size, or this will crash) */
if (!PyArg_ParseTuple(args, "On|zzOziL:render", &string, &id, &mode, &dir, &features, &lang,
&stroke_width, &foreground_ink_long)) {
if (!PyArg_ParseTuple(
args,
"On|zzOziL:render",
&string,
&id,
&mode,
&dir,
&features,
&lang,
&stroke_width,
&foreground_ink_long)) {
return NULL;
}
@ -908,7 +943,8 @@ font_render(FontObject* self, PyObject* args)
foreground_color.red = ink[0];
foreground_color.green = ink[1];
foreground_color.blue = ink[2];
foreground_color.alpha = (FT_Byte) 255; /* ink alpha is handled in ImageDraw.text */
foreground_color.alpha =
(FT_Byte)255; /* ink alpha is handled in ImageDraw.text */
FT_Palette_Set_Foreground_Color(self->face, foreground_color);
}
#endif
@ -927,7 +963,12 @@ font_render(FontObject* self, PyObject* args)
return geterror(error);
}
FT_Stroker_Set(stroker, (FT_Fixed)stroke_width*64, FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);
FT_Stroker_Set(
stroker,
(FT_Fixed)stroke_width * 64,
FT_STROKER_LINECAP_ROUND,
FT_STROKER_LINEJOIN_ROUND,
0);
}
im = (Imaging)id;
@ -950,7 +991,8 @@ font_render(FontObject* self, PyObject* args)
px = PIXEL(x + glyph_info[i].x_offset);
py = PIXEL(y + glyph_info[i].y_offset);
error = FT_Load_Glyph(self->face, glyph_info[i].index, load_flags | FT_LOAD_RENDER);
error =
FT_Load_Glyph(self->face, glyph_info[i].index, load_flags | FT_LOAD_RENDER);
if (error) {
return geterror(error);
}
@ -1030,9 +1072,7 @@ font_render(FontObject* self, PyObject* args)
case FT_PIXEL_MODE_GRAY2:
case FT_PIXEL_MODE_GRAY4:
if (!bitmap_converted_ready) {
#if FREETYPE_MAJOR > 2 ||\
(FREETYPE_MAJOR == 2 && FREETYPE_MINOR > 6)
#if FREETYPE_MAJOR > 2 || (FREETYPE_MAJOR == 2 && FREETYPE_MINOR > 6)
FT_Bitmap_Init(&bitmap_converted);
#else
FT_Bitmap_New(&bitmap_converted);
@ -1091,9 +1131,12 @@ font_render(FontObject* self, PyObject* args)
for (k = x0; k < x1; k++) {
if (target[k * 4 + 3] < source[k * 4 + 3]) {
/* unpremultiply BGRa to RGBA */
target[k * 4 + 0] = CLIP8((255 * (int)source[k * 4 + 2]) / source[k * 4 + 3]);
target[k * 4 + 1] = CLIP8((255 * (int)source[k * 4 + 1]) / source[k * 4 + 3]);
target[k * 4 + 2] = CLIP8((255 * (int)source[k * 4 + 0]) / source[k * 4 + 3]);
target[k * 4 + 0] = CLIP8(
(255 * (int)source[k * 4 + 2]) / source[k * 4 + 3]);
target[k * 4 + 1] = CLIP8(
(255 * (int)source[k * 4 + 1]) / source[k * 4 + 3]);
target[k * 4 + 2] = CLIP8(
(255 * (int)source[k * 4 + 0]) / source[k * 4 + 3]);
target[k * 4 + 3] = source[k * 4 + 3];
}
}
@ -1152,12 +1195,10 @@ glyph_error:
return NULL;
}
#if FREETYPE_MAJOR > 2 ||\
(FREETYPE_MAJOR == 2 && FREETYPE_MINOR > 9) ||\
#if FREETYPE_MAJOR > 2 || (FREETYPE_MAJOR == 2 && FREETYPE_MINOR > 9) || \
(FREETYPE_MAJOR == 2 && FREETYPE_MINOR == 9 && FREETYPE_PATCH == 1)
static PyObject *
font_getvarnames(FontObject* self)
{
font_getvarnames(FontObject *self) {
int error;
FT_UInt i, j, num_namedstyles, name_count;
FT_MM_Var *master;
@ -1198,8 +1239,7 @@ glyph_error:
}
static PyObject *
font_getvaraxes(FontObject* self)
{
font_getvaraxes(FontObject *self) {
int error;
FT_UInt i, j, num_axis, name_count;
FT_MM_Var *master;
@ -1219,12 +1259,11 @@ glyph_error:
axis = master->axis[i];
list_axis = PyDict_New();
PyDict_SetItemString(list_axis, "minimum",
PyLong_FromLong(axis.minimum / 65536));
PyDict_SetItemString(list_axis, "default",
PyLong_FromLong(axis.def / 65536));
PyDict_SetItemString(list_axis, "maximum",
PyLong_FromLong(axis.maximum / 65536));
PyDict_SetItemString(
list_axis, "minimum", PyLong_FromLong(axis.minimum / 65536));
PyDict_SetItemString(list_axis, "default", PyLong_FromLong(axis.def / 65536));
PyDict_SetItemString(
list_axis, "maximum", PyLong_FromLong(axis.maximum / 65536));
for (j = 0; j < name_count; j++) {
error = FT_Get_Sfnt_Name(self->face, j, &name);
@ -1248,8 +1287,7 @@ glyph_error:
}
static PyObject *
font_setvarname(FontObject* self, PyObject* args)
{
font_setvarname(FontObject *self, PyObject *args) {
int error;
int instance_index;
@ -1267,8 +1305,7 @@ glyph_error:
}
static PyObject *
font_setvaraxes(FontObject* self, PyObject* args)
{
font_setvaraxes(FontObject *self, PyObject *args) {
int error;
PyObject *axes, *item;
@ -1317,8 +1354,7 @@ glyph_error:
#endif
static void
font_dealloc(FontObject* self)
{
font_dealloc(FontObject *self) {
if (self->face) {
FT_Done_Face(self->face);
}
@ -1332,20 +1368,17 @@ static PyMethodDef font_methods[] = {
{"render", (PyCFunction)font_render, METH_VARARGS},
{"getsize", (PyCFunction)font_getsize, METH_VARARGS},
{"getlength", (PyCFunction)font_getlength, METH_VARARGS},
#if FREETYPE_MAJOR > 2 ||\
(FREETYPE_MAJOR == 2 && FREETYPE_MINOR > 9) ||\
#if FREETYPE_MAJOR > 2 || (FREETYPE_MAJOR == 2 && FREETYPE_MINOR > 9) || \
(FREETYPE_MAJOR == 2 && FREETYPE_MINOR == 9 && FREETYPE_PATCH == 1)
{"getvarnames", (PyCFunction)font_getvarnames, METH_NOARGS},
{"getvaraxes", (PyCFunction)font_getvaraxes, METH_NOARGS},
{"setvarname", (PyCFunction)font_setvarname, METH_VARARGS},
{"setvaraxes", (PyCFunction)font_setvaraxes, METH_VARARGS},
#endif
{NULL, NULL}
};
{NULL, NULL}};
static PyObject *
font_getattr_family(FontObject* self, void* closure)
{
font_getattr_family(FontObject *self, void *closure) {
if (self->face->family_name) {
return PyUnicode_FromString(self->face->family_name);
}
@ -1353,8 +1386,7 @@ font_getattr_family(FontObject* self, void* closure)
}
static PyObject *
font_getattr_style(FontObject* self, void* closure)
{
font_getattr_style(FontObject *self, void *closure) {
if (self->face->style_name) {
return PyUnicode_FromString(self->face->style_name);
}
@ -1362,39 +1394,32 @@ font_getattr_style(FontObject* self, void* closure)
}
static PyObject *
font_getattr_ascent(FontObject* self, void* closure)
{
font_getattr_ascent(FontObject *self, void *closure) {
return PyLong_FromLong(PIXEL(self->face->size->metrics.ascender));
}
static PyObject *
font_getattr_descent(FontObject* self, void* closure)
{
font_getattr_descent(FontObject *self, void *closure) {
return PyLong_FromLong(-PIXEL(self->face->size->metrics.descender));
}
static PyObject *
font_getattr_height(FontObject* self, void* closure)
{
font_getattr_height(FontObject *self, void *closure) {
return PyLong_FromLong(PIXEL(self->face->size->metrics.height));
}
static PyObject *
font_getattr_x_ppem(FontObject* self, void* closure)
{
font_getattr_x_ppem(FontObject *self, void *closure) {
return PyLong_FromLong(self->face->size->metrics.x_ppem);
}
static PyObject *
font_getattr_y_ppem(FontObject* self, void* closure)
{
font_getattr_y_ppem(FontObject *self, void *closure) {
return PyLong_FromLong(self->face->size->metrics.y_ppem);
}
static PyObject *
font_getattr_glyphs(FontObject* self, void* closure)
{
font_getattr_glyphs(FontObject *self, void *closure) {
return PyLong_FromLong(self->face->num_glyphs);
}
@ -1407,12 +1432,12 @@ static struct PyGetSetDef font_getsetters[] = {
{"x_ppem", (getter)font_getattr_x_ppem},
{"y_ppem", (getter)font_getattr_y_ppem},
{"glyphs", (getter)font_getattr_glyphs},
{ NULL }
};
{NULL}};
static PyTypeObject Font_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"Font", sizeof(FontObject), 0,
PyVarObject_HEAD_INIT(NULL, 0) "Font",
sizeof(FontObject),
0,
/* methods */
(destructor)font_dealloc, /* tp_dealloc */
0, /* tp_print */
@ -1443,9 +1468,7 @@ static PyTypeObject Font_Type = {
};
static PyMethodDef _functions[] = {
{"getfont", (PyCFunction) getfont, METH_VARARGS|METH_KEYWORDS},
{NULL, NULL}
};
{"getfont", (PyCFunction)getfont, METH_VARARGS | METH_KEYWORDS}, {NULL, NULL}};
static int
setup_module(PyObject *m) {
@ -1467,12 +1490,12 @@ setup_module(PyObject* m) {
v = PyUnicode_FromFormat("%d.%d.%d", major, minor, patch);
PyDict_SetItemString(d, "freetype2_version", v);
setraqm();
v = PyBool_FromLong(!!p_raqm.raqm);
PyDict_SetItemString(d, "HAVE_RAQM", v);
if (p_raqm.version_string) {
PyDict_SetItemString(d, "raqm_version", PyUnicode_FromString(p_raqm.version_string()));
PyDict_SetItemString(
d, "raqm_version", PyUnicode_FromString(p_raqm.version_string()));
}
return 0;

31
src/_imagingmath.c
View File

@ -24,22 +24,21 @@
#define MIN_INT32 -2147483648.0
#define UNOP(name, op, type) \
void name(Imaging out, Imaging im1)\
{\
void name(Imaging out, Imaging im1) { \
int x, y; \
for (y = 0; y < out->ysize; y++) { \
type *p0 = (type *)out->image[y]; \
type *p1 = (type *)im1->image[y]; \
for (x = 0; x < out->xsize; x++) { \
*p0 = op(type, *p1); \
p0++; p1++;\
p0++; \
p1++; \
} \
} \
}
#define BINOP(name, op, type) \
void name(Imaging out, Imaging im1, Imaging im2)\
{\
void name(Imaging out, Imaging im1, Imaging im2) { \
int x, y; \
for (y = 0; y < out->ysize; y++) { \
type *p0 = (type *)out->image[y]; \
@ -47,7 +46,9 @@ void name(Imaging out, Imaging im1, Imaging im2)\
type *p2 = (type *)im2->image[y]; \
for (x = 0; x < out->xsize; x++) { \
*p0 = op(type, *p1, *p2); \
p0++; p1++; p2++;\
p0++; \
p1++; \
p2++; \
} \
} \
}
@ -85,8 +86,8 @@ void name(Imaging out, Imaging im1, Imaging im2)\
#define MOD_I(type, v1, v2) ((v2) != 0) ? (v1) % (v2) : 0
#define MOD_F(type, v1, v2) ((v2) != 0.0F) ? fmod((v1), (v2)) : 0.0F
static int powi(int x, int y)
{
static int
powi(int x, int y) {
double v = pow(x, y) + 0.5;
if (errno == EDOM) {
return 0;
@ -162,8 +163,7 @@ BINOP(gt_F, GT, FLOAT32)
BINOP(ge_F, GE, FLOAT32)
static PyObject *
_unop(PyObject* self, PyObject* args)
{
_unop(PyObject *self, PyObject *args) {
Imaging out;
Imaging im1;
void (*unop)(Imaging, Imaging);
@ -185,8 +185,7 @@ _unop(PyObject* self, PyObject* args)
}
static PyObject *
_binop(PyObject* self, PyObject* args)
{
_binop(PyObject *self, PyObject *args) {
Imaging out;
Imaging im1;
Imaging im2;
@ -210,14 +209,10 @@ _binop(PyObject* self, PyObject* args)
}
static PyMethodDef _functions[] = {
{"unop", _unop, 1},
{"binop", _binop, 1},
{NULL, NULL}
};
{"unop", _unop, 1}, {"binop", _binop, 1}, {NULL, NULL}};
static void
install(PyObject *d, char* name, void* value)
{
install(PyObject *d, char *name, void *value) {
PyObject *v = PyLong_FromSsize_t((Py_ssize_t)value);
if (!v || PyDict_SetItemString(d, name, v)) {
PyErr_Clear();

49
src/_imagingmorph.c
View File

@ -28,8 +28,7 @@
Returns number of changed pixels.
*/
static PyObject *
apply(PyObject *self, PyObject* args)
{
apply(PyObject *self, PyObject *args) {
const char *lut;
PyObject *py_lut;
Py_ssize_t lut_len, i0, i1;
@ -63,13 +62,11 @@ apply(PyObject *self, PyObject* args)
width = imgin->xsize;
height = imgin->ysize;
if (imgin->type != IMAGING_TYPE_UINT8 ||
imgin->bands != 1) {
if (imgin->type != IMAGING_TYPE_UINT8 || imgin->bands != 1) {
PyErr_SetString(PyExc_RuntimeError, "Unsupported image type");
return NULL;
}
if (imgout->type != IMAGING_TYPE_UINT8 ||
imgout->bands != 1) {
if (imgout->type != IMAGING_TYPE_UINT8 || imgout->bands != 1) {
PyErr_SetString(PyExc_RuntimeError, "Unsupported image type");
return NULL;
}
@ -109,15 +106,9 @@ apply(PyObject *self, PyObject* args)
unsigned char b7 = nrow[col_idx] & 1;
unsigned char b8 = nrow[cip] & 1;
int lut_idx = (b0
|(b1 << 1)
|(b2 << 2)
|(b3 << 3)
|(b4 << 4)
|(b5 << 5)
|(b6 << 6)
|(b7 << 7)
|(b8 << 8));
int lut_idx =
(b0 | (b1 << 1) | (b2 << 2) | (b3 << 3) | (b4 << 4) | (b5 << 5) |
(b6 << 6) | (b7 << 7) | (b8 << 8));
outrow[col_idx] = 255 * (lut[lut_idx] & 1);
num_changed_pixels += ((b4 & 1) != (outrow[col_idx] & 1));
}
@ -136,8 +127,7 @@ apply(PyObject *self, PyObject* args)
Returns list of matching pixels.
*/
static PyObject *
match(PyObject *self, PyObject* args)
{
match(PyObject *self, PyObject *args) {
const char *lut;
PyObject *py_lut;
Py_ssize_t lut_len, i0;
@ -167,8 +157,7 @@ match(PyObject *self, PyObject* args)
lut = PyBytes_AsString(py_lut);
imgin = (Imaging)i0;
if (imgin->type != IMAGING_TYPE_UINT8 ||
imgin->bands != 1) {
if (imgin->type != IMAGING_TYPE_UINT8 || imgin->bands != 1) {
PyErr_SetString(PyExc_RuntimeError, "Unsupported image type");
return NULL;
}
@ -199,15 +188,9 @@ match(PyObject *self, PyObject* args)
unsigned char b7 = nrow[col_idx] & 1;
unsigned char b8 = nrow[cip] & 1;
int lut_idx = (b0
|(b1 << 1)
|(b2 << 2)
|(b3 << 3)
|(b4 << 4)
|(b5 << 5)
|(b6 << 6)
|(b7 << 7)
|(b8 << 8));
int lut_idx =
(b0 | (b1 << 1) | (b2 << 2) | (b3 << 3) | (b4 << 4) | (b5 << 5) |
(b6 << 6) | (b7 << 7) | (b8 << 8));
if (lut[lut_idx]) {
PyObject *coordObj = Py_BuildValue("(nn)", col_idx, row_idx);
PyList_Append(ret, coordObj);
@ -223,8 +206,7 @@ match(PyObject *self, PyObject* args)
This is faster than match as only 1x1 lookup is made.
*/
static PyObject *
get_on_pixels(PyObject *self, PyObject* args)
{
get_on_pixels(PyObject *self, PyObject *args) {
Py_ssize_t i0;
Imaging img;
UINT8 **rows;
@ -254,10 +236,8 @@ get_on_pixels(PyObject *self, PyObject* args)
return ret;
}
static int
setup_module(PyObject* m)
{
setup_module(PyObject *m) {
PyObject *d = PyModule_GetDict(m);
PyDict_SetItemString(d, "__version", PyUnicode_FromString("0.1"));
@ -270,8 +250,7 @@ static PyMethodDef functions[] = {
{"apply", (PyCFunction)apply, METH_VARARGS, NULL},
{"get_on_pixels", (PyCFunction)get_on_pixels, METH_VARARGS, NULL},
{"match", (PyCFunction)match, METH_VARARGS, NULL},
{NULL, NULL, 0, NULL}
};
{NULL, NULL, 0, NULL}};
PyMODINIT_FUNC
PyInit__imagingmorph(void) {

13
src/_imagingtk.c
View File

@ -12,28 +12,27 @@
* See the README file for information on usage and redistribution.
*/
#include "Python.h"
#include "libImaging/Imaging.h"
#include "Tk/_tkmini.h"
/* must link with Tk/tkImaging.c */
extern void TkImaging_Init(Tcl_Interp* interp);
extern int load_tkinter_funcs(void);
extern void
TkImaging_Init(Tcl_Interp *interp);
extern int
load_tkinter_funcs(void);
/* copied from _tkinter.c (this isn't as bad as it may seem: for new
versions, we use _tkinter's interpaddr hook instead, and all older
versions use this structure layout) */
typedef struct {
PyObject_HEAD
Tcl_Interp* interp;
PyObject_HEAD Tcl_Interp *interp;
} TkappObject;
static PyObject *
_tkinit(PyObject* self, PyObject* args)
{
_tkinit(PyObject *self, PyObject *args) {
Tcl_Interp *interp;
PyObject *arg;

237
src/_webp.c
View File

@ -21,11 +21,13 @@
#endif
void ImagingSectionEnter(ImagingSectionCookie* cookie) {
void
ImagingSectionEnter(ImagingSectionCookie *cookie) {
*cookie = (PyThreadState *)PyEval_SaveThread();
}
void ImagingSectionLeave(ImagingSectionCookie* cookie) {
void
ImagingSectionLeave(ImagingSectionCookie *cookie) {
PyEval_RestoreThread((PyThreadState *)*cookie);
}
@ -36,11 +38,14 @@ void ImagingSectionLeave(ImagingSectionCookie* cookie) {
#ifdef HAVE_WEBPMUX
static const char *const kErrorMessages[-WEBP_MUX_NOT_ENOUGH_DATA + 1] = {
"WEBP_MUX_NOT_FOUND", "WEBP_MUX_INVALID_ARGUMENT", "WEBP_MUX_BAD_DATA",
"WEBP_MUX_MEMORY_ERROR", "WEBP_MUX_NOT_ENOUGH_DATA"
};
"WEBP_MUX_NOT_FOUND",
"WEBP_MUX_INVALID_ARGUMENT",
"WEBP_MUX_BAD_DATA",
"WEBP_MUX_MEMORY_ERROR",
"WEBP_MUX_NOT_ENOUGH_DATA"};
PyObject* HandleMuxError(WebPMuxError err, char* chunk) {
PyObject *
HandleMuxError(WebPMuxError err, char *chunk) {
char message[100];
int message_len;
assert(err <= WEBP_MUX_NOT_FOUND && err >= WEBP_MUX_NOT_ENOUGH_DATA);
@ -52,9 +57,11 @@ PyObject* HandleMuxError(WebPMuxError err, char* chunk) {
// Create the error message
if (chunk == NULL) {
message_len = sprintf(message, "could not assemble chunks: %s", kErrorMessages[-err]);
message_len =
sprintf(message, "could not assemble chunks: %s", kErrorMessages[-err]);
} else {
message_len = sprintf(message, "could not set %.4s chunk: %s", chunk, kErrorMessages[-err]);
message_len = sprintf(
message, "could not set %.4s chunk: %s", chunk, kErrorMessages[-err]);
}
if (message_len < 0) {
PyErr_SetString(PyExc_RuntimeError, "failed to construct error message");
@ -90,8 +97,7 @@ PyObject* HandleMuxError(WebPMuxError err, char* chunk) {
// Encoder type
typedef struct {
PyObject_HEAD
WebPAnimEncoder* enc;
PyObject_HEAD WebPAnimEncoder *enc;
WebPPicture frame;
} WebPAnimEncoderObject;
@ -99,8 +105,7 @@ static PyTypeObject WebPAnimEncoder_Type;
// Decoder type
typedef struct {
PyObject_HEAD
WebPAnimDecoder* dec;
PyObject_HEAD WebPAnimDecoder *dec;
WebPAnimInfo info;
WebPData data;
char *mode;
@ -109,8 +114,8 @@ typedef struct {
static PyTypeObject WebPAnimDecoder_Type;
// Encoder functions
PyObject* _anim_encoder_new(PyObject* self, PyObject* args)
{
PyObject *
_anim_encoder_new(PyObject *self, PyObject *args) {
int width, height;
uint32_t bgcolor;
int loop_count;
@ -122,9 +127,18 @@ PyObject* _anim_encoder_new(PyObject* self, PyObject* args)
WebPAnimEncoderObject *encp = NULL;
WebPAnimEncoder *enc = NULL;
if (!PyArg_ParseTuple(args, "iiIiiiiii",
&width, &height, &bgcolor, &loop_count, &minimize_size,
&kmin, &kmax, &allow_mixed, &verbose)) {
if (!PyArg_ParseTuple(
args,
"iiIiiiiii",
&width,
&height,
&bgcolor,
&loop_count,
&minimize_size,
&kmin,
&kmax,
&allow_mixed,
&verbose)) {
return NULL;
}
@ -164,16 +178,16 @@ PyObject* _anim_encoder_new(PyObject* self, PyObject* args)
return NULL;
}
PyObject* _anim_encoder_dealloc(PyObject* self)
{
PyObject *
_anim_encoder_dealloc(PyObject *self) {
WebPAnimEncoderObject *encp = (WebPAnimEncoderObject *)self;
WebPPictureFree(&(encp->frame));
WebPAnimEncoderDelete(encp->enc);
Py_RETURN_NONE;
}
PyObject* _anim_encoder_add(PyObject* self, PyObject* args)
{
PyObject *
_anim_encoder_add(PyObject *self, PyObject *args) {
uint8_t *rgb;
Py_ssize_t size;
int timestamp;
@ -188,9 +202,18 @@ PyObject* _anim_encoder_add(PyObject* self, PyObject* args)
WebPAnimEncoder *enc = encp->enc;
WebPPicture *frame = &(encp->frame);
if (!PyArg_ParseTuple(args, "z#iiisifi",
(char**)&rgb, &size, &timestamp, &width, &height, &mode,
&lossless, &quality_factor, &method)) {
if (!PyArg_ParseTuple(
args,
"z#iiisifi",
(char **)&rgb,
&size,
&timestamp,
&width,
&height,
&mode,
&lossless,
&quality_factor,
&method)) {
return NULL;
}
@ -236,8 +259,8 @@ PyObject* _anim_encoder_add(PyObject* self, PyObject* args)
Py_RETURN_NONE;
}
PyObject* _anim_encoder_assemble(PyObject* self, PyObject* args)
{
PyObject *
_anim_encoder_assemble(PyObject *self, PyObject *args) {
uint8_t *icc_bytes;
uint8_t *exif_bytes;
uint8_t *xmp_bytes;
@ -250,8 +273,15 @@ PyObject* _anim_encoder_assemble(PyObject* self, PyObject* args)
WebPMux *mux = NULL;
PyObject *ret = NULL;
if (!PyArg_ParseTuple(args, "s#s#s#",
&icc_bytes, &icc_size, &exif_bytes, &exif_size, &xmp_bytes, &xmp_size)) {
if (!PyArg_ParseTuple(
args,
"s#s#s#",
&icc_bytes,
&icc_size,
&exif_bytes,
&exif_size,
&xmp_bytes,
&xmp_size)) {
return NULL;
}
@ -324,8 +354,8 @@ PyObject* _anim_encoder_assemble(PyObject* self, PyObject* args)
}
// Decoder functions
PyObject* _anim_decoder_new(PyObject* self, PyObject* args)
{
PyObject *
_anim_decoder_new(PyObject *self, PyObject *args) {
PyBytesObject *webp_string;
const uint8_t *webp;
Py_ssize_t size;
@ -369,30 +399,31 @@ PyObject* _anim_decoder_new(PyObject* self, PyObject* args)
return NULL;
}
PyObject* _anim_decoder_dealloc(PyObject* self)
{
PyObject *
_anim_decoder_dealloc(PyObject *self) {
WebPAnimDecoderObject *decp = (WebPAnimDecoderObject *)self;
WebPDataClear(&(decp->data));
WebPAnimDecoderDelete(decp->dec);
Py_RETURN_NONE;
}
PyObject* _anim_decoder_get_info(PyObject* self)
{
PyObject *
_anim_decoder_get_info(PyObject *self) {
WebPAnimDecoderObject *decp = (WebPAnimDecoderObject *)self;
WebPAnimInfo *info = &(decp->info);
return Py_BuildValue("IIIIIs",
info->canvas_width, info->canvas_height,
return Py_BuildValue(
"IIIIIs",
info->canvas_width,
info->canvas_height,
info->loop_count,
info->bgcolor,
info->frame_count,
decp->mode
);
decp->mode);
}
PyObject* _anim_decoder_get_chunk(PyObject* self, PyObject* args)
{
PyObject *
_anim_decoder_get_chunk(PyObject *self, PyObject *args) {
char *mode;
WebPAnimDecoderObject *decp = (WebPAnimDecoderObject *)self;
const WebPDemuxer *demux;
@ -414,8 +445,8 @@ PyObject* _anim_decoder_get_chunk(PyObject* self, PyObject* args)
return ret;
}
PyObject* _anim_decoder_get_next(PyObject* self)
{
PyObject *
_anim_decoder_get_next(PyObject *self) {
uint8_t *buf;
int timestamp;
PyObject *bytes;
@ -427,8 +458,8 @@ PyObject* _anim_decoder_get_next(PyObject* self)
return NULL;
}
bytes = PyBytes_FromStringAndSize((char *)buf,
decp->info.canvas_width * 4 * decp->info.canvas_height);
bytes = PyBytes_FromStringAndSize(
(char *)buf, decp->info.canvas_width * 4 * decp->info.canvas_height);
ret = Py_BuildValue("Si", bytes, timestamp);
@ -436,8 +467,8 @@ PyObject* _anim_decoder_get_next(PyObject* self)
return ret;
}
PyObject* _anim_decoder_reset(PyObject* self)
{
PyObject *
_anim_decoder_reset(PyObject *self) {
WebPAnimDecoderObject *decp = (WebPAnimDecoderObject *)self;
WebPAnimDecoderReset(decp->dec);
Py_RETURN_NONE;
@ -456,8 +487,7 @@ static struct PyMethodDef _anim_encoder_methods[] = {
// WebPAnimDecoder type definition
static PyTypeObject WebPAnimEncoder_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"WebPAnimEncoder", /*tp_name */
PyVarObject_HEAD_INIT(NULL, 0) "WebPAnimEncoder", /*tp_name */
sizeof(WebPAnimEncoderObject), /*tp_size */
0, /*tp_itemsize */
/* methods */
@ -500,8 +530,7 @@ static struct PyMethodDef _anim_decoder_methods[] = {
// WebPAnimDecoder type definition
static PyTypeObject WebPAnimDecoder_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"WebPAnimDecoder", /*tp_name */
PyVarObject_HEAD_INIT(NULL, 0) "WebPAnimDecoder", /*tp_name */
sizeof(WebPAnimDecoderObject), /*tp_size */
0, /*tp_itemsize */
/* methods */
@ -539,8 +568,8 @@ static PyTypeObject WebPAnimDecoder_Type = {
/* Legacy WebP Support */
/* -------------------------------------------------------------------- */
PyObject* WebPEncode_wrapper(PyObject* self, PyObject* args)
{
PyObject *
WebPEncode_wrapper(PyObject *self, PyObject *args) {
int width;
int height;
int lossless;
@ -565,9 +594,23 @@ PyObject* WebPEncode_wrapper(PyObject* self, PyObject* args)
WebPMemoryWriter writer;
WebPPicture pic;
if (!PyArg_ParseTuple(args, "y#iiifss#is#s#",
(char**)&rgb, &size, &width, &height, &lossless, &quality_factor, &mode,
&icc_bytes, &icc_size, &method, &exif_bytes, &exif_size, &xmp_bytes, &xmp_size)) {
if (!PyArg_ParseTuple(
args,
"y#iiifss#is#s#",
(char **)&rgb,
&size,
&width,
&height,
&lossless,
&quality_factor,
&mode,
&icc_bytes,
&icc_size,
&method,
&exif_bytes,
&exif_size,
&xmp_bytes,
&xmp_size)) {
return NULL;
}
@ -702,7 +745,8 @@ PyObject* WebPEncode_wrapper(PyObject* self, PyObject* args)
ret_size = output_data.size;
if (ret_size > 0) {
PyObject *ret = PyBytes_FromStringAndSize((char*)output_data.bytes, ret_size);
PyObject *ret =
PyBytes_FromStringAndSize((char *)output_data.bytes, ret_size);
WebPDataClear(&output_data);
return ret;
}
@ -711,12 +755,13 @@ PyObject* WebPEncode_wrapper(PyObject* self, PyObject* args)
Py_RETURN_NONE;
}
PyObject* WebPDecode_wrapper(PyObject* self, PyObject* args)
{
PyObject *
WebPDecode_wrapper(PyObject *self, PyObject *args) {
PyBytesObject *webp_string;
const uint8_t *webp;
Py_ssize_t size;
PyObject *ret = Py_None, *bytes = NULL, *pymode = NULL, *icc_profile = NULL, *exif = NULL;
PyObject *ret = Py_None, *bytes = NULL, *pymode = NULL, *icc_profile = NULL,
*exif = NULL;
WebPDecoderConfig config;
VP8StatusCode vp8_status_code = VP8_STATUS_OK;
char *mode = "RGB";
@ -755,8 +800,7 @@ PyObject* WebPDecode_wrapper(PyObject* self, PyObject* args)
goto end;
}
if (WEBP_MUX_OK != WebPMuxGetFrame(mux, 1, &image))
{
if (WEBP_MUX_OK != WebPMuxGetFrame(mux, 1, &image)) {
WebPMuxDelete(mux);
goto end;
}
@ -767,11 +811,13 @@ PyObject* WebPDecode_wrapper(PyObject* self, PyObject* args)
vp8_status_code = WebPDecode(webp, size, &config);
if (WEBP_MUX_OK == WebPMuxGetChunk(mux, "ICCP", &icc_profile_data)) {
icc_profile = PyBytes_FromStringAndSize((const char*)icc_profile_data.bytes, icc_profile_data.size);
icc_profile = PyBytes_FromStringAndSize(
(const char *)icc_profile_data.bytes, icc_profile_data.size);
}
if (WEBP_MUX_OK == WebPMuxGetChunk(mux, "EXIF", &exif_data)) {
exif = PyBytes_FromStringAndSize((const char*)exif_data.bytes, exif_data.size);
exif = PyBytes_FromStringAndSize(
(const char *)exif_data.bytes, exif_data.size);
}
WebPDataClear(&image.bitstream);
@ -785,18 +831,22 @@ PyObject* WebPDecode_wrapper(PyObject* self, PyObject* args)
}
if (config.output.colorspace < MODE_YUV) {
bytes = PyBytes_FromStringAndSize((char*)config.output.u.RGBA.rgba,
config.output.u.RGBA.size);
bytes = PyBytes_FromStringAndSize(
(char *)config.output.u.RGBA.rgba, config.output.u.RGBA.size);
} else {
// Skipping YUV for now. Need Test Images.
// UNDONE -- unclear if we'll ever get here if we set mode_rgb*
bytes = PyBytes_FromStringAndSize((char*)config.output.u.YUVA.y,
config.output.u.YUVA.y_size);
bytes = PyBytes_FromStringAndSize(
(char *)config.output.u.YUVA.y, config.output.u.YUVA.y_size);
}
pymode = PyUnicode_FromString(mode);
ret = Py_BuildValue("SiiSSS", bytes, config.output.width,
config.output.height, pymode,
ret = Py_BuildValue(
"SiiSSS",
bytes,
config.output.width,
config.output.height,
pymode,
NULL == icc_profile ? Py_None : icc_profile,
NULL == exif ? Py_None : exif);
@ -817,17 +867,22 @@ end:
// Return the decoder's version number, packed in hexadecimal using 8bits for
// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
PyObject* WebPDecoderVersion_wrapper() {
PyObject *
WebPDecoderVersion_wrapper() {
return Py_BuildValue("i", WebPGetDecoderVersion());
}
// Version as string
const char *
WebPDecoderVersion_str(void)
{
WebPDecoderVersion_str(void) {
static char version[20];
int version_number = WebPGetDecoderVersion();
sprintf(version, "%d.%d.%d", version_number >> 16, (version_number >> 8) % 0x100, version_number % 0x100);
sprintf(
version,
"%d.%d.%d",
version_number >> 16,
(version_number >> 8) % 0x100,
version_number % 0x100);
return version;
}
@ -835,11 +890,13 @@ WebPDecoderVersion_str(void)
* The version of webp that ships with (0.1.3) Ubuntu 12.04 doesn't handle alpha well.
* Files that are valid with 0.3 are reported as being invalid.
*/
int WebPDecoderBuggyAlpha(void) {
int
WebPDecoderBuggyAlpha(void) {
return WebPGetDecoderVersion() == 0x0103;
}
PyObject* WebPDecoderBuggyAlpha_wrapper() {
PyObject *
WebPDecoderBuggyAlpha_wrapper() {
return Py_BuildValue("i", WebPDecoderBuggyAlpha());
}
@ -847,8 +904,7 @@ PyObject* WebPDecoderBuggyAlpha_wrapper() {
/* Module Setup */
/* -------------------------------------------------------------------- */
static PyMethodDef webpMethods[] =
{
static PyMethodDef webpMethods[] = {
#ifdef HAVE_WEBPANIM
{"WebPAnimDecoder", _anim_decoder_new, METH_VARARGS, "WebPAnimDecoder"},
{"WebPAnimEncoder", _anim_encoder_new, METH_VARARGS, "WebPAnimEncoder"},
@ -856,11 +912,14 @@ static PyMethodDef webpMethods[] =
{"WebPEncode", WebPEncode_wrapper, METH_VARARGS, "WebPEncode"},
{"WebPDecode", WebPDecode_wrapper, METH_VARARGS, "WebPDecode"},
{"WebPDecoderVersion", WebPDecoderVersion_wrapper, METH_NOARGS, "WebPVersion"},
{"WebPDecoderBuggyAlpha", WebPDecoderBuggyAlpha_wrapper, METH_NOARGS, "WebPDecoderBuggyAlpha"},
{NULL, NULL}
};
{"WebPDecoderBuggyAlpha",
WebPDecoderBuggyAlpha_wrapper,
METH_NOARGS,
"WebPDecoderBuggyAlpha"},
{NULL, NULL}};
void addMuxFlagToModule(PyObject* m) {
void
addMuxFlagToModule(PyObject *m) {
#ifdef HAVE_WEBPMUX
PyModule_AddObject(m, "HAVE_WEBPMUX", Py_True);
#else
@ -868,7 +927,8 @@ void addMuxFlagToModule(PyObject* m) {
#endif
}
void addAnimFlagToModule(PyObject* m) {
void
addAnimFlagToModule(PyObject *m) {
#ifdef HAVE_WEBPANIM
PyModule_AddObject(m, "HAVE_WEBPANIM", Py_True);
#else
@ -876,18 +936,21 @@ void addAnimFlagToModule(PyObject* m) {
#endif
}
void addTransparencyFlagToModule(PyObject* m) {
PyModule_AddObject(m, "HAVE_TRANSPARENCY",
PyBool_FromLong(!WebPDecoderBuggyAlpha()));
void
addTransparencyFlagToModule(PyObject *m) {
PyModule_AddObject(
m, "HAVE_TRANSPARENCY", PyBool_FromLong(!WebPDecoderBuggyAlpha()));
}
static int setup_module(PyObject* m) {
static int
setup_module(PyObject *m) {
PyObject *d = PyModule_GetDict(m);
addMuxFlagToModule(m);
addAnimFlagToModule(m);
addTransparencyFlagToModule(m);
PyDict_SetItemString(d, "webpdecoder_version", PyUnicode_FromString(WebPDecoderVersion_str()));
PyDict_SetItemString(
d, "webpdecoder_version", PyUnicode_FromString(WebPDecoderVersion_str()));
#ifdef HAVE_WEBPANIM
/* Ready object types */

137
src/decode.c
View File

@ -39,15 +39,13 @@
#include "libImaging/Bit.h"
#include "libImaging/Sgi.h"
/* -------------------------------------------------------------------- */
/* Common */
/* -------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
int (*decode)(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
PyObject_HEAD int (*decode)(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
int (*cleanup)(ImagingCodecState state);
struct ImagingCodecStateInstance state;
Imaging im;
@ -58,8 +56,7 @@ typedef struct {
static PyTypeObject ImagingDecoderType;
static ImagingDecoderObject *
PyImaging_DecoderNew(int contextsize)
{
PyImaging_DecoderNew(int contextsize) {
ImagingDecoderObject *decoder;
void *context;
@ -105,8 +102,7 @@ PyImaging_DecoderNew(int contextsize)
}
static void
_dealloc(ImagingDecoderObject* decoder)
{
_dealloc(ImagingDecoderObject *decoder) {
if (decoder->cleanup) {
decoder->cleanup(&decoder->state);
}
@ -118,8 +114,7 @@ _dealloc(ImagingDecoderObject* decoder)
}
static PyObject *
_decode(ImagingDecoderObject* decoder, PyObject* args)
{
_decode(ImagingDecoderObject *decoder, PyObject *args) {
UINT8 *buffer;
Py_ssize_t bufsize;
int status;
@ -143,8 +138,7 @@ _decode(ImagingDecoderObject* decoder, PyObject* args)
}
static PyObject *
_decode_cleanup(ImagingDecoderObject* decoder, PyObject* args)
{
_decode_cleanup(ImagingDecoderObject *decoder, PyObject *args) {
int status = 0;
if (decoder->cleanup) {
@ -154,13 +148,11 @@ _decode_cleanup(ImagingDecoderObject* decoder, PyObject* args)
return Py_BuildValue("i", status);
}
extern Imaging PyImaging_AsImaging(PyObject *op);
extern Imaging
PyImaging_AsImaging(PyObject *op);
static PyObject *
_setimage(ImagingDecoderObject* decoder, PyObject* args)
{
_setimage(ImagingDecoderObject *decoder, PyObject *args) {
PyObject *op;
Imaging im;
ImagingCodecState state;
@ -192,10 +184,8 @@ _setimage(ImagingDecoderObject* decoder, PyObject* args)
state->ysize = y1 - y0;
}
if (state->xsize <= 0 ||
state->xsize + state->xoff > (int) im->xsize ||
state->ysize <= 0 ||
state->ysize + state->yoff > (int) im->ysize) {
if (state->xsize <= 0 || state->xsize + state->xoff > (int)im->xsize ||
state->ysize <= 0 || state->ysize + state->yoff > (int)im->ysize) {
PyErr_SetString(PyExc_ValueError, "tile cannot extend outside image");
return NULL;
}
@ -226,8 +216,7 @@ _setimage(ImagingDecoderObject* decoder, PyObject* args)
}
static PyObject *
_setfd(ImagingDecoderObject* decoder, PyObject* args)
{
_setfd(ImagingDecoderObject *decoder, PyObject *args) {
PyObject *fd;
ImagingCodecState state;
@ -244,10 +233,8 @@ _setfd(ImagingDecoderObject* decoder, PyObject* args)
return Py_None;
}
static PyObject *
_get_pulls_fd(ImagingDecoderObject *decoder)
{
_get_pulls_fd(ImagingDecoderObject *decoder) {
return PyBool_FromLong(decoder->pulls_fd);
}
@ -260,15 +247,16 @@ static struct PyMethodDef methods[] = {
};
static struct PyGetSetDef getseters[] = {
{"pulls_fd", (getter)_get_pulls_fd, NULL,
{"pulls_fd",
(getter)_get_pulls_fd,
NULL,
"True if this decoder expects to pull from self.fd itself.",
NULL},
{NULL, NULL, NULL, NULL, NULL} /* sentinel */
};
static PyTypeObject ImagingDecoderType = {
PyVarObject_HEAD_INIT(NULL, 0)
"ImagingDecoder", /*tp_name*/
PyVarObject_HEAD_INIT(NULL, 0) "ImagingDecoder", /*tp_name*/
sizeof(ImagingDecoderObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
@ -303,9 +291,7 @@ static PyTypeObject ImagingDecoderType = {
/* -------------------------------------------------------------------- */
int
get_unpacker(ImagingDecoderObject* decoder, const char* mode,
const char* rawmode)
{
get_unpacker(ImagingDecoderObject *decoder, const char *mode, const char *rawmode) {
int bits;
ImagingShuffler unpack;
@ -322,14 +308,12 @@ get_unpacker(ImagingDecoderObject* decoder, const char* mode,
return 0;
}
/* -------------------------------------------------------------------- */
/* BIT (packed fields) */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_BitDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_BitDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -338,8 +322,7 @@ PyImaging_BitDecoderNew(PyObject* self, PyObject* args)
int fill = 0;
int sign = 0;
int ystep = 1;
if (!PyArg_ParseTuple(args, "s|iiiii", &mode, &bits, &pad, &fill,
&sign, &ystep)) {
if (!PyArg_ParseTuple(args, "s|iiiii", &mode, &bits, &pad, &fill, &sign, &ystep)) {
return NULL;
}
@ -365,14 +348,12 @@ PyImaging_BitDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* BCn: GPU block-compressed texture formats */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_BcnDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_BcnDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -389,12 +370,15 @@ PyImaging_BcnDecoderNew(PyObject* self, PyObject* args)
case 3: /* BC3: 565 color, 2-endpoint 8-bit interpolated alpha */
case 5: /* BC5: 2-channel 8-bit via 2 BC3 alpha blocks */
case 7: /* BC7: 4-channel 8-bit via everything */
actual = "RGBA"; break;
actual = "RGBA";
break;
case 4: /* BC4: 1-channel 8-bit via 1 BC3 alpha block */
actual = "L"; break;
actual = "L";
break;
case 6: /* BC6: 3-channel 16-bit float */
/* TODO: support 4-channel floating point images */
actual = "RGBAF"; break;
actual = "RGBAF";
break;
default:
PyErr_SetString(PyExc_ValueError, "block compression type unknown");
return NULL;
@ -417,14 +401,12 @@ PyImaging_BcnDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* FLI */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_FliDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_FliDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
decoder = PyImaging_DecoderNew(0);
@ -437,14 +419,12 @@ PyImaging_FliDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* GIF */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_GifDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_GifDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -472,14 +452,12 @@ PyImaging_GifDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* HEX */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_HexDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_HexDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -502,7 +480,6 @@ PyImaging_HexDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* LibTiff */
/* -------------------------------------------------------------------- */
@ -514,8 +491,7 @@ PyImaging_HexDecoderNew(PyObject* self, PyObject* args)
#include <string.h>
PyObject *
PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_LibTiffDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
char *rawmode;
@ -551,14 +527,12 @@ PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args)
#endif
/* -------------------------------------------------------------------- */
/* PackBits */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_PackbitsDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_PackbitsDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -581,14 +555,12 @@ PyImaging_PackbitsDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* PCD */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_PcdDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_PcdDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
decoder = PyImaging_DecoderNew(0);
@ -606,14 +578,12 @@ PyImaging_PcdDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* PCX */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_PcxDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_PcxDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -639,14 +609,12 @@ PyImaging_PcxDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* RAW */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_RawDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_RawDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -675,14 +643,12 @@ PyImaging_RawDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* SGI RLE */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_SgiRleDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_SgiRleDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -711,14 +677,12 @@ PyImaging_SgiRleDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* SUN RLE */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_SunRleDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_SunRleDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -741,14 +705,12 @@ PyImaging_SunRleDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* TGA RLE */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_TgaRleDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_TgaRleDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -776,14 +738,12 @@ PyImaging_TgaRleDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* XBM */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_XbmDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_XbmDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
decoder = PyImaging_DecoderNew(0);
@ -800,7 +760,6 @@ PyImaging_XbmDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
/* -------------------------------------------------------------------- */
/* ZIP */
/* -------------------------------------------------------------------- */
@ -810,8 +769,7 @@ PyImaging_XbmDecoderNew(PyObject* self, PyObject* args)
#include "libImaging/ZipCodecs.h"
PyObject *
PyImaging_ZipDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_ZipDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -839,7 +797,6 @@ PyImaging_ZipDecoderNew(PyObject* self, PyObject* args)
}
#endif
/* -------------------------------------------------------------------- */
/* JPEG */
/* -------------------------------------------------------------------- */
@ -862,8 +819,7 @@ PyImaging_ZipDecoderNew(PyObject* self, PyObject* args)
#include "libImaging/Jpeg.h"
PyObject *
PyImaging_JpegDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
char *mode;
@ -872,8 +828,7 @@ PyImaging_JpegDecoderNew(PyObject* self, PyObject* args)
int scale = 1;
int draft = 0;
if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode,
&scale, &draft)) {
if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode, &scale, &draft)) {
return NULL;
}
@ -919,8 +874,7 @@ PyImaging_JpegDecoderNew(PyObject* self, PyObject* args)
#include "libImaging/Jpeg2K.h"
PyObject *
PyImaging_Jpeg2KDecoderNew(PyObject* self, PyObject* args)
{
PyImaging_Jpeg2KDecoderNew(PyObject *self, PyObject *args) {
ImagingDecoderObject *decoder;
JPEG2KDECODESTATE *context;
@ -932,8 +886,8 @@ PyImaging_Jpeg2KDecoderNew(PyObject* self, PyObject* args)
int fd = -1;
PY_LONG_LONG length = -1;
if (!PyArg_ParseTuple(args, "ss|iiiL", &mode, &format,
&reduce, &layers, &fd, &length)) {
if (!PyArg_ParseTuple(
args, "ss|iiiL", &mode, &format, &reduce, &layers, &fd, &length)) {
return NULL;
}
@ -967,4 +921,3 @@ PyImaging_Jpeg2KDecoderNew(PyObject* self, PyObject* args)
return (PyObject *)decoder;
}
#endif /* HAVE_OPENJPEG */

252
src/display.c
View File

@ -41,15 +41,13 @@
#endif
typedef struct {
PyObject_HEAD
ImagingDIB dib;
PyObject_HEAD ImagingDIB dib;
} ImagingDisplayObject;
static PyTypeObject ImagingDisplayType;
static ImagingDisplayObject *
_new(const char* mode, int xsize, int ysize)
{
_new(const char *mode, int xsize, int ysize) {
ImagingDisplayObject *display;
if (PyType_Ready(&ImagingDisplayType) < 0) {
@ -71,8 +69,7 @@ _new(const char* mode, int xsize, int ysize)
}
static void
_delete(ImagingDisplayObject* display)
{
_delete(ImagingDisplayObject *display) {
if (display->dib) {
ImagingDeleteDIB(display->dib);
}
@ -80,8 +77,7 @@ _delete(ImagingDisplayObject* display)
}
static PyObject *
_expose(ImagingDisplayObject* display, PyObject* args)
{
_expose(ImagingDisplayObject *display, PyObject *args) {
HDC hdc;
if (!PyArg_ParseTuple(args, F_HANDLE, &hdc)) {
return NULL;
@ -94,14 +90,22 @@ _expose(ImagingDisplayObject* display, PyObject* args)
}
static PyObject *
_draw(ImagingDisplayObject* display, PyObject* args)
{
_draw(ImagingDisplayObject *display, PyObject *args) {
HDC hdc;
int dst[4];
int src[4];
if (!PyArg_ParseTuple(args, F_HANDLE "(iiii)(iiii)", &hdc,
dst+0, dst+1, dst+2, dst+3,
src+0, src+1, src+2, src+3)) {
if (!PyArg_ParseTuple(
args,
F_HANDLE "(iiii)(iiii)",
&hdc,
dst + 0,
dst + 1,
dst + 2,
dst + 3,
src + 0,
src + 1,
src + 2,
src + 3)) {
return NULL;
}
@ -111,11 +115,11 @@ _draw(ImagingDisplayObject* display, PyObject* args)
return Py_None;
}
extern Imaging PyImaging_AsImaging(PyObject *op);
extern Imaging
PyImaging_AsImaging(PyObject *op);
static PyObject *
_paste(ImagingDisplayObject* display, PyObject* args)
{
_paste(ImagingDisplayObject *display, PyObject *args) {
Imaging im;
PyObject *op;
@ -143,8 +147,7 @@ _paste(ImagingDisplayObject* display, PyObject* args)
}
static PyObject *
_query_palette(ImagingDisplayObject* display, PyObject* args)
{
_query_palette(ImagingDisplayObject *display, PyObject *args) {
HDC hdc;
int status;
@ -158,8 +161,7 @@ _query_palette(ImagingDisplayObject* display, PyObject* args)
}
static PyObject *
_getdc(ImagingDisplayObject* display, PyObject* args)
{
_getdc(ImagingDisplayObject *display, PyObject *args) {
HWND window;
HDC dc;
@ -177,8 +179,7 @@ _getdc(ImagingDisplayObject* display, PyObject* args)
}
static PyObject *
_releasedc(ImagingDisplayObject* display, PyObject* args)
{
_releasedc(ImagingDisplayObject *display, PyObject *args) {
HWND window;
HDC dc;
@ -193,8 +194,7 @@ _releasedc(ImagingDisplayObject* display, PyObject* args)
}
static PyObject *
_frombytes(ImagingDisplayObject* display, PyObject* args)
{
_frombytes(ImagingDisplayObject *display, PyObject *args) {
char *ptr;
Py_ssize_t bytes;
@ -214,15 +214,13 @@ _frombytes(ImagingDisplayObject* display, PyObject* args)
}
static PyObject *
_tobytes(ImagingDisplayObject* display, PyObject* args)
{
_tobytes(ImagingDisplayObject *display, PyObject *args) {
if (!PyArg_ParseTuple(args, ":tobytes")) {
return NULL;
}
return PyBytes_FromStringAndSize(
display->dib->bits, display->dib->ysize * display->dib->linesize
);
display->dib->bits, display->dib->ysize * display->dib->linesize);
}
static struct PyMethodDef methods[] = {
@ -238,26 +236,20 @@ static struct PyMethodDef methods[] = {
};
static PyObject *
_getattr_mode(ImagingDisplayObject* self, void* closure)
{
_getattr_mode(ImagingDisplayObject *self, void *closure) {
return Py_BuildValue("s", self->dib->mode);
}
static PyObject *
_getattr_size(ImagingDisplayObject* self, void* closure)
{
_getattr_size(ImagingDisplayObject *self, void *closure) {
return Py_BuildValue("ii", self->dib->xsize, self->dib->ysize);
}
static struct PyGetSetDef getsetters[] = {
{ "mode", (getter) _getattr_mode },
{ "size", (getter) _getattr_size },
{ NULL }
};
{"mode", (getter)_getattr_mode}, {"size", (getter)_getattr_size}, {NULL}};
static PyTypeObject ImagingDisplayType = {
PyVarObject_HEAD_INIT(NULL, 0)
"ImagingDisplay", /*tp_name*/
PyVarObject_HEAD_INIT(NULL, 0) "ImagingDisplay", /*tp_name*/
sizeof(ImagingDisplayObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
@ -290,8 +282,7 @@ static PyTypeObject ImagingDisplayType = {
};
PyObject *
PyImaging_DisplayWin32(PyObject* self, PyObject* args)
{
PyImaging_DisplayWin32(PyObject *self, PyObject *args) {
ImagingDisplayObject *display;
char *mode;
int xsize, ysize;
@ -309,8 +300,7 @@ PyImaging_DisplayWin32(PyObject* self, PyObject* args)
}
PyObject *
PyImaging_DisplayModeWin32(PyObject* self, PyObject* args)
{
PyImaging_DisplayModeWin32(PyObject *self, PyObject *args) {
char *mode;
int size[2];
@ -325,8 +315,7 @@ PyImaging_DisplayModeWin32(PyObject* self, PyObject* args)
typedef HANDLE(__stdcall *Func_SetThreadDpiAwarenessContext)(HANDLE);
PyObject *
PyImaging_GrabScreenWin32(PyObject* self, PyObject* args)
{
PyImaging_GrabScreenWin32(PyObject *self, PyObject *args) {
int x = 0, y = 0, width, height;
int includeLayeredWindows = 0, all_screens = 0;
HBITMAP bitmap;
@ -352,8 +341,8 @@ PyImaging_GrabScreenWin32(PyObject* self, PyObject* args)
// loaded dynamically to avoid link errors
user32 = LoadLibraryA("User32.dll");
SetThreadDpiAwarenessContext_function =
(Func_SetThreadDpiAwarenessContext)
GetProcAddress(user32, "SetThreadDpiAwarenessContext");
(Func_SetThreadDpiAwarenessContext)GetProcAddress(
user32, "SetThreadDpiAwarenessContext");
if (SetThreadDpiAwarenessContext_function != NULL) {
// DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = ((DPI_CONTEXT_HANDLE)-3)
dpiAwareness = SetThreadDpiAwarenessContext_function((HANDLE)-3);
@ -406,8 +395,14 @@ PyImaging_GrabScreenWin32(PyObject* self, PyObject* args)
core.bcHeight = height;
core.bcPlanes = 1;
core.bcBitCount = 24;
if (!GetDIBits(screen_copy, bitmap, 0, height, PyBytes_AS_STRING(buffer),
(BITMAPINFO*) &core, DIB_RGB_COLORS)) {
if (!GetDIBits(
screen_copy,
bitmap,
0,
height,
PyBytes_AS_STRING(buffer),
(BITMAPINFO *)&core,
DIB_RGB_COLORS)) {
goto error;
}
@ -426,8 +421,8 @@ error:
return NULL;
}
static BOOL CALLBACK list_windows_callback(HWND hwnd, LPARAM lParam)
{
static BOOL CALLBACK
list_windows_callback(HWND hwnd, LPARAM lParam) {
PyObject *window_list = (PyObject *)lParam;
PyObject *item;
PyObject *title;
@ -454,10 +449,17 @@ static BOOL CALLBACK list_windows_callback(HWND hwnd, LPARAM lParam)
GetWindowRect(hwnd, &outer);
item = Py_BuildValue(
F_HANDLE "N(iiii)(iiii)", hwnd, title,
inner.left, inner.top, inner.right, inner.bottom,
outer.left, outer.top, outer.right, outer.bottom
);
F_HANDLE "N(iiii)(iiii)",
hwnd,
title,
inner.left,
inner.top,
inner.right,
inner.bottom,
outer.left,
outer.top,
outer.right,
outer.bottom);
if (!item) {
return 0;
}
@ -474,8 +476,7 @@ static BOOL CALLBACK list_windows_callback(HWND hwnd, LPARAM lParam)
}
PyObject *
PyImaging_ListWindowsWin32(PyObject* self, PyObject* args)
{
PyImaging_ListWindowsWin32(PyObject *self, PyObject *args) {
PyObject *window_list;
window_list = PyList_New(0);
@ -497,8 +498,7 @@ PyImaging_ListWindowsWin32(PyObject* self, PyObject* args)
/* Windows clipboard grabber */
PyObject *
PyImaging_GrabClipboardWin32(PyObject* self, PyObject* args)
{
PyImaging_GrabClipboardWin32(PyObject *self, PyObject *args) {
int clip;
HANDLE handle = NULL;
int size;
@ -551,8 +551,7 @@ PyImaging_GrabClipboardWin32(PyObject* self, PyObject* args)
static int mainloop = 0;
static void
callback_error(const char* handler)
{
callback_error(const char *handler) {
PyObject *sys_stderr;
sys_stderr = PySys_GetObject("stderr");
@ -568,8 +567,7 @@ callback_error(const char* handler)
}
static LRESULT CALLBACK
windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
{
windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam) {
PAINTSTRUCT ps;
PyObject *callback = NULL;
PyObject *result;
@ -591,8 +589,8 @@ windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
case WM_SIZE:
callback = (PyObject *)GetWindowLongPtr(wnd, 0);
if (callback) {
threadstate = (PyThreadState*)
GetWindowLongPtr(wnd, sizeof(PyObject*));
threadstate =
(PyThreadState *)GetWindowLongPtr(wnd, sizeof(PyObject *));
current_threadstate = PyThreadState_Swap(NULL);
PyEval_RestoreThread(threadstate);
} else {
@ -602,7 +600,6 @@ windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
/* process message */
switch (message) {
case WM_PAINT:
/* redraw (part of) window. this generates a WCK-style
damage/clear/repair cascade */
@ -611,10 +608,13 @@ windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
GetWindowRect(wnd, &rect); /* in screen coordinates */
result = PyObject_CallFunction(
callback, "siiii", "damage",
ps.rcPaint.left, ps.rcPaint.top,
ps.rcPaint.right, ps.rcPaint.bottom
);
callback,
"siiii",
"damage",
ps.rcPaint.left,
ps.rcPaint.top,
ps.rcPaint.right,
ps.rcPaint.bottom);
if (result) {
Py_DECREF(result);
} else {
@ -622,9 +622,14 @@ windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
}
result = PyObject_CallFunction(
callback, "s" F_HANDLE "iiii", "clear", dc,
0, 0, rect.right-rect.left, rect.bottom-rect.top
);
callback,
"s" F_HANDLE "iiii",
"clear",
dc,
0,
0,
rect.right - rect.left,
rect.bottom - rect.top);
if (result) {
Py_DECREF(result);
} else {
@ -632,9 +637,14 @@ windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
}
result = PyObject_CallFunction(
callback, "s" F_HANDLE "iiii", "repair", dc,
0, 0, rect.right-rect.left, rect.bottom-rect.top
);
callback,
"s" F_HANDLE "iiii",
"repair",
dc,
0,
0,
rect.right - rect.left,
rect.bottom - rect.top);
if (result) {
Py_DECREF(result);
} else {
@ -648,8 +658,7 @@ windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
case WM_SIZE:
/* resize window */
result = PyObject_CallFunction(
callback, "sii", "resize", LOWORD(lParam), HIWORD(lParam)
);
callback, "sii", "resize", LOWORD(lParam), HIWORD(lParam));
if (result) {
InvalidateRect(wnd, NULL, 1);
Py_DECREF(result);
@ -683,8 +692,7 @@ windowCallback(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
}
PyObject *
PyImaging_CreateWindowWin32(PyObject* self, PyObject* args)
{
PyImaging_CreateWindowWin32(PyObject *self, PyObject *args) {
HWND wnd;
WNDCLASS windowClass;
@ -718,11 +726,18 @@ PyImaging_CreateWindowWin32(PyObject* self, PyObject* args)
RegisterClass(&windowClass); /* FIXME: check return status */
wnd = CreateWindowEx(
0, windowClass.lpszClassName, title,
0,
windowClass.lpszClassName,
title,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, width, height,
HWND_DESKTOP, NULL, NULL, NULL
);
CW_USEDEFAULT,
CW_USEDEFAULT,
width,
height,
HWND_DESKTOP,
NULL,
NULL,
NULL);
if (!wnd) {
PyErr_SetString(PyExc_OSError, "failed to create window");
@ -734,8 +749,7 @@ PyImaging_CreateWindowWin32(PyObject* self, PyObject* args)
SetWindowLongPtr(wnd, 0, (LONG_PTR)callback);
SetWindowLongPtr(wnd, sizeof(callback), (LONG_PTR)PyThreadState_Get());
Py_BEGIN_ALLOW_THREADS
ShowWindow(wnd, SW_SHOWNORMAL);
Py_BEGIN_ALLOW_THREADS ShowWindow(wnd, SW_SHOWNORMAL);
SetForegroundWindow(wnd); /* to make sure it's visible */
Py_END_ALLOW_THREADS
@ -743,12 +757,10 @@ PyImaging_CreateWindowWin32(PyObject* self, PyObject* args)
}
PyObject *
PyImaging_EventLoopWin32(PyObject* self, PyObject* args)
{
PyImaging_EventLoopWin32(PyObject *self, PyObject *args) {
MSG msg;
Py_BEGIN_ALLOW_THREADS
while (mainloop && GetMessage(&msg, NULL, 0, 0)) {
Py_BEGIN_ALLOW_THREADS while (mainloop && GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
@ -764,8 +776,7 @@ PyImaging_EventLoopWin32(PyObject* self, PyObject* args)
#define GET32(p, o) ((DWORD *)(p + o))[0]
PyObject *
PyImaging_DrawWmf(PyObject* self, PyObject* args)
{
PyImaging_DrawWmf(PyObject *self, PyObject *args) {
HBITMAP bitmap;
HENHMETAFILE meta;
BITMAPCOREHEADER core;
@ -778,29 +789,33 @@ PyImaging_DrawWmf(PyObject* self, PyObject* args)
Py_ssize_t datasize;
int width, height;
int x0, y0, x1, y1;
if (!PyArg_ParseTuple(args, "y#(ii)(iiii):_load", &data, &datasize,
&width, &height, &x0, &x1, &y0, &y1)) {
if (!PyArg_ParseTuple(
args,
"y#(ii)(iiii):_load",
&data,
&datasize,
&width,
&height,
&x0,
&x1,
&y0,
&y1)) {
return NULL;
}
/* step 1: copy metafile contents into METAFILE object */
if (datasize > 22 && GET32(data, 0) == 0x9ac6cdd7) {
/* placeable windows metafile (22-byte aldus header) */
meta = SetWinMetaFileBits(datasize - 22, data + 22, NULL, NULL);
} else if (datasize > 80 && GET32(data, 0) == 1 &&
GET32(data, 40) == 0x464d4520) {
} else if (datasize > 80 && GET32(data, 0) == 1 && GET32(data, 40) == 0x464d4520) {
/* enhanced metafile */
meta = SetEnhMetaFileBits(datasize, data);
} else {
/* unknown meta format */
meta = NULL;
}
if (!meta) {
@ -818,9 +833,7 @@ PyImaging_DrawWmf(PyObject* self, PyObject* args)
dc = CreateCompatibleDC(NULL);
bitmap = CreateDIBSection(
dc, (BITMAPINFO*) &core, DIB_RGB_COLORS, &ptr, NULL, 0
);
bitmap = CreateDIBSection(dc, (BITMAPINFO *)&core, DIB_RGB_COLORS, &ptr, NULL, 0);
if (!bitmap) {
PyErr_SetString(PyExc_OSError, "cannot create bitmap");
@ -876,8 +889,7 @@ error:
/* X11 screen grabber */
PyObject *
PyImaging_GrabScreenX11(PyObject* self, PyObject* args)
{
PyImaging_GrabScreenX11(PyObject *self, PyObject *args) {
int width, height;
char *display_name;
xcb_connection_t *connection;
@ -896,7 +908,10 @@ PyImaging_GrabScreenX11(PyObject* self, PyObject* args)
connection = xcb_connect(display_name, &screen_number);
if (xcb_connection_has_error(connection)) {
PyErr_Format(PyExc_OSError, "X connection failed: error %i", xcb_connection_has_error(connection));
PyErr_Format(
PyExc_OSError,
"X connection failed: error %i",
xcb_connection_has_error(connection));
xcb_disconnect(connection);
return NULL;
}
@ -920,13 +935,26 @@ PyImaging_GrabScreenX11(PyObject* self, PyObject* args)
/* get image data */
reply = xcb_get_image_reply(connection,
xcb_get_image(connection, XCB_IMAGE_FORMAT_Z_PIXMAP, screen->root,
0, 0, width, height, 0x00ffffff),
reply = xcb_get_image_reply(
connection,
xcb_get_image(
connection,
XCB_IMAGE_FORMAT_Z_PIXMAP,
screen->root,
0,
0,
width,
height,
0x00ffffff),
&error);
if (reply == NULL) {
PyErr_Format(PyExc_OSError, "X get_image failed: error %i (%i, %i, %i)",
error->error_code, error->major_code, error->minor_code, error->resource_id);
PyErr_Format(
PyExc_OSError,
"X get_image failed: error %i (%i, %i, %i)",
error->error_code,
error->major_code,
error->minor_code,
error->resource_id);
free(error);
xcb_disconnect(connection);
return NULL;
@ -935,8 +963,8 @@ PyImaging_GrabScreenX11(PyObject* self, PyObject* args)
/* store data in Python buffer */
if (reply->depth == 24) {
buffer = PyBytes_FromStringAndSize((char*)xcb_get_image_data(reply),
xcb_get_image_data_length(reply));
buffer = PyBytes_FromStringAndSize(
(char *)xcb_get_image_data(reply), xcb_get_image_data_length(reply));
} else {
PyErr_Format(PyExc_OSError, "unsupported bit depth: %i", reply->depth);
}

311
src/encode.c
View File

@ -37,9 +37,8 @@
/* -------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
int (*encode)(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
PyObject_HEAD int (*encode)(
Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
int (*cleanup)(ImagingCodecState state);
struct ImagingCodecStateInstance state;
Imaging im;
@ -50,8 +49,7 @@ typedef struct {
static PyTypeObject ImagingEncoderType;
static ImagingEncoderObject *
PyImaging_EncoderNew(int contextsize)
{
PyImaging_EncoderNew(int contextsize) {
ImagingEncoderObject *encoder;
void *context;
@ -94,8 +92,7 @@ PyImaging_EncoderNew(int contextsize)
}
static void
_dealloc(ImagingEncoderObject* encoder)
{
_dealloc(ImagingEncoderObject *encoder) {
if (encoder->cleanup) {
encoder->cleanup(&encoder->state);
}
@ -107,8 +104,7 @@ _dealloc(ImagingEncoderObject* encoder)
}
static PyObject *
_encode_cleanup(ImagingEncoderObject* encoder, PyObject* args)
{
_encode_cleanup(ImagingEncoderObject *encoder, PyObject *args) {
int status = 0;
if (encoder->cleanup) {
@ -119,8 +115,7 @@ _encode_cleanup(ImagingEncoderObject* encoder, PyObject* args)
}
static PyObject *
_encode(ImagingEncoderObject* encoder, PyObject* args)
{
_encode(ImagingEncoderObject *encoder, PyObject *args) {
PyObject *buf;
PyObject *result;
int status;
@ -138,8 +133,8 @@ _encode(ImagingEncoderObject* encoder, PyObject* args)
return NULL;
}
status = encoder->encode(encoder->im, &encoder->state,
(UINT8*) PyBytes_AsString(buf), bufsize);
status = encoder->encode(
encoder->im, &encoder->state, (UINT8 *)PyBytes_AsString(buf), bufsize);
/* adjust string length to avoid slicing in encoder */
if (_PyBytes_Resize(&buf, (status > 0) ? status : 0) < 0) {
@ -154,20 +149,18 @@ _encode(ImagingEncoderObject* encoder, PyObject* args)
}
static PyObject *
_encode_to_pyfd(ImagingEncoderObject* encoder, PyObject* args)
{
_encode_to_pyfd(ImagingEncoderObject *encoder, PyObject *args) {
PyObject *result;
int status;
if (!encoder->pushes_fd) {
// UNDONE, appropriate errcode???
result = Py_BuildValue("ii", 0, IMAGING_CODEC_CONFIG);;
result = Py_BuildValue("ii", 0, IMAGING_CODEC_CONFIG);
;
return result;
}
status = encoder->encode(encoder->im, &encoder->state,
(UINT8*) NULL, 0);
status = encoder->encode(encoder->im, &encoder->state, (UINT8 *)NULL, 0);
result = Py_BuildValue("ii", status, encoder->state.errcode);
@ -175,8 +168,7 @@ _encode_to_pyfd(ImagingEncoderObject* encoder, PyObject* args)
}
static PyObject *
_encode_to_file(ImagingEncoderObject* encoder, PyObject* args)
{
_encode_to_file(ImagingEncoderObject *encoder, PyObject *args) {
UINT8 *buf;
int status;
ImagingSectionCookie cookie;
@ -200,7 +192,6 @@ _encode_to_file(ImagingEncoderObject* encoder, PyObject* args)
ImagingSectionEnter(&cookie);
do {
/* This replaces the inner loop in the ImageFile _save
function. */
@ -223,11 +214,11 @@ _encode_to_file(ImagingEncoderObject* encoder, PyObject* args)
return Py_BuildValue("i", encoder->state.errcode);
}
extern Imaging PyImaging_AsImaging(PyObject *op);
extern Imaging
PyImaging_AsImaging(PyObject *op);
static PyObject *
_setimage(ImagingEncoderObject* encoder, PyObject* args)
{
_setimage(ImagingEncoderObject *encoder, PyObject *args) {
PyObject *op;
Imaging im;
ImagingCodecState state;
@ -260,10 +251,8 @@ _setimage(ImagingEncoderObject* encoder, PyObject* args)
state->ysize = y1 - y0;
}
if (state->xsize <= 0 ||
state->xsize + state->xoff > im->xsize ||
state->ysize <= 0 ||
state->ysize + state->yoff > im->ysize) {
if (state->xsize <= 0 || state->xsize + state->xoff > im->xsize ||
state->ysize <= 0 || state->ysize + state->yoff > im->ysize) {
PyErr_SetString(PyExc_SystemError, "tile cannot extend outside image");
return NULL;
}
@ -292,8 +281,7 @@ _setimage(ImagingEncoderObject* encoder, PyObject* args)
}
static PyObject *
_setfd(ImagingEncoderObject* encoder, PyObject* args)
{
_setfd(ImagingEncoderObject *encoder, PyObject *args) {
PyObject *fd;
ImagingCodecState state;
@ -311,8 +299,7 @@ _setfd(ImagingEncoderObject* encoder, PyObject* args)
}
static PyObject *
_get_pushes_fd(ImagingEncoderObject *encoder)
{
_get_pushes_fd(ImagingEncoderObject *encoder) {
return PyBool_FromLong(encoder->pushes_fd);
}
@ -327,15 +314,16 @@ static struct PyMethodDef methods[] = {
};
static struct PyGetSetDef getseters[] = {
{"pushes_fd", (getter)_get_pushes_fd, NULL,
{"pushes_fd",
(getter)_get_pushes_fd,
NULL,
"True if this decoder expects to push directly to self.fd",
NULL},
{NULL, NULL, NULL, NULL, NULL} /* sentinel */
};
static PyTypeObject ImagingEncoderType = {
PyVarObject_HEAD_INIT(NULL, 0)
"ImagingEncoder", /*tp_name*/
PyVarObject_HEAD_INIT(NULL, 0) "ImagingEncoder", /*tp_name*/
sizeof(ImagingEncoderObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
@ -370,9 +358,7 @@ static PyTypeObject ImagingEncoderType = {
/* -------------------------------------------------------------------- */
int
get_packer(ImagingEncoderObject* encoder, const char* mode,
const char* rawmode)
{
get_packer(ImagingEncoderObject *encoder, const char *mode, const char *rawmode) {
int bits;
ImagingShuffler pack;
@ -389,14 +375,12 @@ get_packer(ImagingEncoderObject* encoder, const char* mode,
return 0;
}
/* -------------------------------------------------------------------- */
/* EPS */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_EpsEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_EpsEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
encoder = PyImaging_EncoderNew(0);
@ -409,14 +393,12 @@ PyImaging_EpsEncoderNew(PyObject* self, PyObject* args)
return (PyObject *)encoder;
}
/* -------------------------------------------------------------------- */
/* GIF */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_GifEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_GifEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
char *mode;
@ -444,14 +426,12 @@ PyImaging_GifEncoderNew(PyObject* self, PyObject* args)
return (PyObject *)encoder;
}
/* -------------------------------------------------------------------- */
/* PCX */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_PcxEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
char *mode;
@ -476,14 +456,12 @@ PyImaging_PcxEncoderNew(PyObject* self, PyObject* args)
return (PyObject *)encoder;
}
/* -------------------------------------------------------------------- */
/* RAW */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_RawEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_RawEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
char *mode;
@ -512,14 +490,12 @@ PyImaging_RawEncoderNew(PyObject* self, PyObject* args)
return (PyObject *)encoder;
}
/* -------------------------------------------------------------------- */
/* TGA */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_TgaRleEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
char *mode;
@ -546,15 +522,12 @@ PyImaging_TgaRleEncoderNew(PyObject* self, PyObject* args)
return (PyObject *)encoder;
}
/* -------------------------------------------------------------------- */
/* XBM */
/* -------------------------------------------------------------------- */
PyObject *
PyImaging_XbmEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_XbmEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
encoder = PyImaging_EncoderNew(0);
@ -571,7 +544,6 @@ PyImaging_XbmEncoderNew(PyObject* self, PyObject* args)
return (PyObject *)encoder;
}
/* -------------------------------------------------------------------- */
/* ZIP */
/* -------------------------------------------------------------------- */
@ -581,8 +553,7 @@ PyImaging_XbmEncoderNew(PyObject* self, PyObject* args)
#include "libImaging/ZipCodecs.h"
PyObject *
PyImaging_ZipEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
char *mode;
@ -592,10 +563,16 @@ PyImaging_ZipEncoderNew(PyObject* self, PyObject* args)
Py_ssize_t compress_type = -1;
char *dictionary = NULL;
Py_ssize_t dictionary_size = 0;
if (!PyArg_ParseTuple(args, "ss|nnny#", &mode, &rawmode,
if (!PyArg_ParseTuple(
args,
"ss|nnny#",
&mode,
&rawmode,
&optimize,
&compress_level, &compress_type,
&dictionary, &dictionary_size)) {
&compress_level,
&compress_type,
&dictionary,
&dictionary_size)) {
return NULL;
}
@ -641,7 +618,6 @@ PyImaging_ZipEncoderNew(PyObject* self, PyObject* args)
}
#endif
/* -------------------------------------------------------------------- */
/* LibTiff */
/* -------------------------------------------------------------------- */
@ -653,8 +629,7 @@ PyImaging_ZipEncoderNew(PyObject* self, PyObject* args)
#include <string.h>
PyObject *
PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
char *mode;
@ -669,16 +644,24 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
int key_int, status, is_core_tag, is_var_length, num_core_tags, i;
TIFFDataType type = TIFF_NOTYPE;
// This list also exists in TiffTags.py
const int core_tags[] = {
256, 257, 258, 259, 262, 263, 266, 269, 274, 277, 278, 280, 281, 340,
341, 282, 283, 284, 286, 287, 296, 297, 320, 321, 338, 32995, 32998, 32996,
339, 32997, 330, 531, 530, 65537
};
const int core_tags[] = {256, 257, 258, 259, 262, 263, 266, 269, 274,
277, 278, 280, 281, 340, 341, 282, 283, 284,
286, 287, 296, 297, 320, 321, 338, 32995, 32998,
32996, 339, 32997, 330, 531, 530, 65537};
Py_ssize_t tags_size;
PyObject *item;
if (! PyArg_ParseTuple(args, "sssnsOO", &mode, &rawmode, &compname, &fp, &filename, &tags, &types)) {
if (!PyArg_ParseTuple(
args,
"sssnsOO",
&mode,
&rawmode,
&compname,
&fp,
&filename,
&tags,
&types)) {
return NULL;
}
@ -748,7 +731,6 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
}
}
if (type == TIFF_NOTYPE) {
// Autodetect type. Types should not be changed for backwards
// compatibility.
@ -787,15 +769,18 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
if (type == TIFF_BYTE) {
is_var_length = 1;
}
if (ImagingLibTiffMergeFieldInfo(&encoder->state, type, key_int, is_var_length)) {
if (ImagingLibTiffMergeFieldInfo(
&encoder->state, type, key_int, is_var_length)) {
continue;
}
}
if (type == TIFF_BYTE || type == TIFF_UNDEFINED) {
status = ImagingLibTiffSetField(&encoder->state,
status = ImagingLibTiffSetField(
&encoder->state,
(ttag_t)key_int,
PyBytes_Size(value), PyBytes_AsString(value));
PyBytes_Size(value),
PyBytes_AsString(value));
} else if (is_var_length) {
Py_ssize_t len, i;
TRACE(("Setting from Tuple: %d \n", key_int));
@ -804,7 +789,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
if (key_int == TIFFTAG_COLORMAP) {
int stride = 256;
if (len != 768) {
PyErr_SetString(PyExc_ValueError, "Requiring 768 items for for Colormap");
PyErr_SetString(
PyExc_ValueError, "Requiring 768 items for for Colormap");
return NULL;
}
UINT16 *av;
@ -814,7 +800,9 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = (UINT16)PyLong_AsLong(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int,
status = ImagingLibTiffSetField(
&encoder->state,
(ttag_t)key_int,
av,
av + stride,
av + stride * 2);
@ -828,7 +816,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = (UINT16)PyLong_AsLong(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int, len, av);
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, len, av);
free(av);
}
} else if (type == TIFF_LONG) {
@ -839,7 +828,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = (UINT32)PyLong_AsLong(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int, len, av);
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, len, av);
free(av);
}
} else if (type == TIFF_SBYTE) {
@ -850,7 +840,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = (INT8)PyLong_AsLong(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int, len, av);
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, len, av);
free(av);
}
} else if (type == TIFF_SSHORT) {
@ -861,7 +852,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = (INT16)PyLong_AsLong(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int, len, av);
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, len, av);
free(av);
}
} else if (type == TIFF_SLONG) {
@ -872,7 +864,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = (INT32)PyLong_AsLong(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int, len, av);
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, len, av);
free(av);
}
} else if (type == TIFF_FLOAT) {
@ -883,7 +876,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = (FLOAT32)PyFloat_AsDouble(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int, len, av);
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, len, av);
free(av);
}
} else if (type == TIFF_DOUBLE) {
@ -894,49 +888,42 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
for (i = 0; i < len; i++) {
av[i] = PyFloat_AsDouble(PyTuple_GetItem(value, i));
}
status = ImagingLibTiffSetField(&encoder->state, (ttag_t) key_int, len, av);
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, len, av);
free(av);
}
}
} else {
if (type == TIFF_SHORT) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(UINT16)PyLong_AsLong(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (UINT16)PyLong_AsLong(value));
} else if (type == TIFF_LONG) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(UINT32)PyLong_AsLong(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (UINT32)PyLong_AsLong(value));
} else if (type == TIFF_SSHORT) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(INT16)PyLong_AsLong(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (INT16)PyLong_AsLong(value));
} else if (type == TIFF_SLONG) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(INT32)PyLong_AsLong(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (INT32)PyLong_AsLong(value));
} else if (type == TIFF_FLOAT) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(FLOAT32)PyFloat_AsDouble(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (FLOAT32)PyFloat_AsDouble(value));
} else if (type == TIFF_DOUBLE) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(FLOAT64)PyFloat_AsDouble(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (FLOAT64)PyFloat_AsDouble(value));
} else if (type == TIFF_SBYTE) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(INT8)PyLong_AsLong(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (INT8)PyLong_AsLong(value));
} else if (type == TIFF_ASCII) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
PyBytes_AsString(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, PyBytes_AsString(value));
} else if (type == TIFF_RATIONAL) {
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) key_int,
(FLOAT64)PyFloat_AsDouble(value));
status = ImagingLibTiffSetField(
&encoder->state, (ttag_t)key_int, (FLOAT64)PyFloat_AsDouble(value));
} else {
TRACE(("Unhandled type for key %d : %s \n",
TRACE(
("Unhandled type for key %d : %s \n",
key_int,
PyBytes_AsString(PyObject_Str(value))));
}
@ -977,7 +964,8 @@ PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
#include "libImaging/Jpeg.h"
static unsigned int* get_qtables_arrays(PyObject* qtables, int* qtablesLen) {
static unsigned int *
get_qtables_arrays(PyObject *qtables, int *qtablesLen) {
PyObject *tables;
PyObject *table;
PyObject *table_data;
@ -996,7 +984,8 @@ static unsigned int* get_qtables_arrays(PyObject* qtables, int* qtablesLen) {
tables = PySequence_Fast(qtables, "expected a sequence");
num_tables = PySequence_Size(qtables);
if (num_tables < 1 || num_tables > NUM_QUANT_TBLS) {
PyErr_SetString(PyExc_ValueError,
PyErr_SetString(
PyExc_ValueError,
"Not a valid number of quantization tables. Should be between 1 and 4.");
Py_DECREF(tables);
return NULL;
@ -1019,7 +1008,8 @@ static unsigned int* get_qtables_arrays(PyObject* qtables, int* qtablesLen) {
}
table_data = PySequence_Fast(table, "expected a sequence");
for (j = 0; j < DCTSIZE2; j++) {
qarrays[i * DCTSIZE2 + j] = PyLong_AS_LONG(PySequence_Fast_GET_ITEM(table_data, j));
qarrays[i * DCTSIZE2 + j] =
PyLong_AS_LONG(PySequence_Fast_GET_ITEM(table_data, j));
}
Py_DECREF(table_data);
}
@ -1038,8 +1028,7 @@ JPEG_QTABLES_ERR:
}
PyObject *
PyImaging_JpegEncoderNew(PyObject* self, PyObject* args)
{
PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
char *mode;
@ -1059,11 +1048,24 @@ PyImaging_JpegEncoderNew(PyObject* self, PyObject* args)
char *rawExif = NULL;
Py_ssize_t rawExifLen = 0;
if (!PyArg_ParseTuple(args, "ss|nnnnnnnnOy#y#",
&mode, &rawmode, &quality,
&progressive, &smooth, &optimize, &streamtype,
&xdpi, &ydpi, &subsampling, &qtables, &extra, &extra_size,
&rawExif, &rawExifLen)) {
if (!PyArg_ParseTuple(
args,
"ss|nnnnnnnnOy#y#",
&mode,
&rawmode,
&quality,
&progressive,
&smooth,
&optimize,
&streamtype,
&xdpi,
&ydpi,
&subsampling,
&qtables,
&extra,
&extra_size,
&rawExif,
&rawExifLen)) {
return NULL;
}
@ -1137,7 +1139,6 @@ PyImaging_JpegEncoderNew(PyObject* self, PyObject* args)
#endif
/* -------------------------------------------------------------------- */
/* JPEG 2000 */
/* -------------------------------------------------------------------- */
@ -1147,8 +1148,7 @@ PyImaging_JpegEncoderNew(PyObject* self, PyObject* args)
#include "libImaging/Jpeg2K.h"
static void
j2k_decode_coord_tuple(PyObject *tuple, int *x, int *y)
{
j2k_decode_coord_tuple(PyObject *tuple, int *x, int *y) {
*x = *y = 0;
if (tuple && PyTuple_Check(tuple) && PyTuple_GET_SIZE(tuple) == 2) {
@ -1165,8 +1165,7 @@ j2k_decode_coord_tuple(PyObject *tuple, int *x, int *y)
}
PyObject *
PyImaging_Jpeg2KEncoderNew(PyObject *self, PyObject *args)
{
PyImaging_Jpeg2KEncoderNew(PyObject *self, PyObject *args) {
ImagingEncoderObject *encoder;
JPEG2KENCODESTATE *context;
@ -1185,11 +1184,22 @@ PyImaging_Jpeg2KEncoderNew(PyObject *self, PyObject *args)
OPJ_CINEMA_MODE cine_mode;
Py_ssize_t fd = -1;
if (!PyArg_ParseTuple(args, "ss|OOOsOnOOOssn", &mode, &format,
&offset, &tile_offset, &tile_size,
&quality_mode, &quality_layers, &num_resolutions,
&cblk_size, &precinct_size,
&irreversible, &progression, &cinema_mode,
if (!PyArg_ParseTuple(
args,
"ss|OOOsOnOOOssn",
&mode,
&format,
&offset,
&tile_offset,
&tile_size,
&quality_mode,
&quality_layers,
&num_resolutions,
&cblk_size,
&precinct_size,
&irreversible,
&progression,
&cinema_mode,
&fd)) {
return NULL;
}
@ -1245,29 +1255,27 @@ PyImaging_Jpeg2KEncoderNew(PyObject *self, PyObject *args)
context->format = codec_format;
context->offset_x = context->offset_y = 0;
j2k_decode_coord_tuple(offset, &context->offset_x, &context->offset_y);
j2k_decode_coord_tuple(tile_offset,
&context->tile_offset_x,
&context->tile_offset_y);
j2k_decode_coord_tuple(tile_size,
&context->tile_size_x,
&context->tile_size_y);
j2k_decode_coord_tuple(
tile_offset, &context->tile_offset_x, &context->tile_offset_y);
j2k_decode_coord_tuple(tile_size, &context->tile_size_x, &context->tile_size_y);
/* Error on illegal tile offsets */
if (context->tile_size_x && context->tile_size_y) {
if (context->tile_offset_x <= context->offset_x - context->tile_size_x
|| context->tile_offset_y <= context->offset_y - context->tile_size_y) {
PyErr_SetString(PyExc_ValueError,
if (context->tile_offset_x <= context->offset_x - context->tile_size_x ||
context->tile_offset_y <= context->offset_y - context->tile_size_y) {
PyErr_SetString(
PyExc_ValueError,
"JPEG 2000 tile offset too small; top left tile must "
"intersect image area");
Py_DECREF(encoder);
return NULL;
}
if (context->tile_offset_x > context->offset_x
|| context->tile_offset_y > context->offset_y) {
PyErr_SetString(PyExc_ValueError,
if (context->tile_offset_x > context->offset_x ||
context->tile_offset_y > context->offset_y) {
PyErr_SetString(
PyExc_ValueError,
"JPEG 2000 tile offset too large to cover image area");
Py_DECREF(encoder);
return NULL;
@ -1282,12 +1290,9 @@ PyImaging_Jpeg2KEncoderNew(PyObject *self, PyObject *args)
context->num_resolutions = num_resolutions;
j2k_decode_coord_tuple(cblk_size,
&context->cblk_width,
&context->cblk_height);
j2k_decode_coord_tuple(precinct_size,
&context->precinct_width,
&context->precinct_height);
j2k_decode_coord_tuple(cblk_size, &context->cblk_width, &context->cblk_height);
j2k_decode_coord_tuple(
precinct_size, &context->precinct_width, &context->precinct_height);
context->irreversible = PyObject_IsTrue(irreversible);
context->progression = prog_order;

80
src/libImaging/Access.c
View File

@ -9,7 +9,6 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
/* use Tests/make_hash.py to calculate these values */
@ -19,8 +18,7 @@
static struct ImagingAccessInstance access_table[ACCESS_TABLE_SIZE];
static inline UINT32
hash(const char* mode)
{
hash(const char *mode) {
UINT32 i = ACCESS_TABLE_HASH;
while (*mode) {
i = ((i << 5) + i) ^ (UINT8)*mode++;
@ -29,13 +27,16 @@ hash(const char* mode)
}
static ImagingAccess
add_item(const char* mode)
{
add_item(const char *mode) {
UINT32 i = hash(mode);
/* printf("hash %s => %d\n", mode, i); */
if (access_table[i].mode && strcmp(access_table[i].mode, mode) != 0) {
fprintf(stderr, "AccessInit: hash collision: %d for both %s and %s\n",
i, mode, access_table[i].mode);
fprintf(
stderr,
"AccessInit: hash collision: %d for both %s and %s\n",
i,
mode,
access_table[i].mode);
exit(1);
}
access_table[i].mode = mode;
@ -45,28 +46,24 @@ add_item(const char* mode)
/* fetch pointer to pixel line */
static void *
line_8(Imaging im, int x, int y)
{
line_8(Imaging im, int x, int y) {
return &im->image8[y][x];
}
static void *
line_16(Imaging im, int x, int y)
{
line_16(Imaging im, int x, int y) {
return &im->image8[y][x + x];
}
static void *
line_32(Imaging im, int x, int y)
{
line_32(Imaging im, int x, int y) {
return &im->image32[y][x];
}
/* fetch individual pixel */
static void
get_pixel(Imaging im, int x, int y, void* color)
{
get_pixel(Imaging im, int x, int y, void *color) {
char *out = color;
/* generic pixel access*/
@ -85,15 +82,13 @@ get_pixel(Imaging im, int x, int y, void* color)
}
static void
get_pixel_8(Imaging im, int x, int y, void* color)
{
get_pixel_8(Imaging im, int x, int y, void *color) {
char *out = color;
out[0] = im->image8[y][x];
}
static void
get_pixel_16L(Imaging im, int x, int y, void* color)
{
get_pixel_16L(Imaging im, int x, int y, void *color) {
UINT8 *in = (UINT8 *)&im->image[y][x + x];
#ifdef WORDS_BIGENDIAN
UINT16 out = in[0] + (in[1] << 8);
@ -104,8 +99,7 @@ get_pixel_16L(Imaging im, int x, int y, void* color)
}
static void
get_pixel_16B(Imaging im, int x, int y, void* color)
{
get_pixel_16B(Imaging im, int x, int y, void *color) {
UINT8 *in = (UINT8 *)&im->image[y][x + x];
#ifdef WORDS_BIGENDIAN
memcpy(color, in, sizeof(UINT16));
@ -116,14 +110,12 @@ get_pixel_16B(Imaging im, int x, int y, void* color)
}
static void
get_pixel_32(Imaging im, int x, int y, void* color)
{
get_pixel_32(Imaging im, int x, int y, void *color) {
memcpy(color, &im->image32[y][x], sizeof(INT32));
}
static void
get_pixel_32L(Imaging im, int x, int y, void* color)
{
get_pixel_32L(Imaging im, int x, int y, void *color) {
UINT8 *in = (UINT8 *)&im->image[y][x * 4];
#ifdef WORDS_BIGENDIAN
INT32 out = in[0] + (in[1] << 8) + (in[2] << 16) + (in[3] << 24);
@ -134,8 +126,7 @@ get_pixel_32L(Imaging im, int x, int y, void* color)
}
static void
get_pixel_32B(Imaging im, int x, int y, void* color)
{
get_pixel_32B(Imaging im, int x, int y, void *color) {
UINT8 *in = (UINT8 *)&im->image[y][x * 4];
#ifdef WORDS_BIGENDIAN
memcpy(color, in, sizeof(INT32));
@ -148,8 +139,7 @@ get_pixel_32B(Imaging im, int x, int y, void* color)
/* store individual pixel */
static void
put_pixel(Imaging im, int x, int y, const void* color)
{
put_pixel(Imaging im, int x, int y, const void *color) {
if (im->image8) {
im->image8[y][x] = *((UINT8 *)color);
} else {
@ -158,20 +148,17 @@ put_pixel(Imaging im, int x, int y, const void* color)
}
static void
put_pixel_8(Imaging im, int x, int y, const void* color)
{
put_pixel_8(Imaging im, int x, int y, const void *color) {
im->image8[y][x] = *((UINT8 *)color);
}
static void
put_pixel_16L(Imaging im, int x, int y, const void* color)
{
put_pixel_16L(Imaging im, int x, int y, const void *color) {
memcpy(&im->image8[y][x + x], color, 2);
}
static void
put_pixel_16B(Imaging im, int x, int y, const void* color)
{
put_pixel_16B(Imaging im, int x, int y, const void *color) {
const char *in = color;
UINT8 *out = (UINT8 *)&im->image8[y][x + x];
out[0] = in[1];
@ -179,14 +166,12 @@ put_pixel_16B(Imaging im, int x, int y, const void* color)
}
static void
put_pixel_32L(Imaging im, int x, int y, const void* color)
{
put_pixel_32L(Imaging im, int x, int y, const void *color) {
memcpy(&im->image8[y][x * 4], color, 4);
}
static void
put_pixel_32B(Imaging im, int x, int y, const void* color)
{
put_pixel_32B(Imaging im, int x, int y, const void *color) {
const char *in = color;
UINT8 *out = (UINT8 *)&im->image8[y][x * 4];
out[0] = in[3];
@ -196,16 +181,15 @@ put_pixel_32B(Imaging im, int x, int y, const void* color)
}
static void
put_pixel_32(Imaging im, int x, int y, const void* color)
{
put_pixel_32(Imaging im, int x, int y, const void *color) {
memcpy(&im->image32[y][x], color, sizeof(INT32));
}
void
ImagingAccessInit()
{
ImagingAccessInit() {
#define ADD(mode_, line_, get_pixel_, put_pixel_) \
{ ImagingAccess access = add_item(mode_); \
{ \
ImagingAccess access = add_item(mode_); \
access->line = line_; \
access->get_pixel = get_pixel_; \
access->put_pixel = put_pixel_; \
@ -236,8 +220,7 @@ ImagingAccessInit()
}
ImagingAccess
ImagingAccessNew(Imaging im)
{
ImagingAccessNew(Imaging im) {
ImagingAccess access = &access_table[hash(im->mode)];
if (im->mode[0] != access->mode[0] || strcmp(im->mode, access->mode) != 0) {
return NULL;
@ -246,7 +229,4 @@ ImagingAccessNew(Imaging im)
}
void
_ImagingAccessDelete(Imaging im, ImagingAccess access)
{
}
_ImagingAccessDelete(Imaging im, ImagingAccess access) {}

35
src/libImaging/AlphaComposite.c
View File

@ -8,39 +8,30 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
#define PRECISION_BITS 7
typedef struct
{
typedef struct {
UINT8 r;
UINT8 g;
UINT8 b;
UINT8 a;
} rgba8;
Imaging
ImagingAlphaComposite(Imaging imDst, Imaging imSrc)
{
ImagingAlphaComposite(Imaging imDst, Imaging imSrc) {
Imaging imOut;
int x, y;
/* Check arguments */
if (!imDst || !imSrc ||
strcmp(imDst->mode, "RGBA") ||
imDst->type != IMAGING_TYPE_UINT8 ||
imDst->bands != 4) {
if (!imDst || !imSrc || strcmp(imDst->mode, "RGBA") ||
imDst->type != IMAGING_TYPE_UINT8 || imDst->bands != 4) {
return ImagingError_ModeError();
}
if (strcmp(imDst->mode, imSrc->mode) ||
imDst->type != imSrc->type ||
imDst->bands != imSrc->bands ||
imDst->xsize != imSrc->xsize ||
if (strcmp(imDst->mode, imSrc->mode) || imDst->type != imSrc->type ||
imDst->bands != imSrc->bands || imDst->xsize != imSrc->xsize ||
imDst->ysize != imSrc->ysize) {
return ImagingError_Mismatch();
}
@ -75,15 +66,19 @@ ImagingAlphaComposite(Imaging imDst, Imaging imSrc)
tmpr = src->r * coef1 + dst->r * coef2;
tmpg = src->g * coef1 + dst->g * coef2;
tmpb = src->b * coef1 + dst->b * coef2;
out->r = SHIFTFORDIV255(tmpr + (0x80<<PRECISION_BITS)) >> PRECISION_BITS;
out->g = SHIFTFORDIV255(tmpg + (0x80<<PRECISION_BITS)) >> PRECISION_BITS;
out->b = SHIFTFORDIV255(tmpb + (0x80<<PRECISION_BITS)) >> PRECISION_BITS;
out->r =
SHIFTFORDIV255(tmpr + (0x80 << PRECISION_BITS)) >> PRECISION_BITS;
out->g =
SHIFTFORDIV255(tmpg + (0x80 << PRECISION_BITS)) >> PRECISION_BITS;
out->b =
SHIFTFORDIV255(tmpb + (0x80 << PRECISION_BITS)) >> PRECISION_BITS;
out->a = SHIFTFORDIV255(outa255 + 0x80);
}
dst++; src++; out++;
dst++;
src++;
out++;
}
}
return imOut;

26
src/libImaging/Bands.c
View File

@ -15,13 +15,10 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
Imaging
ImagingGetBand(Imaging imIn, int band)
{
ImagingGetBand(Imaging imIn, int band) {
Imaging imOut;
int x, y;
@ -68,10 +65,8 @@ ImagingGetBand(Imaging imIn, int band)
return imOut;
}
int
ImagingSplit(Imaging imIn, Imaging bands[4])
{
ImagingSplit(Imaging imIn, Imaging bands[4]) {
int i, j, x, y;
/* Check arguments */
@ -171,10 +166,8 @@ ImagingSplit(Imaging imIn, Imaging bands[4])
return imIn->bands;
}
Imaging
ImagingPutBand(Imaging imOut, Imaging imIn, int band)
{
ImagingPutBand(Imaging imOut, Imaging imIn, int band) {
int x, y;
/* Check arguments */
@ -186,8 +179,7 @@ ImagingPutBand(Imaging imOut, Imaging imIn, int band)
return (Imaging)ImagingError_ValueError("band index out of range");
}
if (imIn->type != imOut->type ||
imIn->xsize != imOut->xsize ||
if (imIn->type != imOut->type || imIn->xsize != imOut->xsize ||
imIn->ysize != imOut->ysize) {
return (Imaging)ImagingError_Mismatch();
}
@ -216,8 +208,7 @@ ImagingPutBand(Imaging imOut, Imaging imIn, int band)
}
Imaging
ImagingFillBand(Imaging imOut, int band, int color)
{
ImagingFillBand(Imaging imOut, int band, int color) {
int x, y;
/* Check arguments */
@ -249,8 +240,7 @@ ImagingFillBand(Imaging imOut, int band, int color)
}
Imaging
ImagingMerge(const char* mode, Imaging bands[4])
{
ImagingMerge(const char *mode, Imaging bands[4]) {
int i, x, y;
int bandsCount = 0;
Imaging imOut;
@ -268,8 +258,8 @@ ImagingMerge(const char* mode, Imaging bands[4])
if (bands[i]->bands != 1) {
return (Imaging)ImagingError_ModeError();
}
if (bands[i]->xsize != firstBand->xsize
|| bands[i]->ysize != firstBand->ysize) {
if (bands[i]->xsize != firstBand->xsize ||
bands[i]->ysize != firstBand->ysize) {
return (Imaging)ImagingError_Mismatch();
}
}

310
src/libImaging/BcnDecode.c
View File

@ -11,10 +11,8 @@
* https://creativecommons.org/publicdomain/zero/1.0/
*/
#include "Imaging.h"
typedef struct {
UINT8 r, g, b, a;
} rgba;
@ -37,23 +35,24 @@ typedef struct {
UINT8 lut[6];
} bc3_alpha;
#define LOAD16(p) \
(p)[0] | ((p)[1] << 8)
#define LOAD16(p) (p)[0] | ((p)[1] << 8)
#define LOAD32(p) \
(p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24)
#define LOAD32(p) (p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24)
static void bc1_color_load(bc1_color *dst, const UINT8 *src) {
static void
bc1_color_load(bc1_color *dst, const UINT8 *src) {
dst->c0 = LOAD16(src);
dst->c1 = LOAD16(src + 2);
dst->lut = LOAD32(src + 4);
}
static void bc3_alpha_load(bc3_alpha *dst, const UINT8 *src) {
static void
bc3_alpha_load(bc3_alpha *dst, const UINT8 *src) {
memcpy(dst, src, sizeof(bc3_alpha));
}
static rgba decode_565(UINT16 x) {
static rgba
decode_565(UINT16 x) {
rgba c;
int r, g, b;
r = (x & 0xf800) >> 8;
@ -69,7 +68,8 @@ static rgba decode_565(UINT16 x) {
return c;
}
static void decode_bc1_color(rgba *dst, const UINT8 *src) {
static void
decode_bc1_color(rgba *dst, const UINT8 *src) {
bc1_color col;
rgba p[4];
int n, cw;
@ -109,7 +109,8 @@ static void decode_bc1_color(rgba *dst, const UINT8 *src) {
}
}
static void decode_bc3_alpha(char *dst, const UINT8 *src, int stride, int o) {
static void
decode_bc3_alpha(char *dst, const UINT8 *src, int stride, int o) {
bc3_alpha b;
UINT16 a0, a1;
UINT8 a[8];
@ -147,11 +148,13 @@ static void decode_bc3_alpha(char *dst, const UINT8 *src, int stride, int o) {
}
}
static void decode_bc1_block(rgba *col, const UINT8* src) {
static void
decode_bc1_block(rgba *col, const UINT8 *src) {
decode_bc1_color(col, src);
}
static void decode_bc2_block(rgba *col, const UINT8* src) {
static void
decode_bc2_block(rgba *col, const UINT8 *src) {
int n, bitI, byI, av;
decode_bc1_color(col, src + 8);
for (n = 0; n < 16; n++) {
@ -163,30 +166,36 @@ static void decode_bc2_block(rgba *col, const UINT8* src) {
}
}
static void decode_bc3_block(rgba *col, const UINT8* src) {
static void
decode_bc3_block(rgba *col, const UINT8 *src) {
decode_bc1_color(col, src + 8);
decode_bc3_alpha((char *)col, src, sizeof(col[0]), 3);
}
static void decode_bc4_block(lum *col, const UINT8* src) {
static void
decode_bc4_block(lum *col, const UINT8 *src) {
decode_bc3_alpha((char *)col, src, sizeof(col[0]), 0);
}
static void decode_bc5_block(rgba *col, const UINT8* src) {
static void
decode_bc5_block(rgba *col, const UINT8 *src) {
decode_bc3_alpha((char *)col, src, sizeof(col[0]), 0);
decode_bc3_alpha((char *)col, src + 8, sizeof(col[0]), 1);
}
/* BC6 and BC7 are described here:
https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_texture_compression_bptc.txt */
https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_texture_compression_bptc.txt
*/
static UINT8 get_bit(const UINT8* src, int bit) {
static UINT8
get_bit(const UINT8 *src, int bit) {
int by = bit >> 3;
bit &= 7;
return (src[by] >> bit) & 1;
}
static UINT8 get_bits(const UINT8* src, int bit, int count) {
static UINT8
get_bits(const UINT8 *src, int bit, int count) {
UINT8 v;
int x;
int by = bit >> 3;
@ -225,73 +234,51 @@ static const bc7_mode_info bc7_modes[] = {
{1, 0, 2, 1, 5, 6, 0, 0, 2, 3},
{1, 0, 2, 0, 7, 8, 0, 0, 2, 2},
{1, 0, 0, 0, 7, 7, 1, 0, 4, 0},
{2, 6, 0, 0, 5, 5, 1, 0, 2, 0}
};
{2, 6, 0, 0, 5, 5, 1, 0, 2, 0}};
/* Subset indices:
Table.P2, 1 bit per index */
static const UINT16 bc7_si2[] = {
0xcccc, 0x8888, 0xeeee, 0xecc8, 0xc880, 0xfeec, 0xfec8, 0xec80,
0xc800, 0xffec, 0xfe80, 0xe800, 0xffe8, 0xff00, 0xfff0, 0xf000,
0xf710, 0x008e, 0x7100, 0x08ce, 0x008c, 0x7310, 0x3100, 0x8cce,
0x088c, 0x3110, 0x6666, 0x366c, 0x17e8, 0x0ff0, 0x718e, 0x399c,
0xaaaa, 0xf0f0, 0x5a5a, 0x33cc, 0x3c3c, 0x55aa, 0x9696, 0xa55a,
0x73ce, 0x13c8, 0x324c, 0x3bdc, 0x6996, 0xc33c, 0x9966, 0x0660,
0x0272, 0x04e4, 0x4e40, 0x2720, 0xc936, 0x936c, 0x39c6, 0x639c,
0x9336, 0x9cc6, 0x817e, 0xe718, 0xccf0, 0x0fcc, 0x7744, 0xee22};
0xcccc, 0x8888, 0xeeee, 0xecc8, 0xc880, 0xfeec, 0xfec8, 0xec80, 0xc800, 0xffec,
0xfe80, 0xe800, 0xffe8, 0xff00, 0xfff0, 0xf000, 0xf710, 0x008e, 0x7100, 0x08ce,
0x008c, 0x7310, 0x3100, 0x8cce, 0x088c, 0x3110, 0x6666, 0x366c, 0x17e8, 0x0ff0,
0x718e, 0x399c, 0xaaaa, 0xf0f0, 0x5a5a, 0x33cc, 0x3c3c, 0x55aa, 0x9696, 0xa55a,
0x73ce, 0x13c8, 0x324c, 0x3bdc, 0x6996, 0xc33c, 0x9966, 0x0660, 0x0272, 0x04e4,
0x4e40, 0x2720, 0xc936, 0x936c, 0x39c6, 0x639c, 0x9336, 0x9cc6, 0x817e, 0xe718,
0xccf0, 0x0fcc, 0x7744, 0xee22};
/* Table.P3, 2 bits per index */
static const UINT32 bc7_si3[] = {
0xaa685050, 0x6a5a5040, 0x5a5a4200, 0x5450a0a8,
0xa5a50000, 0xa0a05050, 0x5555a0a0, 0x5a5a5050,
0xaa550000, 0xaa555500, 0xaaaa5500, 0x90909090,
0x94949494, 0xa4a4a4a4, 0xa9a59450, 0x2a0a4250,
0xa5945040, 0x0a425054, 0xa5a5a500, 0x55a0a0a0,
0xa8a85454, 0x6a6a4040, 0xa4a45000, 0x1a1a0500,
0x0050a4a4, 0xaaa59090, 0x14696914, 0x69691400,
0xa08585a0, 0xaa821414, 0x50a4a450, 0x6a5a0200,
0xa9a58000, 0x5090a0a8, 0xa8a09050, 0x24242424,
0x00aa5500, 0x24924924, 0x24499224, 0x50a50a50,
0x500aa550, 0xaaaa4444, 0x66660000, 0xa5a0a5a0,
0x50a050a0, 0x69286928, 0x44aaaa44, 0x66666600,
0xaa444444, 0x54a854a8, 0x95809580, 0x96969600,
0xa85454a8, 0x80959580, 0xaa141414, 0x96960000,
0xaaaa1414, 0xa05050a0, 0xa0a5a5a0, 0x96000000,
0x40804080, 0xa9a8a9a8, 0xaaaaaa44, 0x2a4a5254};
0xaa685050, 0x6a5a5040, 0x5a5a4200, 0x5450a0a8, 0xa5a50000, 0xa0a05050, 0x5555a0a0,
0x5a5a5050, 0xaa550000, 0xaa555500, 0xaaaa5500, 0x90909090, 0x94949494, 0xa4a4a4a4,
0xa9a59450, 0x2a0a4250, 0xa5945040, 0x0a425054, 0xa5a5a500, 0x55a0a0a0, 0xa8a85454,
0x6a6a4040, 0xa4a45000, 0x1a1a0500, 0x0050a4a4, 0xaaa59090, 0x14696914, 0x69691400,
0xa08585a0, 0xaa821414, 0x50a4a450, 0x6a5a0200, 0xa9a58000, 0x5090a0a8, 0xa8a09050,
0x24242424, 0x00aa5500, 0x24924924, 0x24499224, 0x50a50a50, 0x500aa550, 0xaaaa4444,
0x66660000, 0xa5a0a5a0, 0x50a050a0, 0x69286928, 0x44aaaa44, 0x66666600, 0xaa444444,
0x54a854a8, 0x95809580, 0x96969600, 0xa85454a8, 0x80959580, 0xaa141414, 0x96960000,
0xaaaa1414, 0xa05050a0, 0xa0a5a5a0, 0x96000000, 0x40804080, 0xa9a8a9a8, 0xaaaaaa44,
0x2a4a5254};
/* Anchor indices:
Table.A2 */
static const char bc7_ai0[] = {
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15, 2, 8, 2, 2, 8, 8,15,
2, 8, 2, 2, 8, 8, 2, 2,
15,15, 6, 8, 2, 8,15,15,
2, 8, 2, 2, 2,15,15, 6,
6, 2, 6, 8,15,15, 2, 2,
15,15,15,15,15, 2, 2,15};
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 2, 8, 2, 2, 8,
8, 15, 2, 8, 2, 2, 8, 8, 2, 2, 15, 15, 6, 8, 2, 8, 15, 15, 2, 8, 2, 2,
2, 15, 15, 6, 6, 2, 6, 8, 15, 15, 2, 2, 15, 15, 15, 15, 15, 2, 2, 15};
/* Table.A3a */
static const char bc7_ai1[] = {
3, 3,15,15, 8, 3,15,15,
8, 8, 6, 6, 6, 5, 3, 3,
3, 3, 8,15, 3, 3, 6,10,
5, 8, 8, 6, 8, 5,15,15,
8,15, 3, 5, 6,10, 8,15,
15, 3,15, 5,15,15,15,15,
3,15, 5, 5, 5, 8, 5,10,
5,10, 8,13,15,12, 3, 3};
3, 3, 15, 15, 8, 3, 15, 15, 8, 8, 6, 6, 6, 5, 3, 3, 3, 3, 8, 15, 3, 3,
6, 10, 5, 8, 8, 6, 8, 5, 15, 15, 8, 15, 3, 5, 6, 10, 8, 15, 15, 3, 15, 5,
15, 15, 15, 15, 3, 15, 5, 5, 5, 8, 5, 10, 5, 10, 8, 13, 15, 12, 3, 3};
/* Table.A3b */
static const char bc7_ai2[] = {
15, 8, 8, 3,15,15, 3, 8,
15,15,15,15,15,15,15, 8,
15, 8,15, 3,15, 8,15, 8,
3,15, 6,10,15,15,10, 8,
15, 3,15,10,10, 8, 9,10,
6,15, 8,15, 3, 6, 6, 8,
15, 3,15,15,15,15,15,15,
15,15,15,15, 3,15,15, 8};
static const char bc7_ai2[] = {15, 8, 8, 3, 15, 15, 3, 8, 15, 15, 15, 15, 15,
15, 15, 8, 15, 8, 15, 3, 15, 8, 15, 8, 3, 15,
6, 10, 15, 15, 10, 8, 15, 3, 15, 10, 10, 8, 9,
10, 6, 15, 8, 15, 3, 6, 6, 8, 15, 3, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 3, 15, 15, 8};
/* Interpolation weights */
static const char bc7_weights2[] = {0, 21, 43, 64};
@ -299,7 +286,8 @@ static const char bc7_weights3[] = {0, 9, 18, 27, 37, 46, 55, 64};
static const char bc7_weights4[] = {
0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64};
static const char *bc7_get_weights(int n) {
static const char *
bc7_get_weights(int n) {
if (n == 2) {
return bc7_weights2;
}
@ -309,7 +297,8 @@ static const char *bc7_get_weights(int n) {
return bc7_weights4;
}
static int bc7_get_subset(int ns, int partition, int n) {
static int
bc7_get_subset(int ns, int partition, int n) {
if (ns == 2) {
return 1 & (bc7_si2[partition] >> n);
}
@ -319,12 +308,14 @@ static int bc7_get_subset(int ns, int partition, int n) {
return 0;
}
static UINT8 expand_quantized(UINT8 v, int bits) {
static UINT8
expand_quantized(UINT8 v, int bits) {
v = v << (8 - bits);
return v | (v >> bits);
}
static void bc7_lerp(rgba *dst, const rgba *e, int s0, int s1) {
static void
bc7_lerp(rgba *dst, const rgba *e, int s0, int s1) {
int t0 = 64 - s0;
int t1 = 64 - s1;
dst->r = (UINT8)((t0 * e[0].r + s0 * e[1].r + 32) >> 6);
@ -333,7 +324,8 @@ static void bc7_lerp(rgba *dst, const rgba *e, int s0, int s1) {
dst->a = (UINT8)((t1 * e[0].a + s1 * e[1].a + 32) >> 6);
}
static void decode_bc7_block(rgba *col, const UINT8* src) {
static void
decode_bc7_block(rgba *col, const UINT8 *src) {
rgba endpoints[6];
int bit = 0, cibit, aibit;
int mode = src[0];
@ -352,7 +344,8 @@ static void decode_bc7_block(rgba *col, const UINT8* src) {
}
return;
}
while (!(mode & (1 << bit++))) ;
while (!(mode & (1 << bit++)))
;
mode = bit - 1;
info = &bc7_modes[mode];
/* color selection bits: {subset}{endpoint} */
@ -525,79 +518,75 @@ static const bc6_mode_info bc6_modes[] = {
{1, 0, 0, 10, 10, 10, 10},
{1, 1, 0, 11, 9, 9, 9},
{1, 1, 0, 12, 8, 8, 8},
{1, 1, 0, 16, 4, 4, 4}
};
{1, 1, 0, 16, 4, 4, 4}};
/* Table.F, encoded as a sequence of bit indices */
static const UINT8 bc6_bit_packings[][75] = {
{116, 132, 176, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52,
164, 112, 113, 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80,
81, 82, 83, 84, 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144,
145, 146, 147, 148, 175},
{117, 164, 165, 0, 1, 2, 3, 4, 5, 6, 172, 173, 132, 16, 17, 18, 19, 20, 21,
22, 133, 174, 116, 32, 33, 34, 35, 36, 37, 38, 175, 177, 176, 48, 49, 50,
51, 52, 53, 112, 113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163,
80, 81, 82, 83, 84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144,
145, 146, 147, 148, 149},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 10, 112, 113, 114,
115, 64, 65, 66, 67, 26, 172, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173,
128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148,
175},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 10, 164, 112, 113, 114,
115, 64, 65, 66, 67, 68, 26, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173,
128, 129, 130, 131, 96, 97, 98, 99, 172, 174, 144, 145, 146, 147, 116,
175},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 10, 132, 112, 113, 114,
115, 64, 65, 66, 67, 26, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 42,
128, 129, 130, 131, 96, 97, 98, 99, 173, 174, 144, 145, 146, 147, 176,
175},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 132, 16, 17, 18, 19, 20, 21, 22, 23, 24, 116,
32, 33, 34, 35, 36, 37, 38, 39, 40, 176, 48, 49, 50, 51, 52, 164, 112, 113,
114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84,
173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148,
175},
{0, 1, 2, 3, 4, 5, 6, 7, 164, 132, 16, 17, 18, 19, 20, 21, 22, 23, 174, 116,
32, 33, 34, 35, 36, 37, 38, 39, 175, 176, 48, 49, 50, 51, 52, 53, 112, 113,
114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84,
173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144, 145, 146, 147, 148,
149},
{0, 1, 2, 3, 4, 5, 6, 7, 172, 132, 16, 17, 18, 19, 20, 21, 22, 23, 117, 116,
32, 33, 34, 35, 36, 37, 38, 39, 165, 176, 48, 49, 50, 51, 52, 164, 112,
113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163, 80, 81, 82, 83,
84, 173, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147,
148, 175},
{0, 1, 2, 3, 4, 5, 6, 7, 173, 132, 16, 17, 18, 19, 20, 21, 22, 23, 133, 116,
32, 33, 34, 35, 36, 37, 38, 39, 177, 176, 48, 49, 50, 51, 52, 164, 112,
113, 114, 115, 64, 65, 66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83,
84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147,
148, 175},
{0, 1, 2, 3, 4, 5, 164, 172, 173, 132, 16, 17, 18, 19, 20, 21, 117, 133,
174, 116, 32, 33, 34, 35, 36, 37, 165, 175, 177, 176, 48, 49, 50, 51, 52,
53, 112, 113, 114, 115, 64, 65, 66, 67, 68, 69, 160, 161, 162, 163, 80, 81,
82, 83, 84, 85, 128, 129, 130, 131, 96, 97, 98, 99, 100, 101, 144, 145,
146, 147, 148, 149},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 80, 81, 82, 83, 84, 85, 86, 87, 88,
89},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 10,
64, 65, 66, 67, 68, 69, 70, 71, 72, 26, 80, 81, 82, 83, 84, 85, 86, 87, 88,
42},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 11, 10,
64, 65, 66, 67, 68, 69, 70, 71, 27, 26, 80, 81, 82, 83, 84, 85, 86, 87, 43,
42},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 15, 14, 13, 12, 11, 10,
64, 65, 66, 67, 31, 30, 29, 28, 27, 26, 80, 81, 82, 83, 47, 46, 45, 44, 43,
42}};
{116, 132, 176, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 48, 49, 50, 51, 52, 164, 112, 113, 114, 115, 64, 65,
66, 67, 68, 172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 173, 128,
129, 130, 131, 96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148, 175},
{117, 164, 165, 0, 1, 2, 3, 4, 5, 6, 172, 173, 132, 16, 17,
18, 19, 20, 21, 22, 133, 174, 116, 32, 33, 34, 35, 36, 37, 38,
175, 177, 176, 48, 49, 50, 51, 52, 53, 112, 113, 114, 115, 64, 65,
66, 67, 68, 69, 160, 161, 162, 163, 80, 81, 82, 83, 84, 85, 128,
129, 130, 131, 96, 97, 98, 99, 100, 101, 144, 145, 146, 147, 148, 149},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
48, 49, 50, 51, 52, 10, 112, 113, 114, 115, 64, 65, 66, 67, 26,
172, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173, 128, 129, 130, 131,
96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148, 175},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
48, 49, 50, 51, 10, 164, 112, 113, 114, 115, 64, 65, 66, 67, 68,
26, 160, 161, 162, 163, 80, 81, 82, 83, 42, 173, 128, 129, 130, 131,
96, 97, 98, 99, 172, 174, 144, 145, 146, 147, 116, 175},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
48, 49, 50, 51, 10, 132, 112, 113, 114, 115, 64, 65, 66, 67, 26,
172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 42, 128, 129, 130, 131,
96, 97, 98, 99, 173, 174, 144, 145, 146, 147, 176, 175},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 132, 16, 17, 18, 19, 20,
21, 22, 23, 24, 116, 32, 33, 34, 35, 36, 37, 38, 39, 40, 176,
48, 49, 50, 51, 52, 164, 112, 113, 114, 115, 64, 65, 66, 67, 68,
172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 173, 128, 129, 130, 131,
96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148, 175},
{0, 1, 2, 3, 4, 5, 6, 7, 164, 132, 16, 17, 18, 19, 20,
21, 22, 23, 174, 116, 32, 33, 34, 35, 36, 37, 38, 39, 175, 176,
48, 49, 50, 51, 52, 53, 112, 113, 114, 115, 64, 65, 66, 67, 68,
172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 173, 128, 129, 130, 131,
96, 97, 98, 99, 100, 101, 144, 145, 146, 147, 148, 149},
{0, 1, 2, 3, 4, 5, 6, 7, 172, 132, 16, 17, 18, 19, 20,
21, 22, 23, 117, 116, 32, 33, 34, 35, 36, 37, 38, 39, 165, 176,
48, 49, 50, 51, 52, 164, 112, 113, 114, 115, 64, 65, 66, 67, 68,
69, 160, 161, 162, 163, 80, 81, 82, 83, 84, 173, 128, 129, 130, 131,
96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148, 175},
{0, 1, 2, 3, 4, 5, 6, 7, 173, 132, 16, 17, 18, 19, 20,
21, 22, 23, 133, 116, 32, 33, 34, 35, 36, 37, 38, 39, 177, 176,
48, 49, 50, 51, 52, 164, 112, 113, 114, 115, 64, 65, 66, 67, 68,
172, 160, 161, 162, 163, 80, 81, 82, 83, 84, 85, 128, 129, 130, 131,
96, 97, 98, 99, 100, 174, 144, 145, 146, 147, 148, 175},
{0, 1, 2, 3, 4, 5, 164, 172, 173, 132, 16, 17, 18, 19, 20,
21, 117, 133, 174, 116, 32, 33, 34, 35, 36, 37, 165, 175, 177, 176,
48, 49, 50, 51, 52, 53, 112, 113, 114, 115, 64, 65, 66, 67, 68,
69, 160, 161, 162, 163, 80, 81, 82, 83, 84, 85, 128, 129, 130, 131,
96, 97, 98, 99, 100, 101, 144, 145, 146, 147, 148, 149},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 56, 10,
64, 65, 66, 67, 68, 69, 70, 71, 72, 26, 80, 81, 82, 83, 84, 85, 86, 87, 88, 42},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 52, 53, 54, 55, 11, 10,
64, 65, 66, 67, 68, 69, 70, 71, 27, 26, 80, 81, 82, 83, 84, 85, 86, 87, 43, 42},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 48, 49, 50, 51, 15, 14, 13, 12, 11, 10,
64, 65, 66, 67, 31, 30, 29, 28, 27, 26, 80, 81, 82, 83, 47, 46, 45, 44, 43, 42}};
static void bc6_sign_extend(UINT16 *v, int prec) {
static void
bc6_sign_extend(UINT16 *v, int prec) {
int x = *v;
if (x & (1 << (prec - 1))) {
x |= -1 << prec;
@ -605,7 +594,8 @@ static void bc6_sign_extend(UINT16 *v, int prec) {
*v = (UINT16)x;
}
static int bc6_unquantize(UINT16 v, int prec, int sign) {
static int
bc6_unquantize(UINT16 v, int prec, int sign) {
int s = 0;
int x;
if (!sign) {
@ -645,7 +635,8 @@ static int bc6_unquantize(UINT16 v, int prec, int sign) {
}
}
static float half_to_float(UINT16 h) {
static float
half_to_float(UINT16 h) {
/* https://gist.github.com/rygorous/2144712 */
union {
UINT32 u;
@ -662,7 +653,8 @@ static float half_to_float(UINT16 h) {
return o.f;
}
static float bc6_finalize(int v, int sign) {
static float
bc6_finalize(int v, int sign) {
if (sign) {
if (v < 0) {
v = ((-v) * 31) / 32;
@ -675,7 +667,8 @@ static float bc6_finalize(int v, int sign) {
}
}
static void bc6_lerp(rgb32f *col, int *e0, int *e1, int s, int sign) {
static void
bc6_lerp(rgb32f *col, int *e0, int *e1, int s, int sign) {
int r, g, b;
int t = 64 - s;
r = (e0[0] * t + e1[0] * s) >> 6;
@ -686,7 +679,8 @@ static void bc6_lerp(rgb32f *col, int *e0, int *e1, int s, int sign) {
col->b = bc6_finalize(b, sign);
}
static void decode_bc6_block(rgb32f *col, const UINT8* src, int sign) {
static void
decode_bc6_block(rgb32f *col, const UINT8 *src, int sign) {
UINT16 endpoints[12]; /* storage for r0, g0, b0, r1, ... */
int ueps[12];
int i, i0, ib2, di, dw, mask, numep, s;
@ -773,7 +767,8 @@ static void decode_bc6_block(rgb32f *col, const UINT8* src, int sign) {
}
}
static void put_block(Imaging im, ImagingCodecState state, const char *col, int sz, int C) {
static void
put_block(Imaging im, ImagingCodecState state, const char *col, int sz, int C) {
int width = state->xsize;
int height = state->ysize;
int xmax = width + state->xoff;
@ -813,7 +808,9 @@ static void put_block(Imaging im, ImagingCodecState state, const char *col, int
}
}
static int decode_bcn(Imaging im, ImagingCodecState state, const UINT8* src, int bytes, int N, int C) {
static int
decode_bcn(
Imaging im, ImagingCodecState state, const UINT8 *src, int bytes, int N, int C) {
int ymax = state->ysize + state->yoff;
const UINT8 *ptr = src;
switch (N) {
@ -844,9 +841,9 @@ static int decode_bcn(Imaging im, ImagingCodecState state, const UINT8* src, int
put_block(im, state, (const char *)col, sizeof(col[0]), C);
ptr += 16;
bytes -= 16;
if (state->y >= ymax) {\
return -1; \
}\
if (state->y >= ymax) {
return -1;
}
}
break;
DECODE_LOOP(7, 16, rgba);
@ -855,7 +852,8 @@ static int decode_bcn(Imaging im, ImagingCodecState state, const UINT8* src, int
return (int)(ptr - src);
}
int ImagingBcnDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes) {
int
ImagingBcnDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
int N = state->state & 0xf;
int width = state->xsize;
int height = state->ysize;

1
src/libImaging/Bit.h
View File

@ -1,7 +1,6 @@
/* Bit.h */
typedef struct {
/* CONFIGURATION */
/* Number of bits per pixel */

18
src/libImaging/BitDecode.c
View File

@ -13,20 +13,16 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include "Bit.h"
int
ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
BITSTATE *bitstate = state->context;
UINT8 *ptr;
if (state->state == 0) {
/* Initialize context variables */
/* this decoder only works for float32 image buffers */
@ -56,13 +52,11 @@ ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
}
state->state = 1;
}
ptr = buf;
while (bytes > 0) {
UINT8 byte = *ptr;
ptr++;
@ -80,7 +74,6 @@ ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
bitstate->bitcount += 8;
while (bitstate->bitcount >= bitstate->bits) {
/* get a pixel from the bit buffer */
unsigned long data;
FLOAT32 pixel;
@ -90,16 +83,15 @@ ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
data = bitstate->bitbuffer & bitstate->mask;
if (bitstate->bitcount > 32) {
/* bitbuffer overflow; restore it from last input byte */
bitstate->bitbuffer = byte >> (8 - (bitstate->bitcount -
bitstate->bits));
bitstate->bitbuffer =
byte >> (8 - (bitstate->bitcount - bitstate->bits));
} else {
bitstate->bitbuffer >>= bitstate->bits;
}
} else {
/* store MSB first */
data = (bitstate->bitbuffer >> (bitstate->bitcount -
bitstate->bits))
& bitstate->mask;
data = (bitstate->bitbuffer >> (bitstate->bitcount - bitstate->bits)) &
bitstate->mask;
}
bitstate->bitcount -= bitstate->bits;

23
src/libImaging/Blend.c
View File

@ -15,27 +15,22 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
Imaging
ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha)
{
ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha) {
Imaging imOut;
int x, y;
/* Check arguments */
if (!imIn1 || !imIn2 || imIn1->type != IMAGING_TYPE_UINT8
|| imIn1->palette || strcmp(imIn1->mode, "1") == 0
|| imIn2->palette || strcmp(imIn2->mode, "1") == 0) {
if (!imIn1 || !imIn2 || imIn1->type != IMAGING_TYPE_UINT8 || imIn1->palette ||
strcmp(imIn1->mode, "1") == 0 || imIn2->palette ||
strcmp(imIn2->mode, "1") == 0) {
return ImagingError_ModeError();
}
if (imIn1->type != imIn2->type ||
imIn1->bands != imIn2->bands ||
imIn1->xsize != imIn2->xsize ||
imIn1->ysize != imIn2->ysize) {
if (imIn1->type != imIn2->type || imIn1->bands != imIn2->bands ||
imIn1->xsize != imIn2->xsize || imIn1->ysize != imIn2->ysize) {
return ImagingError_Mismatch();
}
@ -58,8 +53,7 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha)
UINT8 *in2 = (UINT8 *)imIn2->image[y];
UINT8 *out = (UINT8 *)imOut->image[y];
for (x = 0; x < imIn1->linesize; x++) {
out[x] = (UINT8)
((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
out[x] = (UINT8)((int)in1[x] + alpha * ((int)in2[x] - (int)in1[x]));
}
}
} else {
@ -69,8 +63,7 @@ ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha)
UINT8 *in2 = (UINT8 *)imIn2->image[y];
UINT8 *out = (UINT8 *)imOut->image[y];
for (x = 0; x < imIn1->linesize; x++) {
float temp = (float)
((int) in1[x] + alpha * ((int) in2[x] - (int) in1[x]));
float temp = (float)((int)in1[x] + alpha * ((int)in2[x] - (int)in1[x]));
if (temp <= 0.0) {
out[x] = 0;
} else if (temp >= 255.0) {

109
src/libImaging/BoxBlur.c
View File

@ -1,16 +1,19 @@
#include "Imaging.h"
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
typedef UINT8 pixel[4];
void static inline
ImagingLineBoxBlur32(pixel *lineOut, pixel *lineIn, int lastx, int radius, int edgeA,
int edgeB, UINT32 ww, UINT32 fw)
{
void static inline ImagingLineBoxBlur32(
pixel *lineOut,
pixel *lineIn,
int lastx,
int radius,
int edgeA,
int edgeB,
UINT32 ww,
UINT32 fw) {
int x;
UINT32 acc[4];
UINT32 bulk[4];
@ -53,8 +56,7 @@ ImagingLineBoxBlur32(pixel *lineOut, pixel *lineIn, int lastx, int radius, int e
acc[2] += lineIn[lastx][2] * (radius - edgeA + 1);
acc[3] += lineIn[lastx][3] * (radius - edgeA + 1);
if (edgeA <= edgeB)
{
if (edgeA <= edgeB) {
/* Subtract pixel from left ("0").
Add pixels from radius. */
for (x = 0; x < edgeA; x++) {
@ -76,9 +78,7 @@ ImagingLineBoxBlur32(pixel *lineOut, pixel *lineIn, int lastx, int radius, int e
ADD_FAR(bulk, acc, x - radius - 1, lastx);
SAVE(x, bulk);
}
}
else
{
} else {
for (x = 0; x < edgeB; x++) {
MOVE_ACC(acc, 0, x + radius);
ADD_FAR(bulk, acc, 0, x + radius + 1);
@ -101,23 +101,25 @@ ImagingLineBoxBlur32(pixel *lineOut, pixel *lineIn, int lastx, int radius, int e
#undef SAVE
}
void static inline
ImagingLineBoxBlur8(UINT8 *lineOut, UINT8 *lineIn, int lastx, int radius, int edgeA,
int edgeB, UINT32 ww, UINT32 fw)
{
void static inline ImagingLineBoxBlur8(
UINT8 *lineOut,
UINT8 *lineIn,
int lastx,
int radius,
int edgeA,
int edgeB,
UINT32 ww,
UINT32 fw) {
int x;
UINT32 acc;
UINT32 bulk;
#define MOVE_ACC(acc, subtract, add) \
acc += lineIn[add] - lineIn[subtract];
#define MOVE_ACC(acc, subtract, add) acc += lineIn[add] - lineIn[subtract];
#define ADD_FAR(bulk, acc, left, right) \
bulk = (acc * ww) + (lineIn[left] + lineIn[right]) * fw;
#define SAVE(x, bulk) \
lineOut[x] = (UINT8)((bulk + (1 << 23)) >> 24)
#define SAVE(x, bulk) lineOut[x] = (UINT8)((bulk + (1 << 23)) >> 24)
acc = lineIn[0] * (radius + 1);
for (x = 0; x < edgeA - 1; x++) {
@ -125,8 +127,7 @@ ImagingLineBoxBlur8(UINT8 *lineOut, UINT8 *lineIn, int lastx, int radius, int ed
}
acc += lineIn[lastx] * (radius - edgeA + 1);
if (edgeA <= edgeB)
{
if (edgeA <= edgeB) {
for (x = 0; x < edgeA; x++) {
MOVE_ACC(acc, 0, x + radius);
ADD_FAR(bulk, acc, 0, x + radius + 1);
@ -142,9 +143,7 @@ ImagingLineBoxBlur8(UINT8 *lineOut, UINT8 *lineIn, int lastx, int radius, int ed
ADD_FAR(bulk, acc, x - radius - 1, lastx);
SAVE(x, bulk);
}
}
else
{
} else {
for (x = 0; x < edgeB; x++) {
MOVE_ACC(acc, 0, x + radius);
ADD_FAR(bulk, acc, 0, x + radius + 1);
@ -167,11 +166,8 @@ ImagingLineBoxBlur8(UINT8 *lineOut, UINT8 *lineIn, int lastx, int radius, int ed
#undef SAVE
}
Imaging
ImagingHorizontalBoxBlur(Imaging imOut, Imaging imIn, float floatRadius)
{
ImagingHorizontalBoxBlur(Imaging imOut, Imaging imIn, float floatRadius) {
ImagingSectionCookie cookie;
int y;
@ -192,32 +188,33 @@ ImagingHorizontalBoxBlur(Imaging imOut, Imaging imIn, float floatRadius)
ImagingSectionEnter(&cookie);
if (imIn->image8)
{
if (imIn->image8) {
for (y = 0; y < imIn->ysize; y++) {
ImagingLineBoxBlur8(
(imIn == imOut ? (UINT8 *)lineOut : imOut->image8[y]),
imIn->image8[y],
imIn->xsize - 1,
radius, edgeA, edgeB,
ww, fw
);
radius,
edgeA,
edgeB,
ww,
fw);
if (imIn == imOut) {
// Commit.
memcpy(imOut->image8[y], lineOut, imIn->xsize);
}
}
}
else
{
} else {
for (y = 0; y < imIn->ysize; y++) {
ImagingLineBoxBlur32(
imIn == imOut ? (pixel *)lineOut : (pixel *)imOut->image32[y],
(pixel *)imIn->image32[y],
imIn->xsize - 1,
radius, edgeA, edgeB,
ww, fw
);
radius,
edgeA,
edgeB,
ww,
fw);
if (imIn == imOut) {
// Commit.
memcpy(imOut->image32[y], lineOut, imIn->xsize * 4);
@ -232,23 +229,17 @@ ImagingHorizontalBoxBlur(Imaging imOut, Imaging imIn, float floatRadius)
return imOut;
}
Imaging
ImagingBoxBlur(Imaging imOut, Imaging imIn, float radius, int n)
{
ImagingBoxBlur(Imaging imOut, Imaging imIn, float radius, int n) {
int i;
Imaging imTransposed;
if (n < 1) {
return ImagingError_ValueError(
"number of passes must be greater than zero"
);
return ImagingError_ValueError("number of passes must be greater than zero");
}
if (strcmp(imIn->mode, imOut->mode) ||
imIn->type != imOut->type ||
imIn->bands != imOut->bands ||
imIn->xsize != imOut->xsize ||
if (strcmp(imIn->mode, imOut->mode) || imIn->type != imOut->type ||
imIn->bands != imOut->bands || imIn->xsize != imOut->xsize ||
imIn->ysize != imOut->ysize) {
return ImagingError_Mismatch();
}
@ -257,14 +248,10 @@ ImagingBoxBlur(Imaging imOut, Imaging imIn, float radius, int n)
return ImagingError_ModeError();
}
if (!(strcmp(imIn->mode, "RGB") == 0 ||
strcmp(imIn->mode, "RGBA") == 0 ||
strcmp(imIn->mode, "RGBa") == 0 ||
strcmp(imIn->mode, "RGBX") == 0 ||
strcmp(imIn->mode, "CMYK") == 0 ||
strcmp(imIn->mode, "L") == 0 ||
strcmp(imIn->mode, "LA") == 0 ||
strcmp(imIn->mode, "La") == 0)) {
if (!(strcmp(imIn->mode, "RGB") == 0 || strcmp(imIn->mode, "RGBA") == 0 ||
strcmp(imIn->mode, "RGBa") == 0 || strcmp(imIn->mode, "RGBX") == 0 ||
strcmp(imIn->mode, "CMYK") == 0 || strcmp(imIn->mode, "L") == 0 ||
strcmp(imIn->mode, "LA") == 0 || strcmp(imIn->mode, "La") == 0)) {
return ImagingError_ModeError();
}
@ -295,10 +282,8 @@ ImagingBoxBlur(Imaging imOut, Imaging imIn, float radius, int n)
return imOut;
}
Imaging ImagingGaussianBlur(Imaging imOut, Imaging imIn, float radius,
int passes)
{
Imaging
ImagingGaussianBlur(Imaging imOut, Imaging imIn, float radius, int passes) {
float sigma2, L, l, a;
sigma2 = radius * radius / passes;

73
src/libImaging/Chops.c
View File

@ -16,7 +16,6 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
#define CHOP(operation) \
@ -61,16 +60,14 @@
return imOut;
static Imaging
create(Imaging im1, Imaging im2, char* mode)
{
create(Imaging im1, Imaging im2, char *mode) {
int xsize, ysize;
if (!im1 || !im2 || im1->type != IMAGING_TYPE_UINT8 ||
(mode != NULL && (strcmp(im1->mode, "1") || strcmp(im2->mode, "1")))) {
return (Imaging)ImagingError_ModeError();
}
if (im1->type != im2->type ||
im1->bands != im2->bands) {
if (im1->type != im2->type || im1->bands != im2->bands) {
return (Imaging)ImagingError_Mismatch();
}
@ -81,97 +78,85 @@ create(Imaging im1, Imaging im2, char* mode)
}
Imaging
ImagingChopLighter(Imaging imIn1, Imaging imIn2)
{
ImagingChopLighter(Imaging imIn1, Imaging imIn2) {
CHOP((in1[x] > in2[x]) ? in1[x] : in2[x]);
}
Imaging
ImagingChopDarker(Imaging imIn1, Imaging imIn2)
{
ImagingChopDarker(Imaging imIn1, Imaging imIn2) {
CHOP((in1[x] < in2[x]) ? in1[x] : in2[x]);
}
Imaging
ImagingChopDifference(Imaging imIn1, Imaging imIn2)
{
ImagingChopDifference(Imaging imIn1, Imaging imIn2) {
CHOP(abs((int)in1[x] - (int)in2[x]));
}
Imaging
ImagingChopMultiply(Imaging imIn1, Imaging imIn2)
{
ImagingChopMultiply(Imaging imIn1, Imaging imIn2) {
CHOP((int)in1[x] * (int)in2[x] / 255);
}
Imaging
ImagingChopScreen(Imaging imIn1, Imaging imIn2)
{
ImagingChopScreen(Imaging imIn1, Imaging imIn2) {
CHOP(255 - ((int)(255 - in1[x]) * (int)(255 - in2[x])) / 255);
}
Imaging
ImagingChopAdd(Imaging imIn1, Imaging imIn2, float scale, int offset)
{
ImagingChopAdd(Imaging imIn1, Imaging imIn2, float scale, int offset) {
CHOP(((int)in1[x] + (int)in2[x]) / scale + offset);
}
Imaging
ImagingChopSubtract(Imaging imIn1, Imaging imIn2, float scale, int offset)
{
ImagingChopSubtract(Imaging imIn1, Imaging imIn2, float scale, int offset) {
CHOP(((int)in1[x] - (int)in2[x]) / scale + offset);
}
Imaging
ImagingChopAnd(Imaging imIn1, Imaging imIn2)
{
ImagingChopAnd(Imaging imIn1, Imaging imIn2) {
CHOP2((in1[x] && in2[x]) ? 255 : 0, "1");
}
Imaging
ImagingChopOr(Imaging imIn1, Imaging imIn2)
{
ImagingChopOr(Imaging imIn1, Imaging imIn2) {
CHOP2((in1[x] || in2[x]) ? 255 : 0, "1");
}
Imaging
ImagingChopXor(Imaging imIn1, Imaging imIn2)
{
ImagingChopXor(Imaging imIn1, Imaging imIn2) {
CHOP2(((in1[x] != 0) ^ (in2[x] != 0)) ? 255 : 0, "1");
}
Imaging
ImagingChopAddModulo(Imaging imIn1, Imaging imIn2)
{
ImagingChopAddModulo(Imaging imIn1, Imaging imIn2) {
CHOP2(in1[x] + in2[x], NULL);
}
Imaging
ImagingChopSubtractModulo(Imaging imIn1, Imaging imIn2)
{
ImagingChopSubtractModulo(Imaging imIn1, Imaging imIn2) {
CHOP2(in1[x] - in2[x], NULL);
}
Imaging
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 );
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
ImagingChopHardLight(Imaging imIn1, Imaging imIn2)
{
CHOP2( (in2[x]<128) ? ( (in1[x]*in2[x])/127)
: 255 - ( ((255-in2[x]) * (255-in1[x])) / 127)
, NULL);
ImagingChopHardLight(Imaging imIn1, Imaging imIn2) {
CHOP2(
(in2[x] < 128) ? ((in1[x] * in2[x]) / 127)
: 255 - (((255 - in2[x]) * (255 - in1[x])) / 127),
NULL);
}
Imaging
ImagingOverlay(Imaging imIn1, Imaging imIn2)
{
CHOP2( (in1[x]<128) ? ( (in1[x]*in2[x])/127)
: 255 - ( ((255-in1[x]) * (255-in2[x])) / 127)
, NULL);
ImagingOverlay(Imaging imIn1, Imaging imIn2) {
CHOP2(
(in1[x] < 128) ? ((in1[x] * in2[x]) / 127)
: 255 - (((255 - in1[x]) * (255 - in2[x])) / 127),
NULL);
}

97
src/libImaging/ColorLUT.c
View File

@ -1,7 +1,6 @@
#include "Imaging.h"
#include <math.h>
/* 8 bits for result. Table can overflow [0, 1.0] range,
so we need extra bits for overflow and negative values.
NOTE: This value should be the same as in _imaging/_prepare_lut_table() */
@ -16,23 +15,20 @@
#define SHIFT_BITS (16 - 1)
static inline UINT8 clip8(int in)
{
static inline UINT8
clip8(int in) {
return clip8_lookups[(in + PRECISION_ROUNDING) >> PRECISION_BITS];
}
static inline void
interpolate3(INT16 out[3], const INT16 a[3], const INT16 b[3], INT16 shift)
{
interpolate3(INT16 out[3], const INT16 a[3], const INT16 b[3], INT16 shift) {
out[0] = (a[0] * ((1 << SHIFT_BITS) - shift) + b[0] * shift) >> SHIFT_BITS;
out[1] = (a[1] * ((1 << SHIFT_BITS) - shift) + b[1] * shift) >> SHIFT_BITS;
out[2] = (a[2] * ((1 << SHIFT_BITS) - shift) + b[2] * shift) >> SHIFT_BITS;
}
static inline void
interpolate4(INT16 out[4], const INT16 a[4], const INT16 b[4], INT16 shift)
{
interpolate4(INT16 out[4], const INT16 a[4], const INT16 b[4], INT16 shift) {
out[0] = (a[0] * ((1 << SHIFT_BITS) - shift) + b[0] * shift) >> SHIFT_BITS;
out[1] = (a[1] * ((1 << SHIFT_BITS) - shift) + b[1] * shift) >> SHIFT_BITS;
out[2] = (a[2] * ((1 << SHIFT_BITS) - shift) + b[2] * shift) >> SHIFT_BITS;
@ -40,13 +36,10 @@ interpolate4(INT16 out[4], const INT16 a[4], const INT16 b[4], INT16 shift)
}
static inline int
table_index3D(int index1D, int index2D, int index3D,
int size1D, int size1D_2D)
{
table_index3D(int index1D, int index2D, int index3D, int size1D, int size1D_2D) {
return index1D + index2D * size1D + index3D * size1D_2D;
}
/*
Transforms colors of imIn using provided 3D lookup table
and puts the result in imOut. Returns imOut on success or 0 on error.
@ -63,10 +56,14 @@ table_index3D(int index1D, int index2D, int index3D,
and 255 << PRECISION_BITS (16320) is highest value.
*/
Imaging
ImagingColorLUT3D_linear(Imaging imOut, Imaging imIn, int table_channels,
int size1D, int size2D, int size3D,
INT16* table)
{
ImagingColorLUT3D_linear(
Imaging imOut,
Imaging imIn,
int table_channels,
int size1D,
int size2D,
int size3D,
INT16 *table) {
/* This float to int conversion doesn't have rounding
error compensation (+0.5) for two reasons:
1. As we don't hit the highest value,
@ -89,11 +86,8 @@ ImagingColorLUT3D_linear(Imaging imOut, Imaging imIn, int table_channels,
return NULL;
}
if (imIn->type != IMAGING_TYPE_UINT8 ||
imOut->type != IMAGING_TYPE_UINT8 ||
imIn->bands < 3 ||
imOut->bands < table_channels
) {
if (imIn->type != IMAGING_TYPE_UINT8 || imOut->type != IMAGING_TYPE_UINT8 ||
imIn->bands < 3 || imOut->bands < table_channels) {
return (Imaging)ImagingError_ModeError();
}
@ -114,50 +108,75 @@ ImagingColorLUT3D_linear(Imaging imOut, Imaging imIn, int table_channels,
INT16 shift2D = (SCALE_MASK & index2D) >> (SCALE_BITS - SHIFT_BITS);
INT16 shift3D = (SCALE_MASK & index3D) >> (SCALE_BITS - SHIFT_BITS);
int idx = table_channels * table_index3D(
index1D >> SCALE_BITS, index2D >> SCALE_BITS,
index3D >> SCALE_BITS, size1D, size1D_2D);
index1D >> SCALE_BITS,
index2D >> SCALE_BITS,
index3D >> SCALE_BITS,
size1D,
size1D_2D);
INT16 result[4], left[4], right[4];
INT16 leftleft[4], leftright[4], rightleft[4], rightright[4];
if (table_channels == 3) {
UINT32 v;
interpolate3(leftleft, &table[idx + 0], &table[idx + 3], shift1D);
interpolate3(leftright, &table[idx + size1D*3],
&table[idx + size1D*3 + 3], shift1D);
interpolate3(
leftright,
&table[idx + size1D * 3],
&table[idx + size1D * 3 + 3],
shift1D);
interpolate3(left, leftleft, leftright, shift2D);
interpolate3(rightleft, &table[idx + size1D_2D*3],
&table[idx + size1D_2D*3 + 3], shift1D);
interpolate3(rightright, &table[idx + size1D_2D*3 + size1D*3],
&table[idx + size1D_2D*3 + size1D*3 + 3], shift1D);
interpolate3(
rightleft,
&table[idx + size1D_2D * 3],
&table[idx + size1D_2D * 3 + 3],
shift1D);
interpolate3(
rightright,
&table[idx + size1D_2D * 3 + size1D * 3],
&table[idx + size1D_2D * 3 + size1D * 3 + 3],
shift1D);
interpolate3(right, rightleft, rightright, shift2D);
interpolate3(result, left, right, shift3D);
v = MAKE_UINT32(
clip8(result[0]), clip8(result[1]),
clip8(result[2]), rowIn[x*4 + 3]);
clip8(result[0]),
clip8(result[1]),
clip8(result[2]),
rowIn[x * 4 + 3]);
memcpy(rowOut + x * sizeof(v), &v, sizeof(v));
}
if (table_channels == 4) {
UINT32 v;
interpolate4(leftleft, &table[idx + 0], &table[idx + 4], shift1D);
interpolate4(leftright, &table[idx + size1D*4],
&table[idx + size1D*4 + 4], shift1D);
interpolate4(
leftright,
&table[idx + size1D * 4],
&table[idx + size1D * 4 + 4],
shift1D);
interpolate4(left, leftleft, leftright, shift2D);
interpolate4(rightleft, &table[idx + size1D_2D*4],
&table[idx + size1D_2D*4 + 4], shift1D);
interpolate4(rightright, &table[idx + size1D_2D*4 + size1D*4],
&table[idx + size1D_2D*4 + size1D*4 + 4], shift1D);
interpolate4(
rightleft,
&table[idx + size1D_2D * 4],
&table[idx + size1D_2D * 4 + 4],
shift1D);
interpolate4(
rightright,
&table[idx + size1D_2D * 4 + size1D * 4],
&table[idx + size1D_2D * 4 + size1D * 4 + 4],
shift1D);
interpolate4(right, rightleft, rightright, shift2D);
interpolate4(result, left, right, shift3D);
v = MAKE_UINT32(
clip8(result[0]), clip8(result[1]),
clip8(result[2]), clip8(result[3]));
clip8(result[0]),
clip8(result[1]),
clip8(result[2]),
clip8(result[3]));
memcpy(rowOut + x * sizeof(v), &v, sizeof(v));
}
}

419
src/libImaging/Convert.c
View File

File diff suppressed because it is too large Load Diff

572
src/libImaging/ConvertYCbCr.c
View File

@ -28,322 +28,300 @@
#define SCALE 6 /* bits */
static INT16 Y_R[] = { 0, 19, 38, 57, 77, 96, 115, 134, 153, 172, 191,
210, 230, 249, 268, 287, 306, 325, 344, 364, 383, 402, 421, 440, 459,
478, 498, 517, 536, 555, 574, 593, 612, 631, 651, 670, 689, 708, 727,
746, 765, 785, 804, 823, 842, 861, 880, 899, 919, 938, 957, 976, 995,
1014, 1033, 1052, 1072, 1091, 1110, 1129, 1148, 1167, 1186, 1206,
1225, 1244, 1263, 1282, 1301, 1320, 1340, 1359, 1378, 1397, 1416,
1435, 1454, 1473, 1493, 1512, 1531, 1550, 1569, 1588, 1607, 1627,
1646, 1665, 1684, 1703, 1722, 1741, 1761, 1780, 1799, 1818, 1837,
1856, 1875, 1894, 1914, 1933, 1952, 1971, 1990, 2009, 2028, 2048,
2067, 2086, 2105, 2124, 2143, 2162, 2182, 2201, 2220, 2239, 2258,
2277, 2296, 2315, 2335, 2354, 2373, 2392, 2411, 2430, 2449, 2469,
2488, 2507, 2526, 2545, 2564, 2583, 2602, 2622, 2641, 2660, 2679,
2698, 2717, 2736, 2756, 2775, 2794, 2813, 2832, 2851, 2870, 2890,
2909, 2928, 2947, 2966, 2985, 3004, 3023, 3043, 3062, 3081, 3100,
3119, 3138, 3157, 3177, 3196, 3215, 3234, 3253, 3272, 3291, 3311,
3330, 3349, 3368, 3387, 3406, 3425, 3444, 3464, 3483, 3502, 3521,
3540, 3559, 3578, 3598, 3617, 3636, 3655, 3674, 3693, 3712, 3732,
3751, 3770, 3789, 3808, 3827, 3846, 3865, 3885, 3904, 3923, 3942,
3961, 3980, 3999, 4019, 4038, 4057, 4076, 4095, 4114, 4133, 4153,
4172, 4191, 4210, 4229, 4248, 4267, 4286, 4306, 4325, 4344, 4363,
4382, 4401, 4420, 4440, 4459, 4478, 4497, 4516, 4535, 4554, 4574,
4593, 4612, 4631, 4650, 4669, 4688, 4707, 4727, 4746, 4765, 4784,
4803, 4822, 4841, 4861, 4880 };
static INT16 Y_R[] = {
0, 19, 38, 57, 77, 96, 115, 134, 153, 172, 191, 210, 230, 249,
268, 287, 306, 325, 344, 364, 383, 402, 421, 440, 459, 478, 498, 517,
536, 555, 574, 593, 612, 631, 651, 670, 689, 708, 727, 746, 765, 785,
804, 823, 842, 861, 880, 899, 919, 938, 957, 976, 995, 1014, 1033, 1052,
1072, 1091, 1110, 1129, 1148, 1167, 1186, 1206, 1225, 1244, 1263, 1282, 1301, 1320,
1340, 1359, 1378, 1397, 1416, 1435, 1454, 1473, 1493, 1512, 1531, 1550, 1569, 1588,
1607, 1627, 1646, 1665, 1684, 1703, 1722, 1741, 1761, 1780, 1799, 1818, 1837, 1856,
1875, 1894, 1914, 1933, 1952, 1971, 1990, 2009, 2028, 2048, 2067, 2086, 2105, 2124,
2143, 2162, 2182, 2201, 2220, 2239, 2258, 2277, 2296, 2315, 2335, 2354, 2373, 2392,
2411, 2430, 2449, 2469, 2488, 2507, 2526, 2545, 2564, 2583, 2602, 2622, 2641, 2660,
2679, 2698, 2717, 2736, 2756, 2775, 2794, 2813, 2832, 2851, 2870, 2890, 2909, 2928,
2947, 2966, 2985, 3004, 3023, 3043, 3062, 3081, 3100, 3119, 3138, 3157, 3177, 3196,
3215, 3234, 3253, 3272, 3291, 3311, 3330, 3349, 3368, 3387, 3406, 3425, 3444, 3464,
3483, 3502, 3521, 3540, 3559, 3578, 3598, 3617, 3636, 3655, 3674, 3693, 3712, 3732,
3751, 3770, 3789, 3808, 3827, 3846, 3865, 3885, 3904, 3923, 3942, 3961, 3980, 3999,
4019, 4038, 4057, 4076, 4095, 4114, 4133, 4153, 4172, 4191, 4210, 4229, 4248, 4267,
4286, 4306, 4325, 4344, 4363, 4382, 4401, 4420, 4440, 4459, 4478, 4497, 4516, 4535,
4554, 4574, 4593, 4612, 4631, 4650, 4669, 4688, 4707, 4727, 4746, 4765, 4784, 4803,
4822, 4841, 4861, 4880};
static INT16 Y_G[] = { 0, 38, 75, 113, 150, 188, 225, 263, 301, 338,
376, 413, 451, 488, 526, 564, 601, 639, 676, 714, 751, 789, 826, 864,
902, 939, 977, 1014, 1052, 1089, 1127, 1165, 1202, 1240, 1277, 1315,
1352, 1390, 1428, 1465, 1503, 1540, 1578, 1615, 1653, 1691, 1728,
1766, 1803, 1841, 1878, 1916, 1954, 1991, 2029, 2066, 2104, 2141,
2179, 2217, 2254, 2292, 2329, 2367, 2404, 2442, 2479, 2517, 2555,
2592, 2630, 2667, 2705, 2742, 2780, 2818, 2855, 2893, 2930, 2968,
3005, 3043, 3081, 3118, 3156, 3193, 3231, 3268, 3306, 3344, 3381,
3419, 3456, 3494, 3531, 3569, 3607, 3644, 3682, 3719, 3757, 3794,
3832, 3870, 3907, 3945, 3982, 4020, 4057, 4095, 4132, 4170, 4208,
4245, 4283, 4320, 4358, 4395, 4433, 4471, 4508, 4546, 4583, 4621,
4658, 4696, 4734, 4771, 4809, 4846, 4884, 4921, 4959, 4997, 5034,
5072, 5109, 5147, 5184, 5222, 5260, 5297, 5335, 5372, 5410, 5447,
5485, 5522, 5560, 5598, 5635, 5673, 5710, 5748, 5785, 5823, 5861,
5898, 5936, 5973, 6011, 6048, 6086, 6124, 6161, 6199, 6236, 6274,
6311, 6349, 6387, 6424, 6462, 6499, 6537, 6574, 6612, 6650, 6687,
6725, 6762, 6800, 6837, 6875, 6913, 6950, 6988, 7025, 7063, 7100,
7138, 7175, 7213, 7251, 7288, 7326, 7363, 7401, 7438, 7476, 7514,
7551, 7589, 7626, 7664, 7701, 7739, 7777, 7814, 7852, 7889, 7927,
7964, 8002, 8040, 8077, 8115, 8152, 8190, 8227, 8265, 8303, 8340,
8378, 8415, 8453, 8490, 8528, 8566, 8603, 8641, 8678, 8716, 8753,
8791, 8828, 8866, 8904, 8941, 8979, 9016, 9054, 9091, 9129, 9167,
9204, 9242, 9279, 9317, 9354, 9392, 9430, 9467, 9505, 9542, 9580 };
static INT16 Y_G[] = {
0, 38, 75, 113, 150, 188, 225, 263, 301, 338, 376, 413, 451, 488,
526, 564, 601, 639, 676, 714, 751, 789, 826, 864, 902, 939, 977, 1014,
1052, 1089, 1127, 1165, 1202, 1240, 1277, 1315, 1352, 1390, 1428, 1465, 1503, 1540,
1578, 1615, 1653, 1691, 1728, 1766, 1803, 1841, 1878, 1916, 1954, 1991, 2029, 2066,
2104, 2141, 2179, 2217, 2254, 2292, 2329, 2367, 2404, 2442, 2479, 2517, 2555, 2592,
2630, 2667, 2705, 2742, 2780, 2818, 2855, 2893, 2930, 2968, 3005, 3043, 3081, 3118,
3156, 3193, 3231, 3268, 3306, 3344, 3381, 3419, 3456, 3494, 3531, 3569, 3607, 3644,
3682, 3719, 3757, 3794, 3832, 3870, 3907, 3945, 3982, 4020, 4057, 4095, 4132, 4170,
4208, 4245, 4283, 4320, 4358, 4395, 4433, 4471, 4508, 4546, 4583, 4621, 4658, 4696,
4734, 4771, 4809, 4846, 4884, 4921, 4959, 4997, 5034, 5072, 5109, 5147, 5184, 5222,
5260, 5297, 5335, 5372, 5410, 5447, 5485, 5522, 5560, 5598, 5635, 5673, 5710, 5748,
5785, 5823, 5861, 5898, 5936, 5973, 6011, 6048, 6086, 6124, 6161, 6199, 6236, 6274,
6311, 6349, 6387, 6424, 6462, 6499, 6537, 6574, 6612, 6650, 6687, 6725, 6762, 6800,
6837, 6875, 6913, 6950, 6988, 7025, 7063, 7100, 7138, 7175, 7213, 7251, 7288, 7326,
7363, 7401, 7438, 7476, 7514, 7551, 7589, 7626, 7664, 7701, 7739, 7777, 7814, 7852,
7889, 7927, 7964, 8002, 8040, 8077, 8115, 8152, 8190, 8227, 8265, 8303, 8340, 8378,
8415, 8453, 8490, 8528, 8566, 8603, 8641, 8678, 8716, 8753, 8791, 8828, 8866, 8904,
8941, 8979, 9016, 9054, 9091, 9129, 9167, 9204, 9242, 9279, 9317, 9354, 9392, 9430,
9467, 9505, 9542, 9580};
static INT16 Y_B[] = { 0, 7, 15, 22, 29, 36, 44, 51, 58, 66, 73, 80,
88, 95, 102, 109, 117, 124, 131, 139, 146, 153, 161, 168, 175, 182,
190, 197, 204, 212, 219, 226, 233, 241, 248, 255, 263, 270, 277, 285,
292, 299, 306, 314, 321, 328, 336, 343, 350, 358, 365, 372, 379, 387,
394, 401, 409, 416, 423, 430, 438, 445, 452, 460, 467, 474, 482, 489,
496, 503, 511, 518, 525, 533, 540, 547, 554, 562, 569, 576, 584, 591,
598, 606, 613, 620, 627, 635, 642, 649, 657, 664, 671, 679, 686, 693,
700, 708, 715, 722, 730, 737, 744, 751, 759, 766, 773, 781, 788, 795,
803, 810, 817, 824, 832, 839, 846, 854, 861, 868, 876, 883, 890, 897,
905, 912, 919, 927, 934, 941, 948, 956, 963, 970, 978, 985, 992, 1000,
1007, 1014, 1021, 1029, 1036, 1043, 1051, 1058, 1065, 1073, 1080,
1087, 1094, 1102, 1109, 1116, 1124, 1131, 1138, 1145, 1153, 1160,
1167, 1175, 1182, 1189, 1197, 1204, 1211, 1218, 1226, 1233, 1240,
1248, 1255, 1262, 1270, 1277, 1284, 1291, 1299, 1306, 1313, 1321,
1328, 1335, 1342, 1350, 1357, 1364, 1372, 1379, 1386, 1394, 1401,
1408, 1415, 1423, 1430, 1437, 1445, 1452, 1459, 1466, 1474, 1481,
1488, 1496, 1503, 1510, 1518, 1525, 1532, 1539, 1547, 1554, 1561,
1569, 1576, 1583, 1591, 1598, 1605, 1612, 1620, 1627, 1634, 1642,
1649, 1656, 1663, 1671, 1678, 1685, 1693, 1700, 1707, 1715, 1722,
1729, 1736, 1744, 1751, 1758, 1766, 1773, 1780, 1788, 1795, 1802,
1809, 1817, 1824, 1831, 1839, 1846, 1853, 1860 };
static INT16 Y_B[] = {
0, 7, 15, 22, 29, 36, 44, 51, 58, 66, 73, 80, 88, 95,
102, 109, 117, 124, 131, 139, 146, 153, 161, 168, 175, 182, 190, 197,
204, 212, 219, 226, 233, 241, 248, 255, 263, 270, 277, 285, 292, 299,
306, 314, 321, 328, 336, 343, 350, 358, 365, 372, 379, 387, 394, 401,
409, 416, 423, 430, 438, 445, 452, 460, 467, 474, 482, 489, 496, 503,
511, 518, 525, 533, 540, 547, 554, 562, 569, 576, 584, 591, 598, 606,
613, 620, 627, 635, 642, 649, 657, 664, 671, 679, 686, 693, 700, 708,
715, 722, 730, 737, 744, 751, 759, 766, 773, 781, 788, 795, 803, 810,
817, 824, 832, 839, 846, 854, 861, 868, 876, 883, 890, 897, 905, 912,
919, 927, 934, 941, 948, 956, 963, 970, 978, 985, 992, 1000, 1007, 1014,
1021, 1029, 1036, 1043, 1051, 1058, 1065, 1073, 1080, 1087, 1094, 1102, 1109, 1116,
1124, 1131, 1138, 1145, 1153, 1160, 1167, 1175, 1182, 1189, 1197, 1204, 1211, 1218,
1226, 1233, 1240, 1248, 1255, 1262, 1270, 1277, 1284, 1291, 1299, 1306, 1313, 1321,
1328, 1335, 1342, 1350, 1357, 1364, 1372, 1379, 1386, 1394, 1401, 1408, 1415, 1423,
1430, 1437, 1445, 1452, 1459, 1466, 1474, 1481, 1488, 1496, 1503, 1510, 1518, 1525,
1532, 1539, 1547, 1554, 1561, 1569, 1576, 1583, 1591, 1598, 1605, 1612, 1620, 1627,
1634, 1642, 1649, 1656, 1663, 1671, 1678, 1685, 1693, 1700, 1707, 1715, 1722, 1729,
1736, 1744, 1751, 1758, 1766, 1773, 1780, 1788, 1795, 1802, 1809, 1817, 1824, 1831,
1839, 1846, 1853, 1860};
static INT16 Cb_R[] = { 0, -10, -21, -31, -42, -53, -64, -75, -85,
-96, -107, -118, -129, -139, -150, -161, -172, -183, -193, -204, -215,
-226, -237, -247, -258, -269, -280, -291, -301, -312, -323, -334,
-345, -355, -366, -377, -388, -399, -409, -420, -431, -442, -453,
-463, -474, -485, -496, -507, -517, -528, -539, -550, -561, -571,
-582, -593, -604, -615, -625, -636, -647, -658, -669, -679, -690,
-701, -712, -723, -733, -744, -755, -766, -777, -787, -798, -809,
-820, -831, -841, -852, -863, -874, -885, -895, -906, -917, -928,
-939, -949, -960, -971, -982, -993, -1003, -1014, -1025, -1036, -1047,
-1057, -1068, -1079, -1090, -1101, -1111, -1122, -1133, -1144, -1155,
-1165, -1176, -1187, -1198, -1209, -1219, -1230, -1241, -1252, -1263,
-1273, -1284, -1295, -1306, -1317, -1327, -1338, -1349, -1360, -1371,
-1381, -1392, -1403, -1414, -1425, -1435, -1446, -1457, -1468, -1479,
-1489, -1500, -1511, -1522, -1533, -1543, -1554, -1565, -1576, -1587,
-1597, -1608, -1619, -1630, -1641, -1651, -1662, -1673, -1684, -1694,
-1705, -1716, -1727, -1738, -1748, -1759, -1770, -1781, -1792, -1802,
-1813, -1824, -1835, -1846, -1856, -1867, -1878, -1889, -1900, -1910,
-1921, -1932, -1943, -1954, -1964, -1975, -1986, -1997, -2008, -2018,
-2029, -2040, -2051, -2062, -2072, -2083, -2094, -2105, -2116, -2126,
-2137, -2148, -2159, -2170, -2180, -2191, -2202, -2213, -2224, -2234,
-2245, -2256, -2267, -2278, -2288, -2299, -2310, -2321, -2332, -2342,
-2353, -2364, -2375, -2386, -2396, -2407, -2418, -2429, -2440, -2450,
-2461, -2472, -2483, -2494, -2504, -2515, -2526, -2537, -2548, -2558,
-2569, -2580, -2591, -2602, -2612, -2623, -2634, -2645, -2656, -2666,
-2677, -2688, -2699, -2710, -2720, -2731, -2742, -2753 };
static INT16 Cb_R[] = {
0, -10, -21, -31, -42, -53, -64, -75, -85, -96, -107, -118,
-129, -139, -150, -161, -172, -183, -193, -204, -215, -226, -237, -247,
-258, -269, -280, -291, -301, -312, -323, -334, -345, -355, -366, -377,
-388, -399, -409, -420, -431, -442, -453, -463, -474, -485, -496, -507,
-517, -528, -539, -550, -561, -571, -582, -593, -604, -615, -625, -636,
-647, -658, -669, -679, -690, -701, -712, -723, -733, -744, -755, -766,
-777, -787, -798, -809, -820, -831, -841, -852, -863, -874, -885, -895,
-906, -917, -928, -939, -949, -960, -971, -982, -993, -1003, -1014, -1025,
-1036, -1047, -1057, -1068, -1079, -1090, -1101, -1111, -1122, -1133, -1144, -1155,
-1165, -1176, -1187, -1198, -1209, -1219, -1230, -1241, -1252, -1263, -1273, -1284,
-1295, -1306, -1317, -1327, -1338, -1349, -1360, -1371, -1381, -1392, -1403, -1414,
-1425, -1435, -1446, -1457, -1468, -1479, -1489, -1500, -1511, -1522, -1533, -1543,
-1554, -1565, -1576, -1587, -1597, -1608, -1619, -1630, -1641, -1651, -1662, -1673,
-1684, -1694, -1705, -1716, -1727, -1738, -1748, -1759, -1770, -1781, -1792, -1802,
-1813, -1824, -1835, -1846, -1856, -1867, -1878, -1889, -1900, -1910, -1921, -1932,
-1943, -1954, -1964, -1975, -1986, -1997, -2008, -2018, -2029, -2040, -2051, -2062,
-2072, -2083, -2094, -2105, -2116, -2126, -2137, -2148, -2159, -2170, -2180, -2191,
-2202, -2213, -2224, -2234, -2245, -2256, -2267, -2278, -2288, -2299, -2310, -2321,
-2332, -2342, -2353, -2364, -2375, -2386, -2396, -2407, -2418, -2429, -2440, -2450,
-2461, -2472, -2483, -2494, -2504, -2515, -2526, -2537, -2548, -2558, -2569, -2580,
-2591, -2602, -2612, -2623, -2634, -2645, -2656, -2666, -2677, -2688, -2699, -2710,
-2720, -2731, -2742, -2753};
static INT16 Cb_G[] = { 0, -20, -41, -63, -84, -105, -126, -147, -169,
-190, -211, -232, -253, -275, -296, -317, -338, -359, -381, -402,
-423, -444, -465, -487, -508, -529, -550, -571, -593, -614, -635,
-656, -677, -699, -720, -741, -762, -783, -805, -826, -847, -868,
-889, -911, -932, -953, -974, -995, -1017, -1038, -1059, -1080, -1101,
-1123, -1144, -1165, -1186, -1207, -1229, -1250, -1271, -1292, -1313,
-1335, -1356, -1377, -1398, -1419, -1441, -1462, -1483, -1504, -1525,
-1547, -1568, -1589, -1610, -1631, -1653, -1674, -1695, -1716, -1737,
-1759, -1780, -1801, -1822, -1843, -1865, -1886, -1907, -1928, -1949,
-1971, -1992, -2013, -2034, -2055, -2077, -2098, -2119, -2140, -2161,
-2183, -2204, -2225, -2246, -2267, -2289, -2310, -2331, -2352, -2373,
-2395, -2416, -2437, -2458, -2479, -2501, -2522, -2543, -2564, -2585,
-2607, -2628, -2649, -2670, -2691, -2713, -2734, -2755, -2776, -2797,
-2819, -2840, -2861, -2882, -2903, -2925, -2946, -2967, -2988, -3009,
-3031, -3052, -3073, -3094, -3115, -3137, -3158, -3179, -3200, -3221,
-3243, -3264, -3285, -3306, -3328, -3349, -3370, -3391, -3412, -3434,
-3455, -3476, -3497, -3518, -3540, -3561, -3582, -3603, -3624, -3646,
-3667, -3688, -3709, -3730, -3752, -3773, -3794, -3815, -3836, -3858,
-3879, -3900, -3921, -3942, -3964, -3985, -4006, -4027, -4048, -4070,
-4091, -4112, -4133, -4154, -4176, -4197, -4218, -4239, -4260, -4282,
-4303, -4324, -4345, -4366, -4388, -4409, -4430, -4451, -4472, -4494,
-4515, -4536, -4557, -4578, -4600, -4621, -4642, -4663, -4684, -4706,
-4727, -4748, -4769, -4790, -4812, -4833, -4854, -4875, -4896, -4918,
-4939, -4960, -4981, -5002, -5024, -5045, -5066, -5087, -5108, -5130,
-5151, -5172, -5193, -5214, -5236, -5257, -5278, -5299, -5320, -5342,
-5363, -5384, -5405 };
static INT16 Cb_G[] = {
0, -20, -41, -63, -84, -105, -126, -147, -169, -190, -211, -232,
-253, -275, -296, -317, -338, -359, -381, -402, -423, -444, -465, -487,
-508, -529, -550, -571, -593, -614, -635, -656, -677, -699, -720, -741,
-762, -783, -805, -826, -847, -868, -889, -911, -932, -953, -974, -995,
-1017, -1038, -1059, -1080, -1101, -1123, -1144, -1165, -1186, -1207, -1229, -1250,
-1271, -1292, -1313, -1335, -1356, -1377, -1398, -1419, -1441, -1462, -1483, -1504,
-1525, -1547, -1568, -1589, -1610, -1631, -1653, -1674, -1695, -1716, -1737, -1759,
-1780, -1801, -1822, -1843, -1865, -1886, -1907, -1928, -1949, -1971, -1992, -2013,
-2034, -2055, -2077, -2098, -2119, -2140, -2161, -2183, -2204, -2225, -2246, -2267,
-2289, -2310, -2331, -2352, -2373, -2395, -2416, -2437, -2458, -2479, -2501, -2522,
-2543, -2564, -2585, -2607, -2628, -2649, -2670, -2691, -2713, -2734, -2755, -2776,
-2797, -2819, -2840, -2861, -2882, -2903, -2925, -2946, -2967, -2988, -3009, -3031,
-3052, -3073, -3094, -3115, -3137, -3158, -3179, -3200, -3221, -3243, -3264, -3285,
-3306, -3328, -3349, -3370, -3391, -3412, -3434, -3455, -3476, -3497, -3518, -3540,
-3561, -3582, -3603, -3624, -3646, -3667, -3688, -3709, -3730, -3752, -3773, -3794,
-3815, -3836, -3858, -3879, -3900, -3921, -3942, -3964, -3985, -4006, -4027, -4048,
-4070, -4091, -4112, -4133, -4154, -4176, -4197, -4218, -4239, -4260, -4282, -4303,
-4324, -4345, -4366, -4388, -4409, -4430, -4451, -4472, -4494, -4515, -4536, -4557,
-4578, -4600, -4621, -4642, -4663, -4684, -4706, -4727, -4748, -4769, -4790, -4812,
-4833, -4854, -4875, -4896, -4918, -4939, -4960, -4981, -5002, -5024, -5045, -5066,
-5087, -5108, -5130, -5151, -5172, -5193, -5214, -5236, -5257, -5278, -5299, -5320,
-5342, -5363, -5384, -5405};
static INT16 Cb_B[] = { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288,
320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,
768, 800, 832, 864, 896, 928, 960, 992, 1024, 1056, 1088, 1120, 1152,
1184, 1216, 1248, 1280, 1312, 1344, 1376, 1408, 1440, 1472, 1504,
1536, 1568, 1600, 1632, 1664, 1696, 1728, 1760, 1792, 1824, 1856,
1888, 1920, 1952, 1984, 2016, 2048, 2080, 2112, 2144, 2176, 2208,
2240, 2272, 2304, 2336, 2368, 2400, 2432, 2464, 2496, 2528, 2560,
2592, 2624, 2656, 2688, 2720, 2752, 2784, 2816, 2848, 2880, 2912,
2944, 2976, 3008, 3040, 3072, 3104, 3136, 3168, 3200, 3232, 3264,
3296, 3328, 3360, 3392, 3424, 3456, 3488, 3520, 3552, 3584, 3616,
3648, 3680, 3712, 3744, 3776, 3808, 3840, 3872, 3904, 3936, 3968,
4000, 4032, 4064, 4096, 4128, 4160, 4192, 4224, 4256, 4288, 4320,
4352, 4384, 4416, 4448, 4480, 4512, 4544, 4576, 4608, 4640, 4672,
4704, 4736, 4768, 4800, 4832, 4864, 4896, 4928, 4960, 4992, 5024,
5056, 5088, 5120, 5152, 5184, 5216, 5248, 5280, 5312, 5344, 5376,
5408, 5440, 5472, 5504, 5536, 5568, 5600, 5632, 5664, 5696, 5728,
5760, 5792, 5824, 5856, 5888, 5920, 5952, 5984, 6016, 6048, 6080,
6112, 6144, 6176, 6208, 6240, 6272, 6304, 6336, 6368, 6400, 6432,
6464, 6496, 6528, 6560, 6592, 6624, 6656, 6688, 6720, 6752, 6784,
6816, 6848, 6880, 6912, 6944, 6976, 7008, 7040, 7072, 7104, 7136,
7168, 7200, 7232, 7264, 7296, 7328, 7360, 7392, 7424, 7456, 7488,
7520, 7552, 7584, 7616, 7648, 7680, 7712, 7744, 7776, 7808, 7840,
7872, 7904, 7936, 7968, 8000, 8032, 8064, 8096, 8128, 8160 };
static INT16 Cb_B[] = {
0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416,
448, 480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800, 832, 864,
896, 928, 960, 992, 1024, 1056, 1088, 1120, 1152, 1184, 1216, 1248, 1280, 1312,
1344, 1376, 1408, 1440, 1472, 1504, 1536, 1568, 1600, 1632, 1664, 1696, 1728, 1760,
1792, 1824, 1856, 1888, 1920, 1952, 1984, 2016, 2048, 2080, 2112, 2144, 2176, 2208,
2240, 2272, 2304, 2336, 2368, 2400, 2432, 2464, 2496, 2528, 2560, 2592, 2624, 2656,
2688, 2720, 2752, 2784, 2816, 2848, 2880, 2912, 2944, 2976, 3008, 3040, 3072, 3104,
3136, 3168, 3200, 3232, 3264, 3296, 3328, 3360, 3392, 3424, 3456, 3488, 3520, 3552,
3584, 3616, 3648, 3680, 3712, 3744, 3776, 3808, 3840, 3872, 3904, 3936, 3968, 4000,
4032, 4064, 4096, 4128, 4160, 4192, 4224, 4256, 4288, 4320, 4352, 4384, 4416, 4448,
4480, 4512, 4544, 4576, 4608, 4640, 4672, 4704, 4736, 4768, 4800, 4832, 4864, 4896,
4928, 4960, 4992, 5024, 5056, 5088, 5120, 5152, 5184, 5216, 5248, 5280, 5312, 5344,
5376, 5408, 5440, 5472, 5504, 5536, 5568, 5600, 5632, 5664, 5696, 5728, 5760, 5792,
5824, 5856, 5888, 5920, 5952, 5984, 6016, 6048, 6080, 6112, 6144, 6176, 6208, 6240,
6272, 6304, 6336, 6368, 6400, 6432, 6464, 6496, 6528, 6560, 6592, 6624, 6656, 6688,
6720, 6752, 6784, 6816, 6848, 6880, 6912, 6944, 6976, 7008, 7040, 7072, 7104, 7136,
7168, 7200, 7232, 7264, 7296, 7328, 7360, 7392, 7424, 7456, 7488, 7520, 7552, 7584,
7616, 7648, 7680, 7712, 7744, 7776, 7808, 7840, 7872, 7904, 7936, 7968, 8000, 8032,
8064, 8096, 8128, 8160};
#define Cr_R Cb_B
static INT16 Cr_G[] = { 0, -26, -53, -79, -106, -133, -160, -187,
-213, -240, -267, -294, -321, -347, -374, -401, -428, -455, -481,
-508, -535, -562, -589, -615, -642, -669, -696, -722, -749, -776,
-803, -830, -856, -883, -910, -937, -964, -990, -1017, -1044, -1071,
-1098, -1124, -1151, -1178, -1205, -1232, -1258, -1285, -1312, -1339,
-1366, -1392, -1419, -1446, -1473, -1500, -1526, -1553, -1580, -1607,
-1634, -1660, -1687, -1714, -1741, -1768, -1794, -1821, -1848, -1875,
-1902, -1928, -1955, -1982, -2009, -2036, -2062, -2089, -2116, -2143,
-2169, -2196, -2223, -2250, -2277, -2303, -2330, -2357, -2384, -2411,
-2437, -2464, -2491, -2518, -2545, -2571, -2598, -2625, -2652, -2679,
-2705, -2732, -2759, -2786, -2813, -2839, -2866, -2893, -2920, -2947,
-2973, -3000, -3027, -3054, -3081, -3107, -3134, -3161, -3188, -3215,
-3241, -3268, -3295, -3322, -3349, -3375, -3402, -3429, -3456, -3483,
-3509, -3536, -3563, -3590, -3616, -3643, -3670, -3697, -3724, -3750,
-3777, -3804, -3831, -3858, -3884, -3911, -3938, -3965, -3992, -4018,
-4045, -4072, -4099, -4126, -4152, -4179, -4206, -4233, -4260, -4286,
-4313, -4340, -4367, -4394, -4420, -4447, -4474, -4501, -4528, -4554,
-4581, -4608, -4635, -4662, -4688, -4715, -4742, -4769, -4796, -4822,
-4849, -4876, -4903, -4929, -4956, -4983, -5010, -5037, -5063, -5090,
-5117, -5144, -5171, -5197, -5224, -5251, -5278, -5305, -5331, -5358,
-5385, -5412, -5439, -5465, -5492, -5519, -5546, -5573, -5599, -5626,
-5653, -5680, -5707, -5733, -5760, -5787, -5814, -5841, -5867, -5894,
-5921, -5948, -5975, -6001, -6028, -6055, -6082, -6109, -6135, -6162,
-6189, -6216, -6243, -6269, -6296, -6323, -6350, -6376, -6403, -6430,
-6457, -6484, -6510, -6537, -6564, -6591, -6618, -6644, -6671, -6698,
-6725, -6752, -6778, -6805, -6832 };
static INT16 Cr_G[] = {
0, -26, -53, -79, -106, -133, -160, -187, -213, -240, -267, -294,
-321, -347, -374, -401, -428, -455, -481, -508, -535, -562, -589, -615,
-642, -669, -696, -722, -749, -776, -803, -830, -856, -883, -910, -937,
-964, -990, -1017, -1044, -1071, -1098, -1124, -1151, -1178, -1205, -1232, -1258,
-1285, -1312, -1339, -1366, -1392, -1419, -1446, -1473, -1500, -1526, -1553, -1580,
-1607, -1634, -1660, -1687, -1714, -1741, -1768, -1794, -1821, -1848, -1875, -1902,
-1928, -1955, -1982, -2009, -2036, -2062, -2089, -2116, -2143, -2169, -2196, -2223,
-2250, -2277, -2303, -2330, -2357, -2384, -2411, -2437, -2464, -2491, -2518, -2545,
-2571, -2598, -2625, -2652, -2679, -2705, -2732, -2759, -2786, -2813, -2839, -2866,
-2893, -2920, -2947, -2973, -3000, -3027, -3054, -3081, -3107, -3134, -3161, -3188,
-3215, -3241, -3268, -3295, -3322, -3349, -3375, -3402, -3429, -3456, -3483, -3509,
-3536, -3563, -3590, -3616, -3643, -3670, -3697, -3724, -3750, -3777, -3804, -3831,
-3858, -3884, -3911, -3938, -3965, -3992, -4018, -4045, -4072, -4099, -4126, -4152,
-4179, -4206, -4233, -4260, -4286, -4313, -4340, -4367, -4394, -4420, -4447, -4474,
-4501, -4528, -4554, -4581, -4608, -4635, -4662, -4688, -4715, -4742, -4769, -4796,
-4822, -4849, -4876, -4903, -4929, -4956, -4983, -5010, -5037, -5063, -5090, -5117,
-5144, -5171, -5197, -5224, -5251, -5278, -5305, -5331, -5358, -5385, -5412, -5439,
-5465, -5492, -5519, -5546, -5573, -5599, -5626, -5653, -5680, -5707, -5733, -5760,
-5787, -5814, -5841, -5867, -5894, -5921, -5948, -5975, -6001, -6028, -6055, -6082,
-6109, -6135, -6162, -6189, -6216, -6243, -6269, -6296, -6323, -6350, -6376, -6403,
-6430, -6457, -6484, -6510, -6537, -6564, -6591, -6618, -6644, -6671, -6698, -6725,
-6752, -6778, -6805, -6832};
static INT16 Cr_B[] = { 0, -4, -9, -15, -20, -25, -30, -35, -41, -46,
-51, -56, -61, -67, -72, -77, -82, -87, -93, -98, -103, -108, -113,
-119, -124, -129, -134, -140, -145, -150, -155, -160, -166, -171,
-176, -181, -186, -192, -197, -202, -207, -212, -218, -223, -228,
-233, -238, -244, -249, -254, -259, -264, -270, -275, -280, -285,
-290, -296, -301, -306, -311, -316, -322, -327, -332, -337, -342,
-348, -353, -358, -363, -368, -374, -379, -384, -389, -394, -400,
-405, -410, -415, -421, -426, -431, -436, -441, -447, -452, -457,
-462, -467, -473, -478, -483, -488, -493, -499, -504, -509, -514,
-519, -525, -530, -535, -540, -545, -551, -556, -561, -566, -571,
-577, -582, -587, -592, -597, -603, -608, -613, -618, -623, -629,
-634, -639, -644, -649, -655, -660, -665, -670, -675, -681, -686,
-691, -696, -702, -707, -712, -717, -722, -728, -733, -738, -743,
-748, -754, -759, -764, -769, -774, -780, -785, -790, -795, -800,
-806, -811, -816, -821, -826, -832, -837, -842, -847, -852, -858,
-863, -868, -873, -878, -884, -889, -894, -899, -904, -910, -915,
-920, -925, -930, -936, -941, -946, -951, -957, -962, -967, -972,
-977, -983, -988, -993, -998, -1003, -1009, -1014, -1019, -1024,
-1029, -1035, -1040, -1045, -1050, -1055, -1061, -1066, -1071, -1076,
-1081, -1087, -1092, -1097, -1102, -1107, -1113, -1118, -1123, -1128,
-1133, -1139, -1144, -1149, -1154, -1159, -1165, -1170, -1175, -1180,
-1185, -1191, -1196, -1201, -1206, -1211, -1217, -1222, -1227, -1232,
-1238, -1243, -1248, -1253, -1258, -1264, -1269, -1274, -1279, -1284,
-1290, -1295, -1300, -1305, -1310, -1316, -1321, -1326 };
static INT16 Cr_B[] = {
0, -4, -9, -15, -20, -25, -30, -35, -41, -46, -51, -56,
-61, -67, -72, -77, -82, -87, -93, -98, -103, -108, -113, -119,
-124, -129, -134, -140, -145, -150, -155, -160, -166, -171, -176, -181,
-186, -192, -197, -202, -207, -212, -218, -223, -228, -233, -238, -244,
-249, -254, -259, -264, -270, -275, -280, -285, -290, -296, -301, -306,
-311, -316, -322, -327, -332, -337, -342, -348, -353, -358, -363, -368,
-374, -379, -384, -389, -394, -400, -405, -410, -415, -421, -426, -431,
-436, -441, -447, -452, -457, -462, -467, -473, -478, -483, -488, -493,
-499, -504, -509, -514, -519, -525, -530, -535, -540, -545, -551, -556,
-561, -566, -571, -577, -582, -587, -592, -597, -603, -608, -613, -618,
-623, -629, -634, -639, -644, -649, -655, -660, -665, -670, -675, -681,
-686, -691, -696, -702, -707, -712, -717, -722, -728, -733, -738, -743,
-748, -754, -759, -764, -769, -774, -780, -785, -790, -795, -800, -806,
-811, -816, -821, -826, -832, -837, -842, -847, -852, -858, -863, -868,
-873, -878, -884, -889, -894, -899, -904, -910, -915, -920, -925, -930,
-936, -941, -946, -951, -957, -962, -967, -972, -977, -983, -988, -993,
-998, -1003, -1009, -1014, -1019, -1024, -1029, -1035, -1040, -1045, -1050, -1055,
-1061, -1066, -1071, -1076, -1081, -1087, -1092, -1097, -1102, -1107, -1113, -1118,
-1123, -1128, -1133, -1139, -1144, -1149, -1154, -1159, -1165, -1170, -1175, -1180,
-1185, -1191, -1196, -1201, -1206, -1211, -1217, -1222, -1227, -1232, -1238, -1243,
-1248, -1253, -1258, -1264, -1269, -1274, -1279, -1284, -1290, -1295, -1300, -1305,
-1310, -1316, -1321, -1326};
static INT16 R_Cr[] = { -11484, -11394, -11305, -11215, -11125,
-11036, -10946, -10856, -10766, -10677, -10587, -10497, -10407,
-10318, -10228, -10138, -10049, -9959, -9869, -9779, -9690, -9600,
-9510, -9420, -9331, -9241, -9151, -9062, -8972, -8882, -8792, -8703,
-8613, -8523, -8433, -8344, -8254, -8164, -8075, -7985, -7895, -7805,
-7716, -7626, -7536, -7446, -7357, -7267, -7177, -7088, -6998, -6908,
-6818, -6729, -6639, -6549, -6459, -6370, -6280, -6190, -6101, -6011,
-5921, -5831, -5742, -5652, -5562, -5472, -5383, -5293, -5203, -5113,
-5024, -4934, -4844, -4755, -4665, -4575, -4485, -4396, -4306, -4216,
-4126, -4037, -3947, -3857, -3768, -3678, -3588, -3498, -3409, -3319,
-3229, -3139, -3050, -2960, -2870, -2781, -2691, -2601, -2511, -2422,
-2332, -2242, -2152, -2063, -1973, -1883, -1794, -1704, -1614, -1524,
-1435, -1345, -1255, -1165, -1076, -986, -896, -807, -717, -627, -537,
-448, -358, -268, -178, -89, 0, 90, 179, 269, 359, 449, 538, 628, 718,
808, 897, 987, 1077, 1166, 1256, 1346, 1436, 1525, 1615, 1705, 1795,
1884, 1974, 2064, 2153, 2243, 2333, 2423, 2512, 2602, 2692, 2782,
2871, 2961, 3051, 3140, 3230, 3320, 3410, 3499, 3589, 3679, 3769,
3858, 3948, 4038, 4127, 4217, 4307, 4397, 4486, 4576, 4666, 4756,
4845, 4935, 5025, 5114, 5204, 5294, 5384, 5473, 5563, 5653, 5743,
5832, 5922, 6012, 6102, 6191, 6281, 6371, 6460, 6550, 6640, 6730,
6819, 6909, 6999, 7089, 7178, 7268, 7358, 7447, 7537, 7627, 7717,
7806, 7896, 7986, 8076, 8165, 8255, 8345, 8434, 8524, 8614, 8704,
8793, 8883, 8973, 9063, 9152, 9242, 9332, 9421, 9511, 9601, 9691,
9780, 9870, 9960, 10050, 10139, 10229, 10319, 10408, 10498, 10588,
10678, 10767, 10857, 10947, 11037, 11126, 11216, 11306, 11395 };
static INT16 R_Cr[] = {
-11484, -11394, -11305, -11215, -11125, -11036, -10946, -10856, -10766, -10677,
-10587, -10497, -10407, -10318, -10228, -10138, -10049, -9959, -9869, -9779,
-9690, -9600, -9510, -9420, -9331, -9241, -9151, -9062, -8972, -8882,
-8792, -8703, -8613, -8523, -8433, -8344, -8254, -8164, -8075, -7985,
-7895, -7805, -7716, -7626, -7536, -7446, -7357, -7267, -7177, -7088,
-6998, -6908, -6818, -6729, -6639, -6549, -6459, -6370, -6280, -6190,
-6101, -6011, -5921, -5831, -5742, -5652, -5562, -5472, -5383, -5293,
-5203, -5113, -5024, -4934, -4844, -4755, -4665, -4575, -4485, -4396,
-4306, -4216, -4126, -4037, -3947, -3857, -3768, -3678, -3588, -3498,
-3409, -3319, -3229, -3139, -3050, -2960, -2870, -2781, -2691, -2601,
-2511, -2422, -2332, -2242, -2152, -2063, -1973, -1883, -1794, -1704,
-1614, -1524, -1435, -1345, -1255, -1165, -1076, -986, -896, -807,
-717, -627, -537, -448, -358, -268, -178, -89, 0, 90,
179, 269, 359, 449, 538, 628, 718, 808, 897, 987,
1077, 1166, 1256, 1346, 1436, 1525, 1615, 1705, 1795, 1884,
1974, 2064, 2153, 2243, 2333, 2423, 2512, 2602, 2692, 2782,
2871, 2961, 3051, 3140, 3230, 3320, 3410, 3499, 3589, 3679,
3769, 3858, 3948, 4038, 4127, 4217, 4307, 4397, 4486, 4576,
4666, 4756, 4845, 4935, 5025, 5114, 5204, 5294, 5384, 5473,
5563, 5653, 5743, 5832, 5922, 6012, 6102, 6191, 6281, 6371,
6460, 6550, 6640, 6730, 6819, 6909, 6999, 7089, 7178, 7268,
7358, 7447, 7537, 7627, 7717, 7806, 7896, 7986, 8076, 8165,
8255, 8345, 8434, 8524, 8614, 8704, 8793, 8883, 8973, 9063,
9152, 9242, 9332, 9421, 9511, 9601, 9691, 9780, 9870, 9960,
10050, 10139, 10229, 10319, 10408, 10498, 10588, 10678, 10767, 10857,
10947, 11037, 11126, 11216, 11306, 11395};
static INT16 G_Cb[] = { 2819, 2797, 2775, 2753, 2731, 2709, 2687,
2665, 2643, 2621, 2599, 2577, 2555, 2533, 2511, 2489, 2467, 2445,
2423, 2401, 2379, 2357, 2335, 2313, 2291, 2269, 2247, 2225, 2202,
2180, 2158, 2136, 2114, 2092, 2070, 2048, 2026, 2004, 1982, 1960,
1938, 1916, 1894, 1872, 1850, 1828, 1806, 1784, 1762, 1740, 1718,
1696, 1674, 1652, 1630, 1608, 1586, 1564, 1542, 1520, 1498, 1476,
1454, 1432, 1410, 1388, 1366, 1344, 1321, 1299, 1277, 1255, 1233,
1211, 1189, 1167, 1145, 1123, 1101, 1079, 1057, 1035, 1013, 991, 969,
947, 925, 903, 881, 859, 837, 815, 793, 771, 749, 727, 705, 683, 661,
639, 617, 595, 573, 551, 529, 507, 485, 463, 440, 418, 396, 374, 352,
330, 308, 286, 264, 242, 220, 198, 176, 154, 132, 110, 88, 66, 44, 22,
0, -21, -43, -65, -87, -109, -131, -153, -175, -197, -219, -241, -263,
-285, -307, -329, -351, -373, -395, -417, -439, -462, -484, -506,
-528, -550, -572, -594, -616, -638, -660, -682, -704, -726, -748,
-770, -792, -814, -836, -858, -880, -902, -924, -946, -968, -990,
-1012, -1034, -1056, -1078, -1100, -1122, -1144, -1166, -1188, -1210,
-1232, -1254, -1276, -1298, -1320, -1343, -1365, -1387, -1409, -1431,
-1453, -1475, -1497, -1519, -1541, -1563, -1585, -1607, -1629, -1651,
-1673, -1695, -1717, -1739, -1761, -1783, -1805, -1827, -1849, -1871,
-1893, -1915, -1937, -1959, -1981, -2003, -2025, -2047, -2069, -2091,
-2113, -2135, -2157, -2179, -2201, -2224, -2246, -2268, -2290, -2312,
-2334, -2356, -2378, -2400, -2422, -2444, -2466, -2488, -2510, -2532,
-2554, -2576, -2598, -2620, -2642, -2664, -2686, -2708, -2730, -2752,
-2774, -2796 };
static INT16 G_Cb[] = {
2819, 2797, 2775, 2753, 2731, 2709, 2687, 2665, 2643, 2621, 2599, 2577,
2555, 2533, 2511, 2489, 2467, 2445, 2423, 2401, 2379, 2357, 2335, 2313,
2291, 2269, 2247, 2225, 2202, 2180, 2158, 2136, 2114, 2092, 2070, 2048,
2026, 2004, 1982, 1960, 1938, 1916, 1894, 1872, 1850, 1828, 1806, 1784,
1762, 1740, 1718, 1696, 1674, 1652, 1630, 1608, 1586, 1564, 1542, 1520,
1498, 1476, 1454, 1432, 1410, 1388, 1366, 1344, 1321, 1299, 1277, 1255,
1233, 1211, 1189, 1167, 1145, 1123, 1101, 1079, 1057, 1035, 1013, 991,
969, 947, 925, 903, 881, 859, 837, 815, 793, 771, 749, 727,
705, 683, 661, 639, 617, 595, 573, 551, 529, 507, 485, 463,
440, 418, 396, 374, 352, 330, 308, 286, 264, 242, 220, 198,
176, 154, 132, 110, 88, 66, 44, 22, 0, -21, -43, -65,
-87, -109, -131, -153, -175, -197, -219, -241, -263, -285, -307, -329,
-351, -373, -395, -417, -439, -462, -484, -506, -528, -550, -572, -594,
-616, -638, -660, -682, -704, -726, -748, -770, -792, -814, -836, -858,
-880, -902, -924, -946, -968, -990, -1012, -1034, -1056, -1078, -1100, -1122,
-1144, -1166, -1188, -1210, -1232, -1254, -1276, -1298, -1320, -1343, -1365, -1387,
-1409, -1431, -1453, -1475, -1497, -1519, -1541, -1563, -1585, -1607, -1629, -1651,
-1673, -1695, -1717, -1739, -1761, -1783, -1805, -1827, -1849, -1871, -1893, -1915,
-1937, -1959, -1981, -2003, -2025, -2047, -2069, -2091, -2113, -2135, -2157, -2179,
-2201, -2224, -2246, -2268, -2290, -2312, -2334, -2356, -2378, -2400, -2422, -2444,
-2466, -2488, -2510, -2532, -2554, -2576, -2598, -2620, -2642, -2664, -2686, -2708,
-2730, -2752, -2774, -2796};
static INT16 G_Cr[] = { 5850, 5805, 5759, 5713, 5667, 5622, 5576,
5530, 5485, 5439, 5393, 5347, 5302, 5256, 5210, 5165, 5119, 5073,
5028, 4982, 4936, 4890, 4845, 4799, 4753, 4708, 4662, 4616, 4570,
4525, 4479, 4433, 4388, 4342, 4296, 4251, 4205, 4159, 4113, 4068,
4022, 3976, 3931, 3885, 3839, 3794, 3748, 3702, 3656, 3611, 3565,
3519, 3474, 3428, 3382, 3336, 3291, 3245, 3199, 3154, 3108, 3062,
3017, 2971, 2925, 2879, 2834, 2788, 2742, 2697, 2651, 2605, 2559,
2514, 2468, 2422, 2377, 2331, 2285, 2240, 2194, 2148, 2102, 2057,
2011, 1965, 1920, 1874, 1828, 1782, 1737, 1691, 1645, 1600, 1554,
1508, 1463, 1417, 1371, 1325, 1280, 1234, 1188, 1143, 1097, 1051,
1006, 960, 914, 868, 823, 777, 731, 686, 640, 594, 548, 503, 457, 411,
366, 320, 274, 229, 183, 137, 91, 46, 0, -45, -90, -136, -182, -228,
-273, -319, -365, -410, -456, -502, -547, -593, -639, -685, -730,
-776, -822, -867, -913, -959, -1005, -1050, -1096, -1142, -1187,
-1233, -1279, -1324, -1370, -1416, -1462, -1507, -1553, -1599, -1644,
-1690, -1736, -1781, -1827, -1873, -1919, -1964, -2010, -2056, -2101,
-2147, -2193, -2239, -2284, -2330, -2376, -2421, -2467, -2513, -2558,
-2604, -2650, -2696, -2741, -2787, -2833, -2878, -2924, -2970, -3016,
-3061, -3107, -3153, -3198, -3244, -3290, -3335, -3381, -3427, -3473,
-3518, -3564, -3610, -3655, -3701, -3747, -3793, -3838, -3884, -3930,
-3975, -4021, -4067, -4112, -4158, -4204, -4250, -4295, -4341, -4387,
-4432, -4478, -4524, -4569, -4615, -4661, -4707, -4752, -4798, -4844,
-4889, -4935, -4981, -5027, -5072, -5118, -5164, -5209, -5255, -5301,
-5346, -5392, -5438, -5484, -5529, -5575, -5621, -5666, -5712, -5758,
-5804 };
static INT16 B_Cb[] = { -14515, -14402, -14288, -14175, -14062,
-13948, -13835, -13721, -13608, -13495, -13381, -13268, -13154,
-13041, -12928, -12814, -12701, -12587, -12474, -12360, -12247,
-12134, -12020, -11907, -11793, -11680, -11567, -11453, -11340,
-11226, -11113, -11000, -10886, -10773, -10659, -10546, -10433,
-10319, -10206, -10092, -9979, -9865, -9752, -9639, -9525, -9412,
-9298, -9185, -9072, -8958, -8845, -8731, -8618, -8505, -8391, -8278,
-8164, -8051, -7938, -7824, -7711, -7597, -7484, -7371, -7257, -7144,
-7030, -6917, -6803, -6690, -6577, -6463, -6350, -6236, -6123, -6010,
-5896, -5783, -5669, -5556, -5443, -5329, -5216, -5102, -4989, -4876,
-4762, -4649, -4535, -4422, -4309, -4195, -4082, -3968, -3855, -3741,
-3628, -3515, -3401, -3288, -3174, -3061, -2948, -2834, -2721, -2607,
-2494, -2381, -2267, -2154, -2040, -1927, -1814, -1700, -1587, -1473,
-1360, -1246, -1133, -1020, -906, -793, -679, -566, -453, -339, -226,
-112, 0, 113, 227, 340, 454, 567, 680, 794, 907, 1021, 1134, 1247,
1361, 1474, 1588, 1701, 1815, 1928, 2041, 2155, 2268, 2382, 2495,
2608, 2722, 2835, 2949, 3062, 3175, 3289, 3402, 3516, 3629, 3742,
3856, 3969, 4083, 4196, 4310, 4423, 4536, 4650, 4763, 4877, 4990,
5103, 5217, 5330, 5444, 5557, 5670, 5784, 5897, 6011, 6124, 6237,
6351, 6464, 6578, 6691, 6804, 6918, 7031, 7145, 7258, 7372, 7485,
7598, 7712, 7825, 7939, 8052, 8165, 8279, 8392, 8506, 8619, 8732,
8846, 8959, 9073, 9186, 9299, 9413, 9526, 9640, 9753, 9866, 9980,
10093, 10207, 10320, 10434, 10547, 10660, 10774, 10887, 11001, 11114,
11227, 11341, 11454, 11568, 11681, 11794, 11908, 12021, 12135, 12248,
12361, 12475, 12588, 12702, 12815, 12929, 13042, 13155, 13269, 13382,
13496, 13609, 13722, 13836, 13949, 14063, 14176, 14289, 14403 };
static INT16 G_Cr[] = {
5850, 5805, 5759, 5713, 5667, 5622, 5576, 5530, 5485, 5439, 5393, 5347,
5302, 5256, 5210, 5165, 5119, 5073, 5028, 4982, 4936, 4890, 4845, 4799,
4753, 4708, 4662, 4616, 4570, 4525, 4479, 4433, 4388, 4342, 4296, 4251,
4205, 4159, 4113, 4068, 4022, 3976, 3931, 3885, 3839, 3794, 3748, 3702,
3656, 3611, 3565, 3519, 3474, 3428, 3382, 3336, 3291, 3245, 3199, 3154,
3108, 3062, 3017, 2971, 2925, 2879, 2834, 2788, 2742, 2697, 2651, 2605,
2559, 2514, 2468, 2422, 2377, 2331, 2285, 2240, 2194, 2148, 2102, 2057,
2011, 1965, 1920, 1874, 1828, 1782, 1737, 1691, 1645, 1600, 1554, 1508,
1463, 1417, 1371, 1325, 1280, 1234, 1188, 1143, 1097, 1051, 1006, 960,
914, 868, 823, 777, 731, 686, 640, 594, 548, 503, 457, 411,
366, 320, 274, 229, 183, 137, 91, 46, 0, -45, -90, -136,
-182, -228, -273, -319, -365, -410, -456, -502, -547, -593, -639, -685,
-730, -776, -822, -867, -913, -959, -1005, -1050, -1096, -1142, -1187, -1233,
-1279, -1324, -1370, -1416, -1462, -1507, -1553, -1599, -1644, -1690, -1736, -1781,
-1827, -1873, -1919, -1964, -2010, -2056, -2101, -2147, -2193, -2239, -2284, -2330,
-2376, -2421, -2467, -2513, -2558, -2604, -2650, -2696, -2741, -2787, -2833, -2878,
-2924, -2970, -3016, -3061, -3107, -3153, -3198, -3244, -3290, -3335, -3381, -3427,
-3473, -3518, -3564, -3610, -3655, -3701, -3747, -3793, -3838, -3884, -3930, -3975,
-4021, -4067, -4112, -4158, -4204, -4250, -4295, -4341, -4387, -4432, -4478, -4524,
-4569, -4615, -4661, -4707, -4752, -4798, -4844, -4889, -4935, -4981, -5027, -5072,
-5118, -5164, -5209, -5255, -5301, -5346, -5392, -5438, -5484, -5529, -5575, -5621,
-5666, -5712, -5758, -5804};
static INT16 B_Cb[] = {
-14515, -14402, -14288, -14175, -14062, -13948, -13835, -13721, -13608, -13495,
-13381, -13268, -13154, -13041, -12928, -12814, -12701, -12587, -12474, -12360,
-12247, -12134, -12020, -11907, -11793, -11680, -11567, -11453, -11340, -11226,
-11113, -11000, -10886, -10773, -10659, -10546, -10433, -10319, -10206, -10092,
-9979, -9865, -9752, -9639, -9525, -9412, -9298, -9185, -9072, -8958,
-8845, -8731, -8618, -8505, -8391, -8278, -8164, -8051, -7938, -7824,
-7711, -7597, -7484, -7371, -7257, -7144, -7030, -6917, -6803, -6690,
-6577, -6463, -6350, -6236, -6123, -6010, -5896, -5783, -5669, -5556,
-5443, -5329, -5216, -5102, -4989, -4876, -4762, -4649, -4535, -4422,
-4309, -4195, -4082, -3968, -3855, -3741, -3628, -3515, -3401, -3288,
-3174, -3061, -2948, -2834, -2721, -2607, -2494, -2381, -2267, -2154,
-2040, -1927, -1814, -1700, -1587, -1473, -1360, -1246, -1133, -1020,
-906, -793, -679, -566, -453, -339, -226, -112, 0, 113,
227, 340, 454, 567, 680, 794, 907, 1021, 1134, 1247,
1361, 1474, 1588, 1701, 1815, 1928, 2041, 2155, 2268, 2382,
2495, 2608, 2722, 2835, 2949, 3062, 3175, 3289, 3402, 3516,
3629, 3742, 3856, 3969, 4083, 4196, 4310, 4423, 4536, 4650,
4763, 4877, 4990, 5103, 5217, 5330, 5444, 5557, 5670, 5784,
5897, 6011, 6124, 6237, 6351, 6464, 6578, 6691, 6804, 6918,
7031, 7145, 7258, 7372, 7485, 7598, 7712, 7825, 7939, 8052,
8165, 8279, 8392, 8506, 8619, 8732, 8846, 8959, 9073, 9186,
9299, 9413, 9526, 9640, 9753, 9866, 9980, 10093, 10207, 10320,
10434, 10547, 10660, 10774, 10887, 11001, 11114, 11227, 11341, 11454,
11568, 11681, 11794, 11908, 12021, 12135, 12248, 12361, 12475, 12588,
12702, 12815, 12929, 13042, 13155, 13269, 13382, 13496, 13609, 13722,
13836, 13949, 14063, 14176, 14289, 14403};
void
ImagingConvertRGB2YCbCr(UINT8* out, const UINT8* in, int pixels)
{
ImagingConvertRGB2YCbCr(UINT8 *out, const UINT8 *in, int pixels) {
int x;
UINT8 a;
int r, g, b;
int y, cr, cb;
for (x = 0; x < pixels; x++, in += 4, out += 4) {
r = in[0];
g = in[1];
b = in[2];
@ -361,15 +339,13 @@ ImagingConvertRGB2YCbCr(UINT8* out, const UINT8* in, int pixels)
}
void
ImagingConvertYCbCr2RGB(UINT8* out, const UINT8* in, int pixels)
{
ImagingConvertYCbCr2RGB(UINT8 *out, const UINT8 *in, int pixels) {
int x;
UINT8 a;
int r, g, b;
int y, cr, cb;
for (x = 0; x < pixels; x++, in += 4, out += 4) {
y = in[0];
cb = in[1];
cr = in[2];

11
src/libImaging/Copy.c
View File

@ -15,13 +15,10 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
static Imaging
_copy(Imaging imOut, Imaging imIn)
{
_copy(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int y;
@ -50,13 +47,11 @@ _copy(Imaging imOut, Imaging imIn)
}
Imaging
ImagingCopy(Imaging imIn)
{
ImagingCopy(Imaging imIn) {
return _copy(NULL, imIn);
}
Imaging
ImagingCopy2(Imaging imOut, Imaging imIn)
{
ImagingCopy2(Imaging imOut, Imaging imIn) {
return _copy(imOut, imIn);
}

5
src/libImaging/Crop.c
View File

@ -15,13 +15,10 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
Imaging
ImagingCrop(Imaging imIn, int sx0, int sy0, int sx1, int sy1)
{
ImagingCrop(Imaging imIn, int sx0, int sy0, int sx1, int sy1) {
Imaging imOut;
int xsize, ysize;
int dx0, dy0, dx1, dy1;

88
src/libImaging/Dib.c
View File

@ -19,17 +19,14 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#ifdef _WIN32
#include "ImDib.h"
char *
ImagingGetModeDIB(int size_out[2])
{
ImagingGetModeDIB(int size_out[2]) {
/* Get device characteristics */
HDC dc;
@ -55,10 +52,8 @@ ImagingGetModeDIB(int size_out[2])
return mode;
}
ImagingDIB
ImagingNewDIB(const char *mode, int xsize, int ysize)
{
ImagingNewDIB(const char *mode, int xsize, int ysize) {
/* Create a Windows bitmap */
ImagingDIB dib;
@ -66,8 +61,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
int i;
/* Check mode */
if (strcmp(mode, "1") != 0 && strcmp(mode, "L") != 0 &&
strcmp(mode, "RGB") != 0) {
if (strcmp(mode, "1") != 0 && strcmp(mode, "L") != 0 && strcmp(mode, "RGB") != 0) {
return (ImagingDIB)ImagingError_ModeError();
}
@ -78,8 +72,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
return (ImagingDIB)ImagingError_MemoryError();
}
/* malloc check ok, small constant allocation */
dib->info = (BITMAPINFO*) malloc(sizeof(BITMAPINFOHEADER) +
256 * sizeof(RGBQUAD));
dib->info = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
if (!dib->info) {
free(dib);
return (ImagingDIB)ImagingError_MemoryError();
@ -101,8 +94,8 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
return (ImagingDIB)ImagingError_MemoryError();
}
dib->bitmap = CreateDIBSection(dib->dc, dib->info, DIB_RGB_COLORS,
&dib->bits, NULL, 0);
dib->bitmap =
CreateDIBSection(dib->dc, dib->info, DIB_RGB_COLORS, &dib->bits, NULL, 0);
if (!dib->bitmap) {
free(dib->info);
free(dib);
@ -131,9 +124,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
/* Bind a palette to it as well (only required for 8-bit DIBs) */
if (dib->pixelsize == 1) {
for (i = 0; i < 256; i++) {
palette[i].rgbRed =
palette[i].rgbGreen =
palette[i].rgbBlue = i;
palette[i].rgbRed = palette[i].rgbGreen = palette[i].rgbBlue = i;
palette[i].rgbReserved = 0;
}
SetDIBColorTable(dib->dc, 0, 256, palette);
@ -141,7 +132,6 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
/* Create an associated palette (for 8-bit displays only) */
if (strcmp(ImagingGetModeDIB(NULL), "P") == 0) {
char palbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
LPLOGPALETTE pal = (LPLOGPALETTE)palbuf;
int i, r, g, b;
@ -152,7 +142,6 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
GetSystemPaletteEntries(dib->dc, 0, 256, pal->palPalEntry);
if (strcmp(mode, "L") == 0) {
/* Greyscale DIB. Fill all 236 slots with a greyscale ramp
* (this is usually overkill on Windows since VGA only offers
* 6 bits greyscale resolution). Ignore the slots already
@ -160,8 +149,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
i = 10;
for (r = 0; r < 236; r++) {
pal->palPalEntry[i].peRed =
pal->palPalEntry[i].peGreen =
pal->palPalEntry[i].peRed = pal->palPalEntry[i].peGreen =
pal->palPalEntry[i].peBlue = i;
i++;
}
@ -169,7 +157,6 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
dib->palette = CreatePalette(pal);
} else if (strcmp(mode, "RGB") == 0) {
#ifdef CUBE216
/* Colour DIB. Create a 6x6x6 colour cube (216 entries) and
@ -189,8 +176,7 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
}
for (r = 1; r < 22 - 1; r++) {
/* Black and white are already provided by the cube. */
pal->palPalEntry[i].peRed =
pal->palPalEntry[i].peGreen =
pal->palPalEntry[i].peRed = pal->palPalEntry[i].peGreen =
pal->palPalEntry[i].peBlue = r * 255 / (22 - 1);
i++;
}
@ -214,32 +200,30 @@ ImagingNewDIB(const char *mode, int xsize, int ysize)
#endif
dib->palette = CreatePalette(pal);
}
}
return dib;
}
void
ImagingPasteDIB(ImagingDIB dib, Imaging im, int xy[4])
{
ImagingPasteDIB(ImagingDIB dib, Imaging im, int xy[4]) {
/* Paste image data into a bitmap */
/* FIXME: check size! */
int y;
for (y = 0; y < im->ysize; y++) {
dib->pack(dib->bits + dib->linesize*(dib->ysize-(xy[1]+y)-1) +
xy[0]*dib->pixelsize, im->image[y], im->xsize);
dib->pack(
dib->bits + dib->linesize * (dib->ysize - (xy[1] + y) - 1) +
xy[0] * dib->pixelsize,
im->image[y],
im->xsize);
}
}
void
ImagingExposeDIB(ImagingDIB dib, void *dc)
{
ImagingExposeDIB(ImagingDIB dib, void *dc) {
/* Copy bitmap to display */
if (dib->palette != 0) {
@ -249,35 +233,52 @@ ImagingExposeDIB(ImagingDIB dib, void *dc)
}
void
ImagingDrawDIB(ImagingDIB dib, void *dc, int dst[4], int src[4])
{
ImagingDrawDIB(ImagingDIB dib, void *dc, int dst[4], int src[4]) {
/* Copy bitmap to printer/display */
if (GetDeviceCaps((HDC)dc, RASTERCAPS) & RC_STRETCHDIB) {
/* stretchdib (printers) */
StretchDIBits((HDC) dc, dst[0], dst[1], dst[2]-dst[0], dst[3]-dst[1],
src[0], src[1], src[2]-src[0], src[3]-src[1], dib->bits,
dib->info, DIB_RGB_COLORS, SRCCOPY);
StretchDIBits(
(HDC)dc,
dst[0],
dst[1],
dst[2] - dst[0],
dst[3] - dst[1],
src[0],
src[1],
src[2] - src[0],
src[3] - src[1],
dib->bits,
dib->info,
DIB_RGB_COLORS,
SRCCOPY);
} else {
/* stretchblt (displays) */
if (dib->palette != 0) {
SelectPalette((HDC)dc, dib->palette, FALSE);
}
StretchBlt((HDC) dc, dst[0], dst[1], dst[2]-dst[0], dst[3]-dst[1],
dib->dc, src[0], src[1], src[2]-src[0], src[3]-src[1],
StretchBlt(
(HDC)dc,
dst[0],
dst[1],
dst[2] - dst[0],
dst[3] - dst[1],
dib->dc,
src[0],
src[1],
src[2] - src[0],
src[3] - src[1],
SRCCOPY);
}
}
int
ImagingQueryPaletteDIB(ImagingDIB dib, void *dc)
{
ImagingQueryPaletteDIB(ImagingDIB dib, void *dc) {
/* Install bitmap palette */
int n;
if (dib->palette != 0) {
/* Realize associated palette */
HPALETTE now = SelectPalette((HDC)dc, dib->palette, FALSE);
n = RealizePalette((HDC)dc);
@ -293,8 +294,7 @@ ImagingQueryPaletteDIB(ImagingDIB dib, void *dc)
}
void
ImagingDeleteDIB(ImagingDIB dib)
{
ImagingDeleteDIB(ImagingDIB dib) {
/* Clean up */
if (dib->palette) {

416
src/libImaging/Draw.c
View File

@ -65,8 +65,7 @@ typedef struct {
typedef void (*hline_handler)(Imaging, int, int, int, int);
static inline void
point8(Imaging im, int x, int y, int ink)
{
point8(Imaging im, int x, int y, int ink) {
if (x >= 0 && x < im->xsize && y >= 0 && y < im->ysize) {
if (strncmp(im->mode, "I;16", 4) == 0) {
im->image8[y][x * 2] = (UINT8)ink;
@ -78,16 +77,14 @@ point8(Imaging im, int x, int y, int ink)
}
static inline void
point32(Imaging im, int x, int y, int ink)
{
point32(Imaging im, int x, int y, int ink) {
if (x >= 0 && x < im->xsize && y >= 0 && y < im->ysize) {
im->image32[y][x] = ink;
}
}
static inline void
point32rgba(Imaging im, int x, int y, int ink)
{
point32rgba(Imaging im, int x, int y, int ink) {
unsigned int tmp1;
if (x >= 0 && x < im->xsize && y >= 0 && y < im->ysize) {
@ -100,8 +97,7 @@ point32rgba(Imaging im, int x, int y, int ink)
}
static inline void
hline8(Imaging im, int x0, int y0, int x1, int ink)
{
hline8(Imaging im, int x0, int y0, int x1, int ink) {
int tmp, pixelwidth;
if (y0 >= 0 && y0 < im->ysize) {
@ -120,15 +116,16 @@ hline8(Imaging im, int x0, int y0, int x1, int ink)
}
if (x0 <= x1) {
pixelwidth = strncmp(im->mode, "I;16", 4) == 0 ? 2 : 1;
memset(im->image8[y0] + x0 * pixelwidth, (UINT8) ink,
memset(
im->image8[y0] + x0 * pixelwidth,
(UINT8)ink,
(x1 - x0 + 1) * pixelwidth);
}
}
}
static inline void
hline32(Imaging im, int x0, int y0, int x1, int ink)
{
hline32(Imaging im, int x0, int y0, int x1, int ink) {
int tmp;
INT32 *p;
@ -154,8 +151,7 @@ hline32(Imaging im, int x0, int y0, int x1, int ink)
}
static inline void
hline32rgba(Imaging im, int x0, int y0, int x1, int ink)
{
hline32rgba(Imaging im, int x0, int y0, int x1, int ink) {
int tmp;
unsigned int tmp1;
@ -180,15 +176,15 @@ hline32rgba(Imaging im, int x0, int y0, int x1, int ink)
out[0] = BLEND(in[3], out[0], in[0], tmp1);
out[1] = BLEND(in[3], out[1], in[1], tmp1);
out[2] = BLEND(in[3], out[2], in[2], tmp1);
x0++; out += 4;
x0++;
out += 4;
}
}
}
}
static inline void
line8(Imaging im, int x0, int y0, int x1, int y1, int ink)
{
line8(Imaging im, int x0, int y0, int x1, int y1, int ink) {
int i, n, e;
int dx, dy;
int xs, ys;
@ -210,7 +206,6 @@ line8(Imaging im, int x0, int y0, int x1, int y1, int ink)
n = (dx > dy) ? dx : dy;
if (dx == 0) {
/* vertical */
for (i = 0; i < dy; i++) {
point8(im, x0, y0, ink);
@ -218,7 +213,6 @@ line8(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else if (dy == 0) {
/* horizontal */
for (i = 0; i < dx; i++) {
point8(im, x0, y0, ink);
@ -226,7 +220,6 @@ line8(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else if (dx > dy) {
/* bresenham, horizontal slope */
n = dx;
dy += dy;
@ -244,7 +237,6 @@ line8(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else {
/* bresenham, vertical slope */
n = dy;
dx += dx;
@ -260,13 +252,11 @@ line8(Imaging im, int x0, int y0, int x1, int y1, int ink)
e += dx;
y0 += ys;
}
}
}
static inline void
line32(Imaging im, int x0, int y0, int x1, int y1, int ink)
{
line32(Imaging im, int x0, int y0, int x1, int y1, int ink) {
int i, n, e;
int dx, dy;
int xs, ys;
@ -288,7 +278,6 @@ line32(Imaging im, int x0, int y0, int x1, int y1, int ink)
n = (dx > dy) ? dx : dy;
if (dx == 0) {
/* vertical */
for (i = 0; i < dy; i++) {
point32(im, x0, y0, ink);
@ -296,7 +285,6 @@ line32(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else if (dy == 0) {
/* horizontal */
for (i = 0; i < dx; i++) {
point32(im, x0, y0, ink);
@ -304,7 +292,6 @@ line32(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else if (dx > dy) {
/* bresenham, horizontal slope */
n = dx;
dy += dy;
@ -322,7 +309,6 @@ line32(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else {
/* bresenham, vertical slope */
n = dy;
dx += dx;
@ -338,13 +324,11 @@ line32(Imaging im, int x0, int y0, int x1, int y1, int ink)
e += dx;
y0 += ys;
}
}
}
static inline void
line32rgba(Imaging im, int x0, int y0, int x1, int y1, int ink)
{
line32rgba(Imaging im, int x0, int y0, int x1, int y1, int ink) {
int i, n, e;
int dx, dy;
int xs, ys;
@ -366,7 +350,6 @@ line32rgba(Imaging im, int x0, int y0, int x1, int y1, int ink)
n = (dx > dy) ? dx : dy;
if (dx == 0) {
/* vertical */
for (i = 0; i < dy; i++) {
point32rgba(im, x0, y0, ink);
@ -374,7 +357,6 @@ line32rgba(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else if (dy == 0) {
/* horizontal */
for (i = 0; i < dx; i++) {
point32rgba(im, x0, y0, ink);
@ -382,7 +364,6 @@ line32rgba(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else if (dx > dy) {
/* bresenham, horizontal slope */
n = dx;
dy += dy;
@ -400,7 +381,6 @@ line32rgba(Imaging im, int x0, int y0, int x1, int y1, int ink)
}
} else {
/* bresenham, vertical slope */
n = dy;
dx += dx;
@ -416,13 +396,11 @@ line32rgba(Imaging im, int x0, int y0, int x1, int y1, int ink)
e += dx;
y0 += ys;
}
}
}
static int
x_cmp(const void *x0, const void *x1)
{
x_cmp(const void *x0, const void *x1) {
float diff = *((float *)x0) - *((float *)x1);
if (diff < 0) {
return -1;
@ -433,10 +411,9 @@ x_cmp(const void *x0, const void *x1)
}
}
static void
draw_horizontal_lines(Imaging im, int n, Edge *e, int ink, int *x_pos, int y, hline_handler hline)
{
draw_horizontal_lines(
Imaging im, int n, Edge *e, int ink, int *x_pos, int y, hline_handler hline) {
int i;
for (i = 0; i < n; i++) {
if (e[i].ymin == y && e[i].ymin == e[i].ymax) {
@ -467,10 +444,7 @@ draw_horizontal_lines(Imaging im, int n, Edge *e, int ink, int *x_pos, int y, hl
* Filled polygon draw function using scan line algorithm.
*/
static inline int
polygon_generic(Imaging im, int n, Edge *e, int ink, int eofill,
hline_handler hline)
{
polygon_generic(Imaging im, int n, Edge *e, int ink, int eofill, hline_handler hline) {
Edge **edge_table;
float *xx;
int edge_count = 0;
@ -563,26 +537,22 @@ polygon_generic(Imaging im, int n, Edge *e, int ink, int eofill,
}
static inline int
polygon8(Imaging im, int n, Edge *e, int ink, int eofill)
{
polygon8(Imaging im, int n, Edge *e, int ink, int eofill) {
return polygon_generic(im, n, e, ink, eofill, hline8);
}
static inline int
polygon32(Imaging im, int n, Edge *e, int ink, int eofill)
{
polygon32(Imaging im, int n, Edge *e, int ink, int eofill) {
return polygon_generic(im, n, e, ink, eofill, hline32);
}
static inline int
polygon32rgba(Imaging im, int n, Edge *e, int ink, int eofill)
{
polygon32rgba(Imaging im, int n, Edge *e, int ink, int eofill) {
return polygon_generic(im, n, e, ink, eofill, hline32rgba);
}
static inline void
add_edge(Edge *e, int x0, int y0, int x1, int y1)
{
add_edge(Edge *e, int x0, int y0, int x1, int y1) {
/* printf("edge %d %d %d %d\n", x0, y0, x1, y1); */
if (x0 <= x1) {
@ -638,8 +608,7 @@ DRAW draw32rgba = { point32rgba, hline32rgba, line32rgba, polygon32rgba };
}
int
ImagingDrawPoint(Imaging im, int x0, int y0, const void* ink_, int op)
{
ImagingDrawPoint(Imaging im, int x0, int y0, const void *ink_, int op) {
DRAW *draw;
INT32 ink;
@ -651,9 +620,7 @@ ImagingDrawPoint(Imaging im, int x0, int y0, const void* ink_, int op)
}
int
ImagingDrawLine(Imaging im, int x0, int y0, int x1, int y1, const void* ink_,
int op)
{
ImagingDrawLine(Imaging im, int x0, int y0, int x1, int y1, const void *ink_, int op) {
DRAW *draw;
INT32 ink;
@ -665,9 +632,8 @@ ImagingDrawLine(Imaging im, int x0, int y0, int x1, int y1, const void* ink_,
}
int
ImagingDrawWideLine(Imaging im, int x0, int y0, int x1, int y1,
const void* ink_, int width, int op)
{
ImagingDrawWideLine(
Imaging im, int x0, int y0, int x1, int y1, const void *ink_, int width, int op) {
DRAW *draw;
INT32 ink;
int dx, dy;
@ -698,8 +664,7 @@ ImagingDrawWideLine(Imaging im, int x0, int y0, int x1, int y1,
{x0 - dxmin, y0 + dymax},
{x1 - dxmin, y1 + dymax},
{x1 + dxmax, y1 - dymin},
{x0 + dxmax, y0 - dymin}
};
{x0 + dxmax, y0 - dymin}};
add_edge(e + 0, vertices[0][0], vertices[0][1], vertices[1][0], vertices[1][1]);
add_edge(e + 1, vertices[1][0], vertices[1][1], vertices[2][0], vertices[2][1]);
@ -712,9 +677,16 @@ ImagingDrawWideLine(Imaging im, int x0, int y0, int x1, int y1,
}
int
ImagingDrawRectangle(Imaging im, int x0, int y0, int x1, int y1,
const void* ink_, int fill, int width, int op)
{
ImagingDrawRectangle(
Imaging im,
int x0,
int y0,
int x1,
int y1,
const void *ink_,
int fill,
int width,
int op) {
int i;
int y;
int tmp;
@ -728,7 +700,6 @@ ImagingDrawRectangle(Imaging im, int x0, int y0, int x1, int y1,
}
if (fill) {
if (y0 < 0) {
y0 = 0;
} else if (y0 >= im->ysize) {
@ -762,9 +733,7 @@ ImagingDrawRectangle(Imaging im, int x0, int y0, int x1, int y1,
}
int
ImagingDrawPolygon(Imaging im, int count, int* xy, const void* ink_,
int fill, int op)
{
ImagingDrawPolygon(Imaging im, int count, int *xy, const void *ink_, int fill, int op) {
int i, n;
DRAW *draw;
INT32 ink;
@ -776,7 +745,6 @@ ImagingDrawPolygon(Imaging im, int count, int* xy, const void* ink_,
DRAWINIT();
if (fill) {
/* Build edge list */
/* malloc check ok, using calloc */
Edge *e = calloc(count, sizeof(Edge));
@ -794,26 +762,20 @@ ImagingDrawPolygon(Imaging im, int count, int* xy, const void* ink_,
free(e);
} else {
/* Outline */
for (i = 0; i < count - 1; i++) {
draw->line(im, xy[i + i], xy[i + i + 1], xy[i + i + 2], xy[i + i + 3], ink);
}
draw->line(im, xy[i + i], xy[i + i + 1], xy[0], xy[1], ink);
}
return 0;
}
int
ImagingDrawBitmap(Imaging im, int x0, int y0, Imaging bitmap, const void* ink,
int op)
{
ImagingDrawBitmap(Imaging im, int x0, int y0, Imaging bitmap, const void *ink, int op) {
return ImagingFill2(
im, ink, bitmap,
x0, y0, x0 + bitmap->xsize, y0 + bitmap->ysize
);
im, ink, bitmap, x0, y0, x0 + bitmap->xsize, y0 + bitmap->ysize);
}
/* -------------------------------------------------------------------- */
@ -830,7 +792,8 @@ typedef struct {
int8_t finished;
} quarter_state;
void quarter_init(quarter_state* s, int32_t a, int32_t b) {
void
quarter_init(quarter_state *s, int32_t a, int32_t b) {
if (a < 0 || b < 0) {
s->finished = 1;
} else {
@ -849,11 +812,13 @@ void quarter_init(quarter_state* s, int32_t a, int32_t b) {
// deviation of the point from ellipse curve, basically a substitution
// of the point into the ellipse equation
int64_t quarter_delta(quarter_state* s, int64_t x, int64_t y) {
int64_t
quarter_delta(quarter_state *s, int64_t x, int64_t y) {
return llabs(s->a2 * y * y + s->b2 * x * x - s->a2b2);
}
int8_t quarter_next(quarter_state* s, int32_t* ret_x, int32_t* ret_y) {
int8_t
quarter_next(quarter_state *s, int32_t *ret_x, int32_t *ret_y) {
if (s->finished) {
return -1;
}
@ -903,7 +868,8 @@ typedef struct {
int8_t leftmost;
} ellipse_state;
void ellipse_init(ellipse_state* s, int32_t a, int32_t b, int32_t w) {
void
ellipse_init(ellipse_state *s, int32_t a, int32_t b, int32_t w) {
s->bufcnt = 0;
s->leftmost = a % 2;
quarter_init(&s->st_o, a, b);
@ -916,7 +882,8 @@ void ellipse_init(ellipse_state* s, int32_t a, int32_t b, int32_t w) {
}
}
int8_t ellipse_next(ellipse_state* s, int32_t* ret_x0, int32_t* ret_y, int32_t* ret_x1) {
int8_t
ellipse_next(ellipse_state *s, int32_t *ret_x0, int32_t *ret_y, int32_t *ret_x1) {
if (s->bufcnt == 0) {
if (s->finished) {
return -1;
@ -998,7 +965,8 @@ typedef struct event_list {
} event_list;
// Mirrors all the clipping nodes of the tree relative to the y = x line.
void clip_tree_transpose(clip_node* root) {
void
clip_tree_transpose(clip_node *root) {
if (root != NULL) {
if (root->type == CT_CLIP) {
double t = root->a;
@ -1014,7 +982,9 @@ void clip_tree_transpose(clip_node* root) {
// non-intersecting segments sorted by X coordinate.
// Combining nodes (AND, OR) may also accept sequences for intersecting
// segments, i.e. something like correct bracket sequences.
int clip_tree_do_clip(clip_node* root, int32_t x0, int32_t y, int32_t x1, event_list** ret) {
int
clip_tree_do_clip(
clip_node *root, int32_t x0, int32_t y, int32_t x1, event_list **ret) {
if (root == NULL) {
event_list *start = malloc(sizeof(event_list));
if (!start) {
@ -1100,7 +1070,9 @@ int clip_tree_do_clip(clip_node* root, int32_t x0, int32_t y, int32_t x1, event_
int32_t k2 = 0;
while (l1 != NULL || l2 != NULL) {
event_list *t;
if (l2 == NULL || (l1 != NULL && (l1->x < l2->x || (l1->x == l2->x && l1->type > l2->type)))) {
if (l2 == NULL ||
(l1 != NULL &&
(l1->x < l2->x || (l1->x == l2->x && l1->type > l2->type)))) {
t = l1;
k1 += t->type;
assert(k1 >= 0);
@ -1112,14 +1084,14 @@ int clip_tree_do_clip(clip_node* root, int32_t x0, int32_t y, int32_t x1, event_
l2 = l2->next;
}
t->next = NULL;
if ((root->type == CT_OR && (
(t->type == 1 && (tail == NULL || tail->type == -1)) ||
(t->type == -1 && k1 == 0 && k2 == 0)
)) ||
(root->type == CT_AND && (
(t->type == 1 && (tail == NULL || tail->type == -1) && k1 > 0 && k2 > 0) ||
(t->type == -1 && tail != NULL && tail->type == 1 && (k1 == 0 || k2 == 0))
))) {
if ((root->type == CT_OR &&
((t->type == 1 && (tail == NULL || tail->type == -1)) ||
(t->type == -1 && k1 == 0 && k2 == 0))) ||
(root->type == CT_AND &&
((t->type == 1 && (tail == NULL || tail->type == -1) && k1 > 0 &&
k2 > 0) ||
(t->type == -1 && tail != NULL && tail->type == 1 &&
(k1 == 0 || k2 == 0))))) {
if (tail == NULL) {
*ret = t;
} else {
@ -1148,9 +1120,11 @@ typedef struct {
int32_t y;
} clip_ellipse_state;
typedef void (*clip_ellipse_init)(clip_ellipse_state*, int32_t, int32_t, int32_t, float, float);
typedef void (*clip_ellipse_init)(
clip_ellipse_state *, int32_t, int32_t, int32_t, float, float);
void debug_clip_tree(clip_node* root, int space) {
void
debug_clip_tree(clip_node *root, int space) {
if (root == NULL) {
return;
}
@ -1175,7 +1149,8 @@ void debug_clip_tree(clip_node* root, int space) {
}
// Resulting angles will satisfy 0 <= al < 360, al <= ar <= al + 360
void normalize_angles(float* al, float* ar) {
void
normalize_angles(float *al, float *ar) {
if (*ar - *al >= 360) {
*al = 0;
*ar = 360;
@ -1186,7 +1161,8 @@ void normalize_angles(float* al, float* ar) {
}
// An arc with caps orthogonal to the ellipse curve.
void arc_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al, float ar) {
void
arc_init(clip_ellipse_state *s, int32_t a, int32_t b, int32_t w, float al, float ar) {
if (a < b) {
// transpose the coordinate system
arc_init(s, b, a, w, 90 - ar, 90 - al);
@ -1255,7 +1231,9 @@ void arc_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al,
}
// A chord line.
void chord_line_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al, float ar) {
void
chord_line_init(
clip_ellipse_state *s, int32_t a, int32_t b, int32_t w, float al, float ar) {
ellipse_init(&s->st, a, b, a + b + 1);
s->head = NULL;
@ -1275,11 +1253,14 @@ void chord_line_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, flo
s->root->l->c = -(s->root->l->a * xl + s->root->l->b * yl);
s->root->r->a = -s->root->l->a;
s->root->r->b = -s->root->l->b;
s->root->r->c = 2 * w * sqrt(pow(s->root->l->a, 2.0) + pow(s->root->l->b, 2.0)) - s->root->l->c;
s->root->r->c =
2 * w * sqrt(pow(s->root->l->a, 2.0) + pow(s->root->l->b, 2.0)) - s->root->l->c;
}
// Pie side.
void pie_side_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al, float _) {
void
pie_side_init(
clip_ellipse_state *s, int32_t a, int32_t b, int32_t w, float al, float _) {
ellipse_init(&s->st, a, b, a + b + 1);
s->head = NULL;
@ -1321,7 +1302,8 @@ void pie_side_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float
}
// A chord.
void chord_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al, float ar) {
void
chord_init(clip_ellipse_state *s, int32_t a, int32_t b, int32_t w, float al, float ar) {
ellipse_init(&s->st, a, b, w);
s->head = NULL;
@ -1339,7 +1321,8 @@ void chord_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al
}
// A pie. Can also be used to draw an arc with ugly sharp caps.
void pie_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al, float ar) {
void
pie_init(clip_ellipse_state *s, int32_t a, int32_t b, int32_t w, float al, float ar) {
ellipse_init(&s->st, a, b, w);
s->head = NULL;
@ -1366,7 +1349,8 @@ void pie_init(clip_ellipse_state* s, int32_t a, int32_t b, int32_t w, float al,
s->root->type = ar - al < 180 ? CT_AND : CT_OR;
}
void clip_ellipse_free(clip_ellipse_state* s) {
void
clip_ellipse_free(clip_ellipse_state *s) {
while (s->head != NULL) {
event_list *t = s->head;
s->head = s->head->next;
@ -1374,7 +1358,9 @@ void clip_ellipse_free(clip_ellipse_state* s) {
}
}
int8_t clip_ellipse_next(clip_ellipse_state* s, int32_t* ret_x0, int32_t* ret_y, int32_t* ret_x1) {
int8_t
clip_ellipse_next(
clip_ellipse_state *s, int32_t *ret_x0, int32_t *ret_y, int32_t *ret_x1) {
int32_t x0, y, x1;
while (s->head == NULL && ellipse_next(&s->st, &x0, &y, &x1) >= 0) {
if (clip_tree_do_clip(s->root, x0, y, x1, &s->head) < 0) {
@ -1399,10 +1385,16 @@ int8_t clip_ellipse_next(clip_ellipse_state* s, int32_t* ret_x0, int32_t* ret_y,
}
static int
ellipseNew(Imaging im, int x0, int y0, int x1, int y1,
const void* ink_, int fill,
int width, int op)
{
ellipseNew(
Imaging im,
int x0,
int y0,
int x1,
int y1,
const void *ink_,
int fill,
int width,
int op) {
DRAW *draw;
INT32 ink;
DRAWINIT();
@ -1426,10 +1418,18 @@ ellipseNew(Imaging im, int x0, int y0, int x1, int y1,
}
static int
clipEllipseNew(Imaging im, int x0, int y0, int x1, int y1,
float start, float end,
const void* ink_, int width, int op, clip_ellipse_init init)
{
clipEllipseNew(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink_,
int width,
int op,
clip_ellipse_init init) {
DRAW *draw;
INT32 ink;
DRAWINIT();
@ -1452,56 +1452,106 @@ clipEllipseNew(Imaging im, int x0, int y0, int x1, int y1,
return next_code == -1 ? 0 : -1;
}
static int
arcNew(Imaging im, int x0, int y0, int x1, int y1,
float start, float end,
const void* ink_, int width, int op)
{
arcNew(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink_,
int width,
int op) {
return clipEllipseNew(im, x0, y0, x1, y1, start, end, ink_, width, op, arc_init);
}
static int
chordNew(Imaging im, int x0, int y0, int x1, int y1,
float start, float end,
const void* ink_, int width, int op)
{
chordNew(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink_,
int width,
int op) {
return clipEllipseNew(im, x0, y0, x1, y1, start, end, ink_, width, op, chord_init);
}
static int
chordLineNew(Imaging im, int x0, int y0, int x1, int y1,
float start, float end,
const void* ink_, int width, int op)
{
return clipEllipseNew(im, x0, y0, x1, y1, start, end, ink_, width, op, chord_line_init);
chordLineNew(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink_,
int width,
int op) {
return clipEllipseNew(
im, x0, y0, x1, y1, start, end, ink_, width, op, chord_line_init);
}
static int
pieNew(Imaging im, int x0, int y0, int x1, int y1,
float start, float end,
const void* ink_, int width, int op)
{
pieNew(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink_,
int width,
int op) {
return clipEllipseNew(im, x0, y0, x1, y1, start, end, ink_, width, op, pie_init);
}
static int
pieSideNew(Imaging im, int x0, int y0, int x1, int y1,
pieSideNew(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
const void* ink_, int width, int op)
{
const void *ink_,
int width,
int op) {
return clipEllipseNew(im, x0, y0, x1, y1, start, 0, ink_, width, op, pie_side_init);
}
int
ImagingDrawEllipse(Imaging im, int x0, int y0, int x1, int y1,
const void* ink, int fill, int width, int op)
{
ImagingDrawEllipse(
Imaging im,
int x0,
int y0,
int x1,
int y1,
const void *ink,
int fill,
int width,
int op) {
return ellipseNew(im, x0, y0, x1, y1, ink, fill, width, op);
}
int
ImagingDrawArc(Imaging im, int x0, int y0, int x1, int y1,
float start, float end, const void* ink, int width, int op)
{
ImagingDrawArc(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink,
int width,
int op) {
normalize_angles(&start, &end);
if (start + 360 == end) {
return ImagingDrawEllipse(im, x0, y0, x1, y1, ink, 0, width, op);
@ -1512,12 +1562,19 @@ ImagingDrawArc(Imaging im, int x0, int y0, int x1, int y1,
return arcNew(im, x0, y0, x1, y1, start, end, ink, width, op);
}
int
ImagingDrawChord(Imaging im, int x0, int y0, int x1, int y1,
float start, float end, const void* ink, int fill,
int width, int op)
{
ImagingDrawChord(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink,
int fill,
int width,
int op) {
normalize_angles(&start, &end);
if (start + 360 == end) {
return ImagingDrawEllipse(im, x0, y0, x1, y1, ink, fill, width, op);
@ -1535,12 +1592,19 @@ ImagingDrawChord(Imaging im, int x0, int y0, int x1, int y1,
}
}
int
ImagingDrawPieslice(Imaging im, int x0, int y0, int x1, int y1,
float start, float end, const void* ink, int fill,
int width, int op)
{
ImagingDrawPieslice(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink,
int fill,
int width,
int op) {
normalize_angles(&start, &end);
if (start + 360 == end) {
return ellipseNew(im, x0, y0, x1, y1, ink, fill, width, op);
@ -1563,7 +1627,6 @@ ImagingDrawPieslice(Imaging im, int x0, int y0, int x1, int y1,
}
}
/* -------------------------------------------------------------------- */
/* experimental level 2 ("arrow") graphics stuff. this implements
@ -1572,7 +1635,6 @@ ImagingDrawPieslice(Imaging im, int x0, int y0, int x1, int y1,
itself */
struct ImagingOutlineInstance {
float x0, y0;
float x, y;
@ -1581,13 +1643,10 @@ struct ImagingOutlineInstance {
Edge *edges;
int size;
};
ImagingOutline
ImagingOutlineNew(void)
{
ImagingOutlineNew(void) {
ImagingOutline outline;
outline = calloc(1, sizeof(struct ImagingOutlineInstance));
@ -1604,8 +1663,7 @@ ImagingOutlineNew(void)
}
void
ImagingOutlineDelete(ImagingOutline outline)
{
ImagingOutlineDelete(ImagingOutline outline) {
if (!outline) {
return;
}
@ -1617,10 +1675,8 @@ ImagingOutlineDelete(ImagingOutline outline)
free(outline);
}
static Edge *
allocate(ImagingOutline outline, int extra)
{
allocate(ImagingOutline outline, int extra) {
Edge *e;
if (outline->count + extra > outline->size) {
@ -1650,8 +1706,7 @@ allocate(ImagingOutline outline, int extra)
}
int
ImagingOutlineMove(ImagingOutline outline, float x0, float y0)
{
ImagingOutlineMove(ImagingOutline outline, float x0, float y0) {
outline->x = outline->x0 = x0;
outline->y = outline->y0 = y0;
@ -1659,8 +1714,7 @@ ImagingOutlineMove(ImagingOutline outline, float x0, float y0)
}
int
ImagingOutlineLine(ImagingOutline outline, float x1, float y1)
{
ImagingOutlineLine(ImagingOutline outline, float x1, float y1) {
Edge *e;
e = allocate(outline, 1);
@ -1677,9 +1731,14 @@ ImagingOutlineLine(ImagingOutline outline, float x1, float y1)
}
int
ImagingOutlineCurve(ImagingOutline outline, float x1, float y1,
float x2, float y2, float x3, float y3)
{
ImagingOutlineCurve(
ImagingOutline outline,
float x1,
float y1,
float x2,
float y2,
float x3,
float y3) {
Edge *e;
int i;
float xo, yo;
@ -1697,7 +1756,6 @@ ImagingOutlineCurve(ImagingOutline outline, float x1, float y1,
/* flatten the bezier segment */
for (i = 1; i <= STEPS; i++) {
float t = ((float)i) / STEPS;
float t2 = t * t;
float t3 = t2 * t;
@ -1712,7 +1770,6 @@ ImagingOutlineCurve(ImagingOutline outline, float x1, float y1,
add_edge(e++, xo, yo, (int)x, (int)y);
xo = x, yo = y;
}
outline->x = xo;
@ -1722,8 +1779,7 @@ ImagingOutlineCurve(ImagingOutline outline, float x1, float y1,
}
int
ImagingOutlineClose(ImagingOutline outline)
{
ImagingOutlineClose(ImagingOutline outline) {
if (outline->x == outline->x0 && outline->y == outline->y0) {
return 0;
}
@ -1731,16 +1787,19 @@ ImagingOutlineClose(ImagingOutline outline)
}
int
ImagingOutlineTransform(ImagingOutline outline, double a[6])
{
ImagingOutlineTransform(ImagingOutline outline, double a[6]) {
Edge *eIn;
Edge *eOut;
int i, n;
int x0, y0, x1, y1;
int X0, Y0, X1, Y1;
double a0 = a[0]; double a1 = a[1]; double a2 = a[2];
double a3 = a[3]; double a4 = a[4]; double a5 = a[5];
double a0 = a[0];
double a1 = a[1];
double a2 = a[2];
double a3 = a[3];
double a4 = a[4];
double a5 = a[5];
eIn = outline->edges;
n = outline->count;
@ -1758,7 +1817,6 @@ ImagingOutlineTransform(ImagingOutline outline, double a[6])
}
for (i = 0; i < n; i++) {
x0 = eIn->x0;
y0 = eIn->y0;
@ -1787,7 +1845,6 @@ ImagingOutlineTransform(ImagingOutline outline, double a[6])
eIn++;
eOut++;
}
free(eIn);
@ -1796,9 +1853,8 @@ ImagingOutlineTransform(ImagingOutline outline, double a[6])
}
int
ImagingDrawOutline(Imaging im, ImagingOutline outline, const void* ink_,
int fill, int op)
{
ImagingDrawOutline(
Imaging im, ImagingOutline outline, const void *ink_, int fill, int op) {
DRAW *draw;
INT32 ink;

10
src/libImaging/Effects.c
View File

@ -15,14 +15,12 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include <math.h>
Imaging
ImagingEffectMandelbrot(int xsize, int ysize, double extent[4], int quality)
{
ImagingEffectMandelbrot(int xsize, int ysize, double extent[4], int quality) {
/* Generate a Mandelbrot set covering the given extent */
Imaging im;
@ -74,8 +72,7 @@ ImagingEffectMandelbrot(int xsize, int ysize, double extent[4], int quality)
}
Imaging
ImagingEffectNoise(int xsize, int ysize, float sigma)
{
ImagingEffectNoise(int xsize, int ysize, float sigma) {
/* Generate Gaussian noise centered around 128 */
Imaging imOut;
@ -117,8 +114,7 @@ ImagingEffectNoise(int xsize, int ysize, float sigma)
}
Imaging
ImagingEffectSpread(Imaging imIn, int distance)
{
ImagingEffectSpread(Imaging imIn, int distance) {
/* Randomly spread pixels in an image */
Imaging imOut;

8
src/libImaging/EpsEncode.c
View File

@ -17,13 +17,10 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingEpsEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingEpsEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
enum { HEXBYTE = 1, NEWLINE };
const char *hex = "0123456789abcdef";
@ -38,7 +35,6 @@ ImagingEpsEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
in = (UINT8 *)im->image[state->y];
for (;;) {
if (state->state == NEWLINE) {
if (bytes < 1) {
break;
@ -75,9 +71,7 @@ ImagingEpsEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
in = (UINT8 *)im->image[state->y];
}
}
return ptr - buf;
}

26
src/libImaging/Except.c
View File

@ -19,41 +19,34 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
/* exception state */
void *
ImagingError_OSError(void)
{
ImagingError_OSError(void) {
fprintf(stderr, "*** exception: file access error\n");
return NULL;
}
void *
ImagingError_MemoryError(void)
{
ImagingError_MemoryError(void) {
fprintf(stderr, "*** exception: out of memory\n");
return NULL;
}
void *
ImagingError_ModeError(void)
{
ImagingError_ModeError(void) {
return ImagingError_ValueError("bad image mode");
}
void *
ImagingError_Mismatch(void)
{
ImagingError_Mismatch(void) {
return ImagingError_ValueError("images don't match");
}
void *
ImagingError_ValueError(const char *message)
{
ImagingError_ValueError(const char *message) {
if (!message) {
message = "exception: bad argument to function";
}
@ -62,21 +55,18 @@ ImagingError_ValueError(const char *message)
}
void
ImagingError_Clear(void)
{
ImagingError_Clear(void) {
/* nop */;
}
/* thread state */
void
ImagingSectionEnter(ImagingSectionCookie* cookie)
{
ImagingSectionEnter(ImagingSectionCookie *cookie) {
/* pass */
}
void
ImagingSectionLeave(ImagingSectionCookie* cookie)
{
ImagingSectionLeave(ImagingSectionCookie *cookie) {
/* pass */
}

13
src/libImaging/File.c
View File

@ -15,19 +15,15 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include <ctype.h>
int
ImagingSaveRaw(Imaging im, FILE* fp)
{
ImagingSaveRaw(Imaging im, FILE *fp) {
int x, y, i;
if (strcmp(im->mode, "1") == 0 || strcmp(im->mode, "L") == 0) {
/* @PIL227: FIXME: for mode "1", map != 0 to 255 */
/* PGM "L" */
@ -36,23 +32,19 @@ ImagingSaveRaw(Imaging im, FILE* fp)
}
} else {
/* PPM "RGB" or other internal format */
for (y = 0; y < im->ysize; y++) {
for (x = i = 0; x < im->xsize; x++, i += im->pixelsize) {
fwrite(im->image[y] + i, 1, im->bands, fp);
}
}
}
return 1;
}
int
ImagingSavePPM(Imaging im, const char* outfile)
{
ImagingSavePPM(Imaging im, const char *outfile) {
FILE *fp;
if (!im) {
@ -84,4 +76,3 @@ ImagingSavePPM(Imaging im, const char* outfile)
return 1;
}

13
src/libImaging/Fill.c
View File

@ -15,14 +15,12 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include "math.h"
Imaging
ImagingFill(Imaging im, const void* colour)
{
ImagingFill(Imaging im, const void *colour) {
int x, y;
ImagingSectionCookie cookie;
@ -65,8 +63,7 @@ ImagingFill(Imaging im, const void* colour)
}
Imaging
ImagingFillLinearGradient(const char *mode)
{
ImagingFillLinearGradient(const char *mode) {
Imaging im;
int y;
@ -87,8 +84,7 @@ ImagingFillLinearGradient(const char *mode)
}
Imaging
ImagingFillRadialGradient(const char *mode)
{
ImagingFillRadialGradient(const char *mode) {
Imaging im;
int x, y;
int d;
@ -104,7 +100,8 @@ ImagingFillRadialGradient(const char *mode)
for (y = 0; y < 256; y++) {
for (x = 0; x < 256; x++) {
d = (int) sqrt((double) ((x-128)*(x-128) + (y-128)*(y-128)) * 2.0);
d = (int)sqrt(
(double)((x - 128) * (x - 128) + (y - 128) * (y - 128)) * 2.0);
if (d >= 255) {
im->image8[y][x] = 255;
} else {

56
src/libImaging/Filter.c
View File

@ -26,9 +26,8 @@
#include "Imaging.h"
static inline UINT8 clip8(float in)
{
static inline UINT8
clip8(float in) {
if (in <= 0.0) {
return 0;
}
@ -39,8 +38,7 @@ static inline UINT8 clip8(float in)
}
Imaging
ImagingExpand(Imaging imIn, int xmargin, int ymargin, int mode)
{
ImagingExpand(Imaging imIn, int xmargin, int ymargin, int mode) {
Imaging imOut;
int x, y;
ImagingSectionCookie cookie;
@ -55,7 +53,8 @@ ImagingExpand(Imaging imIn, int xmargin, int ymargin, int mode)
return NULL;
}
#define EXPAND_LINE(type, image, yin, yout) {\
#define EXPAND_LINE(type, image, yin, yout) \
{ \
for (x = 0; x < xmargin; x++) { \
imOut->image[yout][x] = imIn->image[yin][0]; \
} \
@ -68,7 +67,8 @@ ImagingExpand(Imaging imIn, int xmargin, int ymargin, int mode)
} \
}
#define EXPAND(type, image) {\
#define EXPAND(type, image) \
{ \
for (y = 0; y < ymargin; y++) { \
EXPAND_LINE(type, image, 0, y); \
} \
@ -93,14 +93,10 @@ ImagingExpand(Imaging imIn, int xmargin, int ymargin, int mode)
return imOut;
}
void
ImagingFilter3x3(Imaging imOut, Imaging im, const float* kernel,
float offset)
{
#define KERNEL1x3(in0, x, kernel, d) ( \
_i2f((UINT8) in0[x-d]) * (kernel)[0] + \
_i2f((UINT8) in0[x]) * (kernel)[1] + \
ImagingFilter3x3(Imaging imOut, Imaging im, const float *kernel, float offset) {
#define KERNEL1x3(in0, x, kernel, d) \
(_i2f((UINT8)in0[x - d]) * (kernel)[0] + _i2f((UINT8)in0[x]) * (kernel)[1] + \
_i2f((UINT8)in0[x + d]) * (kernel)[2])
int x = 0, y = 0;
@ -164,8 +160,7 @@ ImagingFilter3x3(Imaging imOut, Imaging im, const float* kernel,
ss0 += KERNEL1x3(in_1, x * 4 + 0, &kernel[6], 4);
ss1 += KERNEL1x3(in_1, x * 4 + 1, &kernel[6], 4);
ss2 += KERNEL1x3(in_1, x * 4 + 2, &kernel[6], 4);
v = MAKE_UINT32(
clip8(ss0), clip8(ss1), clip8(ss2), 0);
v = MAKE_UINT32(clip8(ss0), clip8(ss1), clip8(ss2), 0);
memcpy(out + x * sizeof(v), &v, sizeof(v));
}
} else if (im->bands == 4) {
@ -187,8 +182,7 @@ ImagingFilter3x3(Imaging imOut, Imaging im, const float* kernel,
ss1 += KERNEL1x3(in_1, x * 4 + 1, &kernel[6], 4);
ss2 += KERNEL1x3(in_1, x * 4 + 2, &kernel[6], 4);
ss3 += KERNEL1x3(in_1, x * 4 + 3, &kernel[6], 4);
v = MAKE_UINT32(
clip8(ss0), clip8(ss1), clip8(ss2), clip8(ss3));
v = MAKE_UINT32(clip8(ss0), clip8(ss1), clip8(ss2), clip8(ss3));
memcpy(out + x * sizeof(v), &v, sizeof(v));
}
}
@ -198,15 +192,11 @@ ImagingFilter3x3(Imaging imOut, Imaging im, const float* kernel,
memcpy(imOut->image[y], im->image[y], im->linesize);
}
void
ImagingFilter5x5(Imaging imOut, Imaging im, const float* kernel,
float offset)
{
#define KERNEL1x5(in0, x, kernel, d) ( \
_i2f((UINT8) in0[x-d-d]) * (kernel)[0] + \
_i2f((UINT8) in0[x-d]) * (kernel)[1] + \
_i2f((UINT8) in0[x]) * (kernel)[2] + \
ImagingFilter5x5(Imaging imOut, Imaging im, const float *kernel, float offset) {
#define KERNEL1x5(in0, x, kernel, d) \
(_i2f((UINT8)in0[x - d - d]) * (kernel)[0] + \
_i2f((UINT8)in0[x - d]) * (kernel)[1] + _i2f((UINT8)in0[x]) * (kernel)[2] + \
_i2f((UINT8)in0[x + d]) * (kernel)[3] + \
_i2f((UINT8)in0[x + d + d]) * (kernel)[4])
@ -290,8 +280,7 @@ ImagingFilter5x5(Imaging imOut, Imaging im, const float* kernel,
ss0 += KERNEL1x5(in_2, x * 4 + 0, &kernel[20], 4);
ss1 += KERNEL1x5(in_2, x * 4 + 1, &kernel[20], 4);
ss2 += KERNEL1x5(in_2, x * 4 + 2, &kernel[20], 4);
v = MAKE_UINT32(
clip8(ss0), clip8(ss1), clip8(ss2), 0);
v = MAKE_UINT32(clip8(ss0), clip8(ss1), clip8(ss2), 0);
memcpy(out + x * sizeof(v), &v, sizeof(v));
}
} else if (im->bands == 4) {
@ -321,12 +310,12 @@ ImagingFilter5x5(Imaging imOut, Imaging im, const float* kernel,
ss1 += KERNEL1x5(in_2, x * 4 + 1, &kernel[20], 4);
ss2 += KERNEL1x5(in_2, x * 4 + 2, &kernel[20], 4);
ss3 += KERNEL1x5(in_2, x * 4 + 3, &kernel[20], 4);
v = MAKE_UINT32(
clip8(ss0), clip8(ss1), clip8(ss2), clip8(ss3));
v = MAKE_UINT32(clip8(ss0), clip8(ss1), clip8(ss2), clip8(ss3));
memcpy(out + x * sizeof(v), &v, sizeof(v));
}
}
memcpy(out + x * sizeof(UINT32), in0 + x * sizeof(UINT32), sizeof(UINT32) * 2);
memcpy(
out + x * sizeof(UINT32), in0 + x * sizeof(UINT32), sizeof(UINT32) * 2);
}
}
memcpy(imOut->image[y], im->image[y], im->linesize);
@ -334,9 +323,7 @@ ImagingFilter5x5(Imaging imOut, Imaging im, const float* kernel,
}
Imaging
ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32* kernel,
FLOAT32 offset)
{
ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32 *kernel, FLOAT32 offset) {
Imaging imOut;
ImagingSectionCookie cookie;
@ -368,4 +355,3 @@ ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32* kernel,
ImagingSectionLeave(&cookie);
return imOut;
}

27
src/libImaging/FliDecode.c
View File

@ -14,15 +14,11 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#define I16(ptr) ((ptr)[0] + ((ptr)[1] << 8))
#define I16(ptr)\
((ptr)[0] + ((ptr)[1] << 8))
#define I32(ptr)\
((ptr)[0] + ((ptr)[1] << 8) + ((ptr)[2] << 16) + ((ptr)[3] << 24))
#define I32(ptr) ((ptr)[0] + ((ptr)[1] << 8) + ((ptr)[2] << 16) + ((ptr)[3] << 24))
#define ERR_IF_DATA_OOB(offset) \
if ((data + (offset)) > ptr + bytes) { \
@ -31,8 +27,7 @@
}
int
ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
UINT8 *ptr;
int framesize;
int c, chunks, advance;
@ -80,18 +75,21 @@ ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
}
data = ptr + 6;
switch (I16(ptr + 4)) {
case 4: case 11:
case 4:
case 11:
/* FLI COLOR chunk */
break; /* ignored; handled by Python code */
case 7:
/* FLI SS2 chunk (word delta) */
/* OOB ok, we've got 4 bytes min on entry */
lines = I16(data); data += 2;
lines = I16(data);
data += 2;
for (l = y = 0; l < lines && y < state->ysize; l++, y++) {
UINT8 *local_buf = (UINT8 *)im->image[y];
int p, packets;
ERR_IF_DATA_OOB(2)
packets = I16(data); data += 2;
packets = I16(data);
data += 2;
while (packets & 0x8000) {
/* flag word */
if (packets & 0x4000) {
@ -106,7 +104,8 @@ ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
local_buf[state->xsize - 1] = (UINT8)packets;
}
ERR_IF_DATA_OOB(2)
packets = I16(data); data += 2;
packets = I16(data);
data += 2;
}
for (p = x = 0; p < packets; p++) {
ERR_IF_DATA_OOB(2)
@ -146,7 +145,9 @@ ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
case 12:
/* FLI LC chunk (byte delta) */
/* OOB Check ok, we have 4 bytes min here */
y = I16(data); ymax = y + I16(data+2); data += 4;
y = I16(data);
ymax = y + I16(data + 2);
data += 4;
for (; y < ymax && y < state->ysize; y++) {
UINT8 *out = (UINT8 *)im->image[y];
ERR_IF_DATA_OOB(1)

247
src/libImaging/Geometry.c
View File

@ -15,8 +15,7 @@
/* Transpose operations */
Imaging
ImagingFlipLeftRight(Imaging imOut, Imaging imIn)
{
ImagingFlipLeftRight(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int x, y, xr;
@ -58,10 +57,8 @@ ImagingFlipLeftRight(Imaging imOut, Imaging imIn)
return imOut;
}
Imaging
ImagingFlipTopBottom(Imaging imOut, Imaging imIn)
{
ImagingFlipTopBottom(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int y, yr;
@ -86,10 +83,8 @@ ImagingFlipTopBottom(Imaging imOut, Imaging imIn)
return imOut;
}
Imaging
ImagingRotate90(Imaging imOut, Imaging imIn)
{
ImagingRotate90(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int x, y, xx, yy, xr, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize;
@ -110,8 +105,12 @@ ImagingRotate90(Imaging imOut, Imaging imIn)
xxsize = x + ROTATE_CHUNK < imIn->xsize ? x + ROTATE_CHUNK : imIn->xsize; \
for (yy = y; yy < yysize; yy += ROTATE_SMALL_CHUNK) { \
for (xx = x; xx < xxsize; xx += ROTATE_SMALL_CHUNK) { \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize ? yy + ROTATE_SMALL_CHUNK : imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize ? xx + ROTATE_SMALL_CHUNK : imIn->xsize; \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize \
? yy + ROTATE_SMALL_CHUNK \
: imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize \
? xx + ROTATE_SMALL_CHUNK \
: imIn->xsize; \
for (yyy = yy; yyy < yyysize; yyy++) { \
INT *in = (INT *)imIn->image[yyy]; \
xr = imIn->xsize - 1 - xx; \
@ -144,10 +143,8 @@ ImagingRotate90(Imaging imOut, Imaging imIn)
return imOut;
}
Imaging
ImagingTranspose(Imaging imOut, Imaging imIn)
{
ImagingTranspose(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int x, y, xx, yy, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize;
@ -168,8 +165,12 @@ ImagingTranspose(Imaging imOut, Imaging imIn)
xxsize = x + ROTATE_CHUNK < imIn->xsize ? x + ROTATE_CHUNK : imIn->xsize; \
for (yy = y; yy < yysize; yy += ROTATE_SMALL_CHUNK) { \
for (xx = x; xx < xxsize; xx += ROTATE_SMALL_CHUNK) { \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize ? yy + ROTATE_SMALL_CHUNK : imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize ? xx + ROTATE_SMALL_CHUNK : imIn->xsize; \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize \
? yy + ROTATE_SMALL_CHUNK \
: imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize \
? xx + ROTATE_SMALL_CHUNK \
: imIn->xsize; \
for (yyy = yy; yyy < yyysize; yyy++) { \
INT *in = (INT *)imIn->image[yyy]; \
for (xxx = xx; xxx < xxxsize; xxx++) { \
@ -201,10 +202,8 @@ ImagingTranspose(Imaging imOut, Imaging imIn)
return imOut;
}
Imaging
ImagingTransverse(Imaging imOut, Imaging imIn)
{
ImagingTransverse(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int x, y, xr, yr, xx, yy, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize;
@ -225,8 +224,12 @@ ImagingTransverse(Imaging imOut, Imaging imIn)
xxsize = x + ROTATE_CHUNK < imIn->xsize ? x + ROTATE_CHUNK : imIn->xsize; \
for (yy = y; yy < yysize; yy += ROTATE_SMALL_CHUNK) { \
for (xx = x; xx < xxsize; xx += ROTATE_SMALL_CHUNK) { \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize ? yy + ROTATE_SMALL_CHUNK : imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize ? xx + ROTATE_SMALL_CHUNK : imIn->xsize; \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize \
? yy + ROTATE_SMALL_CHUNK \
: imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize \
? xx + ROTATE_SMALL_CHUNK \
: imIn->xsize; \
yr = imIn->ysize - 1 - yy; \
for (yyy = yy; yyy < yyysize; yyy++, yr--) { \
INT *in = (INT *)imIn->image[yyy]; \
@ -260,10 +263,8 @@ ImagingTransverse(Imaging imOut, Imaging imIn)
return imOut;
}
Imaging
ImagingRotate180(Imaging imOut, Imaging imIn)
{
ImagingRotate180(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int x, y, xr, yr;
@ -306,10 +307,8 @@ ImagingRotate180(Imaging imOut, Imaging imIn)
return imOut;
}
Imaging
ImagingRotate270(Imaging imOut, Imaging imIn)
{
ImagingRotate270(Imaging imOut, Imaging imIn) {
ImagingSectionCookie cookie;
int x, y, xx, yy, yr, xxsize, yysize;
int xxx, yyy, xxxsize, yyysize;
@ -330,8 +329,12 @@ ImagingRotate270(Imaging imOut, Imaging imIn)
xxsize = x + ROTATE_CHUNK < imIn->xsize ? x + ROTATE_CHUNK : imIn->xsize; \
for (yy = y; yy < yysize; yy += ROTATE_SMALL_CHUNK) { \
for (xx = x; xx < xxsize; xx += ROTATE_SMALL_CHUNK) { \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize ? yy + ROTATE_SMALL_CHUNK : imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize ? xx + ROTATE_SMALL_CHUNK : imIn->xsize; \
yyysize = yy + ROTATE_SMALL_CHUNK < imIn->ysize \
? yy + ROTATE_SMALL_CHUNK \
: imIn->ysize; \
xxxsize = xx + ROTATE_SMALL_CHUNK < imIn->xsize \
? xx + ROTATE_SMALL_CHUNK \
: imIn->xsize; \
yr = imIn->ysize - 1 - yy; \
for (yyy = yy; yyy < yyysize; yyy++, yr--) { \
INT *in = (INT *)imIn->image[yyy]; \
@ -364,22 +367,24 @@ ImagingRotate270(Imaging imOut, Imaging imIn)
return imOut;
}
/* -------------------------------------------------------------------- */
/* Transforms */
/* transform primitives (ImagingTransformMap) */
static int
affine_transform(double* xout, double* yout, int x, int y, void* data)
{
affine_transform(double *xout, double *yout, int x, int y, void *data) {
/* full moon tonight. your compiler will generate bogus code
for simple expressions, unless you reorganize the code, or
install Service Pack 3 */
double *a = (double *)data;
double a0 = a[0]; double a1 = a[1]; double a2 = a[2];
double a3 = a[3]; double a4 = a[4]; double a5 = a[5];
double a0 = a[0];
double a1 = a[1];
double a2 = a[2];
double a3 = a[3];
double a4 = a[4];
double a5 = a[5];
double xin = x + 0.5;
double yin = y + 0.5;
@ -391,12 +396,16 @@ affine_transform(double* xout, double* yout, int x, int y, void* data)
}
static int
perspective_transform(double* xout, double* yout, int x, int y, void* data)
{
perspective_transform(double *xout, double *yout, int x, int y, void *data) {
double *a = (double *)data;
double a0 = a[0]; double a1 = a[1]; double a2 = a[2];
double a3 = a[3]; double a4 = a[4]; double a5 = a[5];
double a6 = a[6]; double a7 = a[7];
double a0 = a[0];
double a1 = a[1];
double a2 = a[2];
double a3 = a[3];
double a4 = a[4];
double a5 = a[5];
double a6 = a[6];
double a7 = a[7];
double xin = x + 0.5;
double yin = y + 0.5;
@ -408,13 +417,18 @@ perspective_transform(double* xout, double* yout, int x, int y, void* data)
}
static int
quad_transform(double* xout, double* yout, int x, int y, void* data)
{
quad_transform(double *xout, double *yout, int x, int y, void *data) {
/* quad warp: map quadrilateral to rectangle */
double *a = (double *)data;
double a0 = a[0]; double a1 = a[1]; double a2 = a[2]; double a3 = a[3];
double a4 = a[4]; double a5 = a[5]; double a6 = a[6]; double a7 = a[7];
double a0 = a[0];
double a1 = a[1];
double a2 = a[2];
double a3 = a[3];
double a4 = a[4];
double a5 = a[5];
double a6 = a[6];
double a7 = a[7];
double xin = x + 0.5;
double yin = y + 0.5;
@ -428,8 +442,7 @@ quad_transform(double* xout, double* yout, int x, int y, void* data)
/* transform filters (ImagingTransformFilter) */
static int
nearest_filter8(void* out, Imaging im, double xin, double yin)
{
nearest_filter8(void *out, Imaging im, double xin, double yin) {
int x = COORD(xin);
int y = COORD(yin);
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) {
@ -440,8 +453,7 @@ nearest_filter8(void* out, Imaging im, double xin, double yin)
}
static int
nearest_filter16(void* out, Imaging im, double xin, double yin)
{
nearest_filter16(void *out, Imaging im, double xin, double yin) {
int x = COORD(xin);
int y = COORD(yin);
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) {
@ -452,8 +464,7 @@ nearest_filter16(void* out, Imaging im, double xin, double yin)
}
static int
nearest_filter32(void* out, Imaging im, double xin, double yin)
{
nearest_filter32(void *out, Imaging im, double xin, double yin) {
int x = COORD(xin);
int y = COORD(yin);
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) {
@ -466,8 +477,7 @@ nearest_filter32(void* out, Imaging im, double xin, double yin)
#define XCLIP(im, x) (((x) < 0) ? 0 : ((x) < im->xsize) ? (x) : im->xsize - 1)
#define YCLIP(im, y) (((y) < 0) ? 0 : ((y) < im->ysize) ? (y) : im->ysize - 1)
#define BILINEAR(v, a, b, d)\
(v = (a) + ( (b) - (a) ) * (d))
#define BILINEAR(v, a, b, d) (v = (a) + ((b) - (a)) * (d))
#define BILINEAR_HEAD(type) \
int x, y; \
@ -485,7 +495,8 @@ nearest_filter32(void* out, Imaging im, double xin, double yin)
dx = xin - x; \
dy = yin - y;
#define BILINEAR_BODY(type, image, step, offset) {\
#define BILINEAR_BODY(type, image, step, offset) \
{ \
in = (type *)((image)[YCLIP(im, y)] + offset); \
x0 = XCLIP(im, x + 0) * step; \
x1 = XCLIP(im, x + 1) * step; \
@ -500,8 +511,7 @@ nearest_filter32(void* out, Imaging im, double xin, double yin)
}
static int
bilinear_filter8(void* out, Imaging im, double xin, double yin)
{
bilinear_filter8(void *out, Imaging im, double xin, double yin) {
BILINEAR_HEAD(UINT8);
BILINEAR_BODY(UINT8, im->image8, 1, 0);
((UINT8 *)out)[0] = (UINT8)v1;
@ -509,8 +519,7 @@ bilinear_filter8(void* out, Imaging im, double xin, double yin)
}
static int
bilinear_filter32I(void* out, Imaging im, double xin, double yin)
{
bilinear_filter32I(void *out, Imaging im, double xin, double yin) {
INT32 k;
BILINEAR_HEAD(INT32);
BILINEAR_BODY(INT32, im->image32, 1, 0);
@ -520,8 +529,7 @@ bilinear_filter32I(void* out, Imaging im, double xin, double yin)
}
static int
bilinear_filter32F(void* out, Imaging im, double xin, double yin)
{
bilinear_filter32F(void *out, Imaging im, double xin, double yin) {
FLOAT32 k;
BILINEAR_HEAD(FLOAT32);
BILINEAR_BODY(FLOAT32, im->image32, 1, 0);
@ -531,8 +539,7 @@ bilinear_filter32F(void* out, Imaging im, double xin, double yin)
}
static int
bilinear_filter32LA(void* out, Imaging im, double xin, double yin)
{
bilinear_filter32LA(void *out, Imaging im, double xin, double yin) {
BILINEAR_HEAD(UINT8);
BILINEAR_BODY(UINT8, im->image, 4, 0);
((UINT8 *)out)[0] = (UINT8)v1;
@ -544,8 +551,7 @@ bilinear_filter32LA(void* out, Imaging im, double xin, double yin)
}
static int
bilinear_filter32RGB(void* out, Imaging im, double xin, double yin)
{
bilinear_filter32RGB(void *out, Imaging im, double xin, double yin) {
int b;
BILINEAR_HEAD(UINT8);
for (b = 0; b < im->bands; b++) {
@ -559,7 +565,8 @@ bilinear_filter32RGB(void* out, Imaging im, double xin, double yin)
#undef BILINEAR_HEAD
#undef BILINEAR_BODY
#define BICUBIC(v, v1, v2, v3, v4, d) {\
#define BICUBIC(v, v1, v2, v3, v4, d) \
{ \
double p1 = v2; \
double p2 = -v1 + v3; \
double p3 = 2 * (v1 - v2) + v3 - v4; \
@ -583,9 +590,11 @@ bilinear_filter32RGB(void* out, Imaging im, double xin, double yin)
y = FLOOR(yin); \
dx = xin - x; \
dy = yin - y; \
x--; y--;
x--; \
y--;
#define BICUBIC_BODY(type, image, step, offset) {\
#define BICUBIC_BODY(type, image, step, offset) \
{ \
in = (type *)((image)[YCLIP(im, y)] + offset); \
x0 = XCLIP(im, x + 0) * step; \
x1 = XCLIP(im, x + 1) * step; \
@ -613,10 +622,8 @@ bilinear_filter32RGB(void* out, Imaging im, double xin, double yin)
BICUBIC(v1, v1, v2, v3, v4, dy); \
}
static int
bicubic_filter8(void* out, Imaging im, double xin, double yin)
{
bicubic_filter8(void *out, Imaging im, double xin, double yin) {
BICUBIC_HEAD(UINT8);
BICUBIC_BODY(UINT8, im->image8, 1, 0);
if (v1 <= 0.0) {
@ -630,8 +637,7 @@ bicubic_filter8(void* out, Imaging im, double xin, double yin)
}
static int
bicubic_filter32I(void* out, Imaging im, double xin, double yin)
{
bicubic_filter32I(void *out, Imaging im, double xin, double yin) {
INT32 k;
BICUBIC_HEAD(INT32);
BICUBIC_BODY(INT32, im->image32, 1, 0);
@ -641,8 +647,7 @@ bicubic_filter32I(void* out, Imaging im, double xin, double yin)
}
static int
bicubic_filter32F(void* out, Imaging im, double xin, double yin)
{
bicubic_filter32F(void *out, Imaging im, double xin, double yin) {
FLOAT32 k;
BICUBIC_HEAD(FLOAT32);
BICUBIC_BODY(FLOAT32, im->image32, 1, 0);
@ -652,8 +657,7 @@ bicubic_filter32F(void* out, Imaging im, double xin, double yin)
}
static int
bicubic_filter32LA(void* out, Imaging im, double xin, double yin)
{
bicubic_filter32LA(void *out, Imaging im, double xin, double yin) {
BICUBIC_HEAD(UINT8);
BICUBIC_BODY(UINT8, im->image, 4, 0);
if (v1 <= 0.0) {
@ -681,8 +685,7 @@ bicubic_filter32LA(void* out, Imaging im, double xin, double yin)
}
static int
bicubic_filter32RGB(void* out, Imaging im, double xin, double yin)
{
bicubic_filter32RGB(void *out, Imaging im, double xin, double yin) {
int b;
BICUBIC_HEAD(UINT8);
for (b = 0; b < im->bands; b++) {
@ -703,8 +706,7 @@ bicubic_filter32RGB(void* out, Imaging im, double xin, double yin)
#undef BICUBIC_BODY
static ImagingTransformFilter
getfilter(Imaging im, int filterid)
{
getfilter(Imaging im, int filterid) {
switch (filterid) {
case IMAGING_TRANSFORM_NEAREST:
if (im->image8) {
@ -770,10 +772,16 @@ getfilter(Imaging im, int filterid)
Imaging
ImagingGenericTransform(
Imaging imOut, Imaging imIn, int x0, int y0, int x1, int y1,
ImagingTransformMap transform, void* transform_data,
int filterid, int fill)
{
Imaging imOut,
Imaging imIn,
int x0,
int y0,
int x1,
int y1,
ImagingTransformMap transform,
void *transform_data,
int filterid,
int fill) {
/* slow generic transformation. use ImagingTransformAffine or
ImagingScaleAffine where possible. */
@ -827,10 +835,15 @@ ImagingGenericTransform(
}
static Imaging
ImagingScaleAffine(Imaging imOut, Imaging imIn,
int x0, int y0, int x1, int y1,
double a[6], int fill)
{
ImagingScaleAffine(
Imaging imOut,
Imaging imIn,
int x0,
int y0,
int x1,
int y1,
double a[6],
int fill) {
/* scale, nearest neighbour resampling */
ImagingSectionCookie cookie;
@ -920,17 +933,23 @@ ImagingScaleAffine(Imaging imOut, Imaging imIn,
}
static inline int
check_fixed(double a[6], int x, int y)
{
return (fabs(x*a[0] + y*a[1] + a[2]) < 32768.0 &&
check_fixed(double a[6], int x, int y) {
return (
fabs(x * a[0] + y * a[1] + a[2]) < 32768.0 &&
fabs(x * a[3] + y * a[4] + a[5]) < 32768.0);
}
static inline Imaging
affine_fixed(Imaging imOut, Imaging imIn,
int x0, int y0, int x1, int y1,
double a[6], int filterid, int fill)
{
affine_fixed(
Imaging imOut,
Imaging imIn,
int x0,
int y0,
int x1,
int y1,
double a[6],
int filterid,
int fill) {
/* affine transform, nearest neighbour resampling, fixed point
arithmetics */
@ -949,8 +968,10 @@ affine_fixed(Imaging imOut, Imaging imIn,
/* use 16.16 fixed point arithmetics */
#define FIX(v) FLOOR((v)*65536.0 + 0.5)
a0 = FIX(a[0]); a1 = FIX(a[1]);
a3 = FIX(a[3]); a4 = FIX(a[4]);
a0 = FIX(a[0]);
a1 = FIX(a[1]);
a3 = FIX(a[3]);
a4 = FIX(a[4]);
a2 = FIX(a[2] + a[0] * 0.5 + a[1] * 0.5);
a5 = FIX(a[5] + a[3] * 0.5 + a[4] * 0.5);
@ -996,10 +1017,16 @@ affine_fixed(Imaging imOut, Imaging imIn,
}
Imaging
ImagingTransformAffine(Imaging imOut, Imaging imIn,
int x0, int y0, int x1, int y1,
double a[6], int filterid, int fill)
{
ImagingTransformAffine(
Imaging imOut,
Imaging imIn,
int x0,
int y0,
int x1,
int y1,
double a[6],
int filterid,
int fill) {
/* affine transform, nearest neighbour resampling, floating point
arithmetics*/
@ -1012,10 +1039,7 @@ ImagingTransformAffine(Imaging imOut, Imaging imIn,
if (filterid || imIn->type == IMAGING_TYPE_SPECIAL) {
return ImagingGenericTransform(
imOut, imIn,
x0, y0, x1, y1,
affine_transform, a,
filterid, fill);
imOut, imIn, x0, y0, x1, y1, affine_transform, a, filterid, fill);
}
if (a[1] == 0 && a[3] == 0) {
@ -1100,10 +1124,17 @@ ImagingTransformAffine(Imaging imOut, Imaging imIn,
}
Imaging
ImagingTransform(Imaging imOut, Imaging imIn, int method,
int x0, int y0, int x1, int y1,
double a[8], int filterid, int fill)
{
ImagingTransform(
Imaging imOut,
Imaging imIn,
int method,
int x0,
int y0,
int x1,
int y1,
double a[8],
int filterid,
int fill) {
ImagingTransformMap transform;
switch (method) {
@ -1122,7 +1153,5 @@ ImagingTransform(Imaging imOut, Imaging imIn, int method,
}
return ImagingGenericTransform(
imOut, imIn,
x0, y0, x1, y1,
transform, a, filterid, fill);
imOut, imIn, x0, y0, x1, y1, transform, a, filterid, fill);
}

48
src/libImaging/GetBBox.c
View File

@ -16,13 +16,10 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingGetBBox(Imaging im, int bbox[4])
{
ImagingGetBBox(Imaging im, int bbox[4]) {
/* Get the bounding box for any non-zero data in the image.*/
int x, y;
@ -61,10 +58,9 @@ ImagingGetBBox(Imaging im, int bbox[4])
INT32 mask = 0xffffffff;
if (im->bands == 3) {
((UINT8 *)&mask)[3] = 0;
} else if (strcmp(im->mode, "RGBa") == 0 ||
strcmp(im->mode, "RGBA") == 0 ||
strcmp(im->mode, "La") == 0 ||
strcmp(im->mode, "LA") == 0 ||
} else if (
strcmp(im->mode, "RGBa") == 0 || strcmp(im->mode, "RGBA") == 0 ||
strcmp(im->mode, "La") == 0 || strcmp(im->mode, "LA") == 0 ||
strcmp(im->mode, "PA") == 0) {
#ifdef WORDS_BIGENDIAN
mask = 0x000000ff;
@ -83,10 +79,8 @@ ImagingGetBBox(Imaging im, int bbox[4])
return 1; /* ok */
}
int
ImagingGetProjection(Imaging im, UINT8* xproj, UINT8* yproj)
{
ImagingGetProjection(Imaging im, UINT8 *xproj, UINT8 *yproj) {
/* Get projection arrays for non-zero data in the image.*/
int x, y;
@ -123,10 +117,8 @@ ImagingGetProjection(Imaging im, UINT8* xproj, UINT8* yproj)
return 1; /* ok */
}
int
ImagingGetExtrema(Imaging im, void *extrema)
{
ImagingGetExtrema(Imaging im, void *extrema) {
int x, y;
INT32 imin, imax;
FLOAT32 fmin, fmax;
@ -225,20 +217,18 @@ ImagingGetExtrema(Imaging im, void *extrema)
return 1; /* ok */
}
/* static ImagingColorItem* getcolors8(Imaging im, int maxcolors, int* size);*/
static ImagingColorItem* getcolors32(Imaging im, int maxcolors, int* size);
static ImagingColorItem *
getcolors32(Imaging im, int maxcolors, int *size);
ImagingColorItem *
ImagingGetColors(Imaging im, int maxcolors, int* size)
{
ImagingGetColors(Imaging im, int maxcolors, int *size) {
/* FIXME: add support for 8-bit images */
return getcolors32(im, maxcolors, size);
}
static ImagingColorItem *
getcolors32(Imaging im, int maxcolors, int* size)
{
getcolors32(Imaging im, int maxcolors, int *size) {
unsigned int h;
unsigned int i, incr;
int colors;
@ -256,12 +246,12 @@ getcolors32(Imaging im, int maxcolors, int* size)
Python's Unicode property database (written by yours truly) /F */
static int SIZES[] = {
4,3, 8,3, 16,3, 32,5, 64,3, 128,3, 256,29, 512,17, 1024,9, 2048,5,
4096,83, 8192,27, 16384,43, 32768,3, 65536,45, 131072,9, 262144,39,
524288,39, 1048576,9, 2097152,5, 4194304,3, 8388608,33, 16777216,27,
33554432,9, 67108864,71, 134217728,39, 268435456,9, 536870912,5,
1073741824,83, 0
};
4, 3, 8, 3, 16, 3, 32, 5, 64, 3,
128, 3, 256, 29, 512, 17, 1024, 9, 2048, 5,
4096, 83, 8192, 27, 16384, 43, 32768, 3, 65536, 45,
131072, 9, 262144, 39, 524288, 39, 1048576, 9, 2097152, 5,
4194304, 3, 8388608, 33, 16777216, 27, 33554432, 9, 67108864, 71,
134217728, 39, 268435456, 9, 536870912, 5, 1073741824, 83, 0};
code_size = code_poly = code_mask = 0;
@ -309,7 +299,8 @@ getcolors32(Imaging im, int maxcolors, int* size)
if (colors++ == maxcolors) {
goto overflow;
}
v->x = x; v->y = y;
v->x = x;
v->y = y;
v->pixel = pixel;
v->count = 1;
continue;
@ -329,7 +320,8 @@ getcolors32(Imaging im, int maxcolors, int* size)
if (colors++ == maxcolors) {
goto overflow;
}
v->x = x; v->y = y;
v->x = x;
v->y = y;
v->pixel = pixel;
v->count = 1;
break;

7
src/libImaging/Gif.h
View File

@ -7,7 +7,6 @@
* Copyright (c) Fredrik Lundh 1995-96.
*/
/* Max size for a LZW code word. */
#define GIFBITS 12
@ -15,9 +14,7 @@
#define GIFTABLE (1 << GIFBITS)
#define GIFBUFFER (1 << GIFBITS)
typedef struct {
/* CONFIGURATION */
/* Initial number of bits. The caller should clear all fields in
@ -65,15 +62,13 @@ typedef struct {
} GIFDECODERSTATE;
typedef struct GIFENCODERBLOCK_T
{
typedef struct GIFENCODERBLOCK_T {
struct GIFENCODERBLOCK_T *next;
int size;
UINT8 data[255];
} GIFENCODERBLOCK;
typedef struct {
/* CONFIGURATION */
/* Initial number of bits. The caller should clear all fields in

42
src/libImaging/GifDecode.c
View File

@ -21,7 +21,6 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include <stdio.h>
@ -29,12 +28,11 @@
#include "Gif.h"
#define NEWLINE(state, context) {\
#define NEWLINE(state, context) \
{ \
state->x = 0; \
state->y += context->step; \
while (state->y >= state->ysize)\
switch (context->interlace) {\
while (state->y >= state->ysize) switch (context->interlace) { \
case 1: \
context->repeat = state->y = 4; \
context->interlace = 2; \
@ -57,10 +55,8 @@
} \
}
int
ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t bytes)
{
ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes) {
UINT8 *p;
UINT8 *out;
int c, i;
@ -70,7 +66,6 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
UINT8 *ptr = buffer;
if (!state->state) {
/* Initialise state */
if (context->bits < 0 || context->bits > 12) {
state->errcode = IMAGING_CODEC_CONFIG;
@ -97,9 +92,7 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
out = im->image8[state->y + state->yoff] + state->xoff + state->x;
for (;;) {
if (state->state == 1) {
/* First free entry in table */
context->next = context->clear + 2;
@ -115,7 +108,6 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
}
if (context->bufferindex < GIFBUFFER) {
/* Return whole buffer in one chunk */
i = GIFBUFFER - context->bufferindex;
p = &context->buffer[context->bufferindex];
@ -123,15 +115,13 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
context->bufferindex = GIFBUFFER;
} else {
/* Get current symbol */
while (context->bitcount < context->codesize) {
if (context->blocksize > 0) {
/* Read next byte */
c = *ptr++; bytes--;
c = *ptr++;
bytes--;
context->blocksize--;
@ -140,7 +130,6 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
context->bitcount += 8;
} else {
/* New GIF block */
/* We don't start decoding unless we have a full block */
@ -154,8 +143,8 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
context->blocksize = c;
ptr++; bytes--;
ptr++;
bytes--;
}
}
@ -185,7 +174,6 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
p = &context->lastdata;
if (state->state == 2) {
/* First valid symbol after clear; use as is */
if (c > context->clear) {
state->errcode = IMAGING_CODEC_BROKEN;
@ -196,7 +184,6 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
state->state = 3;
} else {
thiscode = c;
if (c > context->next) {
@ -205,7 +192,6 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
}
if (c == context->next) {
/* c == next is allowed. not sure why. */
if (context->bufferindex <= 0) {
@ -213,15 +199,12 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
return -1;
}
context->buffer[--context->bufferindex] =
context->lastdata;
context->buffer[--context->bufferindex] = context->lastdata;
c = context->lastcode;
}
while (c >= context->clear) {
/* Copy data string to buffer (beginning from right) */
if (context->bufferindex <= 0 || c >= GIFTABLE) {
@ -229,8 +212,7 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
return -1;
}
context->buffer[--context->bufferindex] =
context->data[c];
context->buffer[--context->bufferindex] = context->data[c];
c = context->link[c];
}
@ -238,7 +220,6 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
context->lastdata = c;
if (context->next < GIFTABLE) {
/* We'll only add this symbol if we have room
for it (take advise, Netscape!) */
context->data[context->next] = c;
@ -246,18 +227,15 @@ ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t
if (context->next == context->codemask &&
context->codesize < GIFBITS) {
/* Expand code size */
context->codesize++;
context->codemask = (1 << context->codesize) - 1;
}
context->next++;
}
context->lastcode = thiscode;
}
}

31
src/libImaging/GifEncode.c
View File

@ -35,8 +35,7 @@ enum { INIT, ENCODE, ENCODE_EOF, FLUSH, EXIT };
necessary. */
static inline int
emit(GIFENCODERSTATE *context, int byte)
{
emit(GIFENCODERSTATE *context, int byte) {
/* write a byte to the output buffer */
if (!context->block || context->block->size == 255) {
@ -74,7 +73,6 @@ emit(GIFENCODERSTATE *context, int byte)
block->next = NULL;
context->block = block;
}
/* write new byte to block */
@ -86,7 +84,8 @@ emit(GIFENCODERSTATE *context, int byte)
/* write a code word to the current block. this is a macro to make
sure it's inlined on all platforms */
#define EMIT(code) {\
#define EMIT(code) \
{ \
context->bitbuffer |= ((INT32)(code)) << context->bitcount; \
context->bitcount += 9; \
while (context->bitcount >= 8) { \
@ -104,7 +103,8 @@ emit(GIFENCODERSTATE *context, int byte)
long stretches of identical pixels. but remember: if you want
really good compression, use another file format. */
#define EMIT_RUN(label) {\
#define EMIT_RUN(label) \
{ \
label: \
while (context->count > 0) { \
int run = 2; \
@ -138,8 +138,7 @@ label:\
}
int
ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
UINT8 *ptr;
int this;
@ -147,7 +146,6 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
GIFENCODERSTATE *context = (GIFENCODERSTATE *)state->context;
if (!state->state) {
/* place a clear code in the output buffer */
context->bitbuffer = CLEAR_CODE;
context->bitcount = 9;
@ -167,22 +165,17 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
if (state->xsize <= 0 || state->ysize <= 0) {
state->state = ENCODE_EOF;
}
}
ptr = buf;
for (;;)
switch (state->state) {
for (;;) switch (state->state) {
case INIT:
case ENCODE:
/* identify and store a run of pixels */
if (state->x == 0 || state->x >= state->xsize) {
if (!context->interlace && state->y >= state->ysize) {
state->state = ENCODE_EOF;
break;
@ -197,8 +190,8 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
state->shuffle(
state->buffer,
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->xsize
);
state->xoff * im->pixelsize,
state->xsize);
state->x = 0;
@ -231,7 +224,6 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
/* just make sure we don't loop forever */
context->interlace = 0;
}
}
/* Potential special case for xsize==1 */
if (state->x < state->xsize) {
@ -250,7 +242,6 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
break;
case ENCODE_EOF:
/* write the final run */
@ -292,12 +283,10 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
case FLUSH:
while (context->flush) {
/* get a block from the flush queue */
block = context->flush;
if (block->size > 0) {
/* make sure it fits into the output buffer */
if (bytes < block->size + 1) {
return ptr - buf;
@ -308,7 +297,6 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
ptr += block->size + 1;
bytes -= block->size + 1;
}
context->flush = block->next;
@ -317,7 +305,6 @@ ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
free(context->free);
}
context->free = block;
}
if (state->state == EXIT) {

21
src/libImaging/HexDecode.c
View File

@ -13,23 +13,22 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#define HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
(v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
(v >= 'A' && v <= 'F') ? v - 'A' + 10 : -1)
#define HEX(v) \
((v >= '0' && v <= '9') ? v - '0' \
: (v >= 'a' && v <= 'f') ? v - 'a' + 10 \
: (v >= 'A' && v <= 'F') ? v - 'A' + 10 \
: -1)
int
ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
UINT8 *ptr;
int a, b;
ptr = buf;
for (;;) {
if (bytes < 2) {
return ptr - buf;
}
@ -38,22 +37,19 @@ ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
b = HEX(ptr[1]);
if (a < 0 || b < 0) {
ptr++;
bytes--;
} else {
ptr += 2;
bytes -= 2;
state->buffer[state->x] = (a << 4) + b;
if (++state->x >= state->bytes) {
/* Got a full line, unpack it */
state->shuffle((UINT8*) im->image[state->y], state->buffer,
state->xsize);
state->shuffle(
(UINT8 *)im->image[state->y], state->buffer, state->xsize);
state->x = 0;
@ -62,7 +58,6 @@ ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
return -1;
}
}
}
}
}

11
src/libImaging/Histo.c
View File

@ -16,10 +16,8 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
/* HISTOGRAM */
/* --------------------------------------------------------------------
* Take a histogram of an image. Returns a histogram object containing
@ -27,8 +25,7 @@
*/
void
ImagingHistogramDelete(ImagingHistogram h)
{
ImagingHistogramDelete(ImagingHistogram h) {
if (h) {
if (h->histogram) {
free(h->histogram);
@ -38,8 +35,7 @@ ImagingHistogramDelete(ImagingHistogram h)
}
ImagingHistogram
ImagingHistogramNew(Imaging im)
{
ImagingHistogramNew(Imaging im) {
ImagingHistogram h;
/* Create histogram descriptor */
@ -61,8 +57,7 @@ ImagingHistogramNew(Imaging im)
}
ImagingHistogram
ImagingGetHistogram(Imaging im, Imaging imMask, void* minmax)
{
ImagingGetHistogram(Imaging im, Imaging imMask, void *minmax) {
ImagingSectionCookie cookie;
int x, y, i;
ImagingHistogram h;

21
src/libImaging/ImDib.h
View File

@ -37,18 +37,25 @@ struct ImagingDIBInstance {
typedef struct ImagingDIBInstance *ImagingDIB;
extern char* ImagingGetModeDIB(int size_out[2]);
extern char *
ImagingGetModeDIB(int size_out[2]);
extern ImagingDIB ImagingNewDIB(const char *mode, int xsize, int ysize);
extern ImagingDIB
ImagingNewDIB(const char *mode, int xsize, int ysize);
extern void ImagingDeleteDIB(ImagingDIB im);
extern void
ImagingDeleteDIB(ImagingDIB im);
extern void ImagingDrawDIB(ImagingDIB dib, void *dc, int dst[4], int src[4]);
extern void ImagingExposeDIB(ImagingDIB dib, void *dc);
extern void
ImagingDrawDIB(ImagingDIB dib, void *dc, int dst[4], int src[4]);
extern void
ImagingExposeDIB(ImagingDIB dib, void *dc);
extern int ImagingQueryPaletteDIB(ImagingDIB dib, void *dc);
extern int
ImagingQueryPaletteDIB(ImagingDIB dib, void *dc);
extern void ImagingPasteDIB(ImagingDIB dib, Imaging im, int xy[4]);
extern void
ImagingPasteDIB(ImagingDIB dib, Imaging im, int xy[4]);
#if defined(__cplusplus)
}

7
src/libImaging/ImPlatform.h
View File

@ -10,7 +10,8 @@
#include "Python.h"
/* Workaround issue #2479 */
#if PY_VERSION_HEX < 0x03070000 && defined(PySlice_GetIndicesEx) && !defined(PYPY_VERSION)
#if PY_VERSION_HEX < 0x03070000 && defined(PySlice_GetIndicesEx) && \
!defined(PYPY_VERSION)
#undef PySlice_GetIndicesEx
#endif
@ -80,7 +81,5 @@ typedef signed __int64 int64_t;
#endif
#ifdef __GNUC__
#define GCC_VERSION (__GNUC__ * 10000 \
+ __GNUC_MINOR__ * 100 \
+ __GNUC_PATCHLEVEL__)
#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif

671
src/libImaging/Imaging.h
View File

@ -10,20 +10,16 @@
* See the README file for information on usage and redistribution.
*/
#include "ImPlatform.h"
#if defined(__cplusplus)
extern "C" {
#endif
#ifndef M_PI
#define M_PI 3.1415926535897932384626433832795
#endif
/* -------------------------------------------------------------------- */
/*
@ -73,7 +69,8 @@ typedef struct ImagingPaletteInstance* ImagingPalette;
#define IMAGING_TYPE_FLOAT32 2
#define IMAGING_TYPE_SPECIAL 3 /* check mode for details */
#define IMAGING_MODE_LENGTH 6+1 /* Band names ("1", "L", "P", "RGB", "RGBA", "CMYK", "YCbCr", "BGR;xy") */
#define IMAGING_MODE_LENGTH \
6 + 1 /* Band names ("1", "L", "P", "RGB", "RGBA", "CMYK", "YCbCr", "BGR;xy") */
typedef struct {
char *ptr;
@ -81,9 +78,9 @@ typedef struct {
} ImagingMemoryBlock;
struct ImagingMemoryInstance {
/* Format */
char mode[IMAGING_MODE_LENGTH]; /* Band names ("1", "L", "P", "RGB", "RGBA", "CMYK", "YCbCr", "BGR;xy") */
char mode[IMAGING_MODE_LENGTH]; /* Band names ("1", "L", "P", "RGB", "RGBA", "CMYK",
"YCbCr", "BGR;xy") */
int type; /* Data type (IMAGING_TYPE_*) */
int depth; /* Depth (ignored in this version) */
int bands; /* Number of bands (1, 2, 3, or 4) */
@ -109,7 +106,6 @@ struct ImagingMemoryInstance {
void (*destroy)(Imaging im);
};
#define IMAGING_PIXEL_1(im, x, y) ((im)->image8[(y)][(x)])
#define IMAGING_PIXEL_L(im, x, y) ((im)->image8[(y)][(x)])
#define IMAGING_PIXEL_LA(im, x, y) ((im)->image[(y)][(x)*4])
@ -134,19 +130,15 @@ struct ImagingAccessInstance {
};
struct ImagingHistogramInstance {
/* Format */
char mode[IMAGING_MODE_LENGTH]; /* Band names (of corresponding source image) */
int bands; /* Number of bands (1, 3, or 4) */
/* Data */
long *histogram; /* Histogram (bands*256 longs) */
};
struct ImagingPaletteInstance {
/* Format */
char mode[IMAGING_MODE_LENGTH]; /* Band names */
@ -155,7 +147,6 @@ struct ImagingPaletteInstance {
INT16 *cache; /* Palette cache (used for predefined palettes) */
int keep_cache; /* This palette will be reused; keep cache */
};
typedef struct ImagingMemoryArena {
@ -167,72 +158,98 @@ typedef struct ImagingMemoryArena {
int stats_new_count; /* Number of new allocated images */
int stats_allocated_blocks; /* Number of allocated blocks */
int stats_reused_blocks; /* Number of blocks which were retrieved from a pool */
int stats_reallocated_blocks; /* Number of blocks which were actually reallocated after retrieving */
int stats_reallocated_blocks; /* Number of blocks which were actually reallocated
after retrieving */
int stats_freed_blocks; /* Number of freed blocks */
} * ImagingMemoryArena;
/* Objects */
/* ------- */
extern struct ImagingMemoryArena ImagingDefaultArena;
extern int ImagingMemorySetBlocksMax(ImagingMemoryArena arena, int blocks_max);
extern void ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size);
extern int
ImagingMemorySetBlocksMax(ImagingMemoryArena arena, int blocks_max);
extern void
ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size);
extern Imaging ImagingNew(const char* mode, int xsize, int ysize);
extern Imaging ImagingNewDirty(const char* mode, int xsize, int ysize);
extern Imaging ImagingNew2Dirty(const char* mode, Imaging imOut, Imaging imIn);
extern void ImagingDelete(Imaging im);
extern Imaging
ImagingNew(const char *mode, int xsize, int ysize);
extern Imaging
ImagingNewDirty(const char *mode, int xsize, int ysize);
extern Imaging
ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn);
extern void
ImagingDelete(Imaging im);
extern Imaging ImagingNewBlock(const char* mode, int xsize, int ysize);
extern Imaging
ImagingNewBlock(const char *mode, int xsize, int ysize);
extern Imaging ImagingNewPrologue(const char *mode,
int xsize, int ysize);
extern Imaging ImagingNewPrologueSubtype(const char *mode,
int xsize, int ysize,
int structure_size);
extern Imaging
ImagingNewPrologue(const char *mode, int xsize, int ysize);
extern Imaging
ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int structure_size);
extern void ImagingCopyPalette(Imaging destination, Imaging source);
extern void
ImagingCopyPalette(Imaging destination, Imaging source);
extern void ImagingHistogramDelete(ImagingHistogram histogram);
extern void
ImagingHistogramDelete(ImagingHistogram histogram);
extern void ImagingAccessInit(void);
extern ImagingAccess ImagingAccessNew(Imaging im);
extern void _ImagingAccessDelete(Imaging im, ImagingAccess access);
extern void
ImagingAccessInit(void);
extern ImagingAccess
ImagingAccessNew(Imaging im);
extern void
_ImagingAccessDelete(Imaging im, ImagingAccess access);
#define ImagingAccessDelete(im, access) /* nop, for now */
extern ImagingPalette ImagingPaletteNew(const char *mode);
extern ImagingPalette ImagingPaletteNewBrowser(void);
extern ImagingPalette ImagingPaletteDuplicate(ImagingPalette palette);
extern void ImagingPaletteDelete(ImagingPalette palette);
extern ImagingPalette
ImagingPaletteNew(const char *mode);
extern ImagingPalette
ImagingPaletteNewBrowser(void);
extern ImagingPalette
ImagingPaletteDuplicate(ImagingPalette palette);
extern void
ImagingPaletteDelete(ImagingPalette palette);
extern int ImagingPaletteCachePrepare(ImagingPalette palette);
extern void ImagingPaletteCacheUpdate(ImagingPalette palette,
int r, int g, int b);
extern void ImagingPaletteCacheDelete(ImagingPalette palette);
extern int
ImagingPaletteCachePrepare(ImagingPalette palette);
extern void
ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b);
extern void
ImagingPaletteCacheDelete(ImagingPalette palette);
#define ImagingPaletteCache(p, r, g, b) \
p->cache[(r >> 2) + (g >> 2) * 64 + (b >> 2) * 64 * 64]
extern Imaging ImagingQuantize(Imaging im, int colours, int mode, int kmeans);
extern Imaging
ImagingQuantize(Imaging im, int colours, int mode, int kmeans);
/* Threading */
/* --------- */
typedef void *ImagingSectionCookie;
extern void ImagingSectionEnter(ImagingSectionCookie* cookie);
extern void ImagingSectionLeave(ImagingSectionCookie* cookie);
extern void
ImagingSectionEnter(ImagingSectionCookie *cookie);
extern void
ImagingSectionLeave(ImagingSectionCookie *cookie);
/* Exceptions */
/* ---------- */
extern void* ImagingError_OSError(void);
extern void* ImagingError_MemoryError(void);
extern void* ImagingError_ModeError(void); /* maps to ValueError by default */
extern void* ImagingError_Mismatch(void); /* maps to ValueError by default */
extern void* ImagingError_ValueError(const char* message);
extern void ImagingError_Clear(void);
extern void *
ImagingError_OSError(void);
extern void *
ImagingError_MemoryError(void);
extern void *
ImagingError_ModeError(void); /* maps to ValueError by default */
extern void *
ImagingError_Mismatch(void); /* maps to ValueError by default */
extern void *
ImagingError_ValueError(const char *message);
extern void
ImagingError_Clear(void);
/* Transform callbacks */
/* ------------------- */
@ -242,7 +259,6 @@ extern void ImagingError_Clear(void);
#define IMAGING_TRANSFORM_PERSPECTIVE 2
#define IMAGING_TRANSFORM_QUAD 3
/* standard filters */
#define IMAGING_TRANSFORM_NEAREST 0
#define IMAGING_TRANSFORM_BOX 4
@ -251,249 +267,391 @@ extern void ImagingError_Clear(void);
#define IMAGING_TRANSFORM_BICUBIC 3
#define IMAGING_TRANSFORM_LANCZOS 1
typedef int (*ImagingTransformMap)(double* X, double* Y,
int x, int y, void* data);
typedef int (*ImagingTransformFilter)(void* out, Imaging im,
double x, double y);
typedef int (*ImagingTransformMap)(double *X, double *Y, int x, int y, void *data);
typedef int (*ImagingTransformFilter)(void *out, Imaging im, double x, double y);
/* Image Manipulation Methods */
/* -------------------------- */
extern Imaging ImagingAlphaComposite(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha);
extern Imaging ImagingCopy(Imaging im);
extern Imaging ImagingConvert(Imaging im, const char* mode, ImagingPalette palette, int dither);
extern Imaging ImagingConvertInPlace(Imaging im, const char* mode);
extern Imaging ImagingConvertMatrix(Imaging im, const char *mode, float m[]);
extern Imaging ImagingConvertTransparent(Imaging im, const char *mode, int r, int g, int b);
extern Imaging ImagingCrop(Imaging im, int x0, int y0, int x1, int y1);
extern Imaging ImagingExpand(Imaging im, int x, int y, int mode);
extern Imaging ImagingFill(Imaging im, const void* ink);
extern int ImagingFill2(
Imaging into, const void* ink, Imaging mask,
int x0, int y0, int x1, int y1);
extern Imaging ImagingFillBand(Imaging im, int band, int color);
extern Imaging ImagingFillLinearGradient(const char* mode);
extern Imaging ImagingFillRadialGradient(const char* mode);
extern Imaging ImagingFilter(
Imaging im, int xsize, int ysize, const FLOAT32* kernel,
FLOAT32 offset);
extern Imaging ImagingFlipLeftRight(Imaging imOut, Imaging imIn);
extern Imaging ImagingFlipTopBottom(Imaging imOut, Imaging imIn);
extern Imaging ImagingGaussianBlur(Imaging imOut, Imaging imIn, float radius,
int passes);
extern Imaging ImagingGetBand(Imaging im, int band);
extern Imaging ImagingMerge(const char* mode, Imaging bands[4]);
extern int ImagingSplit(Imaging im, Imaging bands[4]);
extern int ImagingGetBBox(Imaging im, int bbox[4]);
typedef struct { int x, y; INT32 count; INT32 pixel; } ImagingColorItem;
extern ImagingColorItem* ImagingGetColors(Imaging im, int maxcolors,
int *colors);
extern int ImagingGetExtrema(Imaging im, void *extrema);
extern int ImagingGetProjection(Imaging im, UINT8* xproj, UINT8* yproj);
extern ImagingHistogram ImagingGetHistogram(
Imaging im, Imaging mask, void *extrema);
extern Imaging ImagingModeFilter(Imaging im, int size);
extern Imaging ImagingNegative(Imaging im);
extern Imaging 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 char* tablemode, const void* table);
extern Imaging ImagingPointTransform(
Imaging imIn, double scale, double offset);
extern Imaging ImagingPutBand(Imaging im, Imaging imIn, int band);
extern Imaging ImagingRankFilter(Imaging im, int size, int rank);
extern Imaging ImagingRotate90(Imaging imOut, Imaging imIn);
extern Imaging ImagingRotate180(Imaging imOut, Imaging imIn);
extern Imaging ImagingRotate270(Imaging imOut, Imaging imIn);
extern Imaging ImagingTranspose(Imaging imOut, Imaging imIn);
extern Imaging ImagingTransverse(Imaging imOut, Imaging imIn);
extern Imaging ImagingResample(Imaging imIn, int xsize, int ysize, int filter, float box[4]);
extern Imaging ImagingReduce(Imaging imIn, int xscale, int yscale, int box[4]);
extern Imaging ImagingTransform(
Imaging imOut, Imaging imIn, int method, int x0, int y0, int x1, int y1,
double *a, int filter, int fill);
extern Imaging ImagingUnsharpMask(
Imaging imOut, Imaging im, float radius, int percent, int threshold);
extern Imaging ImagingBoxBlur(Imaging imOut, Imaging imIn, float radius, int n);
extern Imaging ImagingColorLUT3D_linear(Imaging imOut, Imaging imIn,
int table_channels, int size1D, int size2D, int size3D, INT16* table);
extern Imaging
ImagingAlphaComposite(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingBlend(Imaging imIn1, Imaging imIn2, float alpha);
extern Imaging
ImagingCopy(Imaging im);
extern Imaging
ImagingConvert(Imaging im, const char *mode, ImagingPalette palette, int dither);
extern Imaging
ImagingConvertInPlace(Imaging im, const char *mode);
extern Imaging
ImagingConvertMatrix(Imaging im, const char *mode, float m[]);
extern Imaging
ImagingConvertTransparent(Imaging im, const char *mode, int r, int g, int b);
extern Imaging
ImagingCrop(Imaging im, int x0, int y0, int x1, int y1);
extern Imaging
ImagingExpand(Imaging im, int x, int y, int mode);
extern Imaging
ImagingFill(Imaging im, const void *ink);
extern int
ImagingFill2(
Imaging into, const void *ink, Imaging mask, int x0, int y0, int x1, int y1);
extern Imaging
ImagingFillBand(Imaging im, int band, int color);
extern Imaging
ImagingFillLinearGradient(const char *mode);
extern Imaging
ImagingFillRadialGradient(const char *mode);
extern Imaging
ImagingFilter(Imaging im, int xsize, int ysize, const FLOAT32 *kernel, FLOAT32 offset);
extern Imaging
ImagingFlipLeftRight(Imaging imOut, Imaging imIn);
extern Imaging
ImagingFlipTopBottom(Imaging imOut, Imaging imIn);
extern Imaging
ImagingGaussianBlur(Imaging imOut, Imaging imIn, float radius, int passes);
extern Imaging
ImagingGetBand(Imaging im, int band);
extern Imaging
ImagingMerge(const char *mode, Imaging bands[4]);
extern int
ImagingSplit(Imaging im, Imaging bands[4]);
extern int
ImagingGetBBox(Imaging im, int bbox[4]);
typedef struct {
int x, y;
INT32 count;
INT32 pixel;
} ImagingColorItem;
extern ImagingColorItem *
ImagingGetColors(Imaging im, int maxcolors, int *colors);
extern int
ImagingGetExtrema(Imaging im, void *extrema);
extern int
ImagingGetProjection(Imaging im, UINT8 *xproj, UINT8 *yproj);
extern ImagingHistogram
ImagingGetHistogram(Imaging im, Imaging mask, void *extrema);
extern Imaging
ImagingModeFilter(Imaging im, int size);
extern Imaging
ImagingNegative(Imaging im);
extern Imaging
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 char *tablemode, const void *table);
extern Imaging
ImagingPointTransform(Imaging imIn, double scale, double offset);
extern Imaging
ImagingPutBand(Imaging im, Imaging imIn, int band);
extern Imaging
ImagingRankFilter(Imaging im, int size, int rank);
extern Imaging
ImagingRotate90(Imaging imOut, Imaging imIn);
extern Imaging
ImagingRotate180(Imaging imOut, Imaging imIn);
extern Imaging
ImagingRotate270(Imaging imOut, Imaging imIn);
extern Imaging
ImagingTranspose(Imaging imOut, Imaging imIn);
extern Imaging
ImagingTransverse(Imaging imOut, Imaging imIn);
extern Imaging
ImagingResample(Imaging imIn, int xsize, int ysize, int filter, float box[4]);
extern Imaging
ImagingReduce(Imaging imIn, int xscale, int yscale, int box[4]);
extern Imaging
ImagingTransform(
Imaging imOut,
Imaging imIn,
int method,
int x0,
int y0,
int x1,
int y1,
double *a,
int filter,
int fill);
extern Imaging
ImagingUnsharpMask(Imaging imOut, Imaging im, float radius, int percent, int threshold);
extern Imaging
ImagingBoxBlur(Imaging imOut, Imaging imIn, float radius, int n);
extern Imaging
ImagingColorLUT3D_linear(
Imaging imOut,
Imaging imIn,
int table_channels,
int size1D,
int size2D,
int size3D,
INT16 *table);
extern Imaging ImagingCopy2(Imaging imOut, Imaging imIn);
extern Imaging ImagingConvert2(Imaging imOut, Imaging imIn);
extern Imaging
ImagingCopy2(Imaging imOut, Imaging imIn);
extern Imaging
ImagingConvert2(Imaging imOut, Imaging imIn);
/* Channel operations */
/* any mode, except "F" */
extern Imaging ImagingChopLighter(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopDarker(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopDifference(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopMultiply(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopScreen(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopAdd(
Imaging imIn1, Imaging imIn2, float scale, int offset);
extern Imaging ImagingChopSubtract(
Imaging imIn1, Imaging imIn2, float scale, int offset);
extern Imaging ImagingChopAddModulo(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopSubtractModulo(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopSoftLight(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopHardLight(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingOverlay(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopLighter(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopDarker(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopDifference(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopMultiply(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopScreen(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopAdd(Imaging imIn1, Imaging imIn2, float scale, int offset);
extern Imaging
ImagingChopSubtract(Imaging imIn1, Imaging imIn2, float scale, int offset);
extern Imaging
ImagingChopAddModulo(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopSubtractModulo(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopSoftLight(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopHardLight(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingOverlay(Imaging imIn1, Imaging imIn2);
/* "1" images only */
extern Imaging ImagingChopAnd(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopOr(Imaging imIn1, Imaging imIn2);
extern Imaging ImagingChopXor(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopAnd(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopOr(Imaging imIn1, Imaging imIn2);
extern Imaging
ImagingChopXor(Imaging imIn1, Imaging imIn2);
/* Graphics */
extern int ImagingDrawArc(Imaging im, int x0, int y0, int x1, int y1,
float start, float end, const void* ink, int width,
extern int
ImagingDrawArc(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink,
int width,
int op);
extern int
ImagingDrawBitmap(Imaging im, int x0, int y0, Imaging bitmap, const void *ink, int op);
extern int
ImagingDrawChord(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink,
int fill,
int width,
int op);
extern int
ImagingDrawEllipse(
Imaging im,
int x0,
int y0,
int x1,
int y1,
const void *ink,
int fill,
int width,
int op);
extern int
ImagingDrawLine(Imaging im, int x0, int y0, int x1, int y1, const void *ink, int op);
extern int
ImagingDrawWideLine(
Imaging im, int x0, int y0, int x1, int y1, const void *ink, int width, int op);
extern int
ImagingDrawPieslice(
Imaging im,
int x0,
int y0,
int x1,
int y1,
float start,
float end,
const void *ink,
int fill,
int width,
int op);
extern int
ImagingDrawPoint(Imaging im, int x, int y, const void *ink, int op);
extern int
ImagingDrawPolygon(Imaging im, int points, int *xy, const void *ink, int fill, int op);
extern int
ImagingDrawRectangle(
Imaging im,
int x0,
int y0,
int x1,
int y1,
const void *ink,
int fill,
int width,
int op);
extern int ImagingDrawBitmap(Imaging im, int x0, int y0, Imaging bitmap,
const void* ink, int op);
extern int ImagingDrawChord(Imaging im, int x0, int y0, int x1, int y1,
float start, float end, const void* ink, int fill,
int width, int op);
extern int ImagingDrawEllipse(Imaging im, int x0, int y0, int x1, int y1,
const void* ink, int fill, int width, int op);
extern int ImagingDrawLine(Imaging im, int x0, int y0, int x1, int y1,
const void* ink, int op);
extern int ImagingDrawWideLine(Imaging im, int x0, int y0, int x1, int y1,
const void* ink, int width, int op);
extern int ImagingDrawPieslice(Imaging im, int x0, int y0, int x1, int y1,
float start, float end, const void* ink, int fill,
int width, int op);
extern int ImagingDrawPoint(Imaging im, int x, int y, const void* ink, int op);
extern int ImagingDrawPolygon(Imaging im, int points, int *xy,
const void* ink, int fill, int op);
extern int ImagingDrawRectangle(Imaging im, int x0, int y0, int x1, int y1,
const void* ink, int fill, int width, int op);
/* Level 2 graphics (WORK IN PROGRESS) */
extern ImagingOutline ImagingOutlineNew(void);
extern void ImagingOutlineDelete(ImagingOutline outline);
extern ImagingOutline
ImagingOutlineNew(void);
extern void
ImagingOutlineDelete(ImagingOutline outline);
extern int ImagingDrawOutline(Imaging im, ImagingOutline outline,
const void* ink, int fill, int op);
extern int
ImagingDrawOutline(
Imaging im, ImagingOutline outline, const void *ink, int fill, int op);
extern int ImagingOutlineMove(ImagingOutline outline, float x, float y);
extern int ImagingOutlineLine(ImagingOutline outline, float x, float y);
extern int ImagingOutlineCurve(ImagingOutline outline, float x1, float y1,
float x2, float y2, float x3, float y3);
extern int ImagingOutlineTransform(ImagingOutline outline, double a[6]);
extern int
ImagingOutlineMove(ImagingOutline outline, float x, float y);
extern int
ImagingOutlineLine(ImagingOutline outline, float x, float y);
extern int
ImagingOutlineCurve(
ImagingOutline outline, float x1, float y1, float x2, float y2, float x3, float y3);
extern int
ImagingOutlineTransform(ImagingOutline outline, double a[6]);
extern int ImagingOutlineClose(ImagingOutline outline);
extern int
ImagingOutlineClose(ImagingOutline outline);
/* Special effects */
extern Imaging ImagingEffectSpread(Imaging imIn, int distance);
extern Imaging ImagingEffectNoise(int xsize, int ysize, float sigma);
extern Imaging ImagingEffectMandelbrot(int xsize, int ysize,
double extent[4], int quality);
extern Imaging
ImagingEffectSpread(Imaging imIn, int distance);
extern Imaging
ImagingEffectNoise(int xsize, int ysize, float sigma);
extern Imaging
ImagingEffectMandelbrot(int xsize, int ysize, double extent[4], int quality);
/* File I/O */
/* -------- */
/* Built-in drivers */
extern Imaging ImagingOpenPPM(const char* filename);
extern int ImagingSavePPM(Imaging im, const char* filename);
extern Imaging
ImagingOpenPPM(const char *filename);
extern int
ImagingSavePPM(Imaging im, const char *filename);
/* Codecs */
typedef struct ImagingCodecStateInstance *ImagingCodecState;
typedef int (*ImagingCodec)(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
typedef int (*ImagingCodec)(
Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int ImagingBcnDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingBitDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingEpsEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingFliDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingGifDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingGifEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingHexDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int
ImagingBcnDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingBitDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingEpsEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int
ImagingFliDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int
ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
#ifdef HAVE_LIBJPEG
extern int ImagingJpegDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingJpegDecodeCleanup(ImagingCodecState state);
extern int ImagingJpegUseJCSExtensions(void);
extern int
ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingJpegDecodeCleanup(ImagingCodecState state);
extern int
ImagingJpegUseJCSExtensions(void);
extern int ImagingJpegEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int
ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
#endif
#ifdef HAVE_OPENJPEG
extern int ImagingJpeg2KDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingJpeg2KDecodeCleanup(ImagingCodecState state);
extern int ImagingJpeg2KEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingJpeg2KEncodeCleanup(ImagingCodecState state);
extern int
ImagingJpeg2KDecode(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingJpeg2KDecodeCleanup(ImagingCodecState state);
extern int
ImagingJpeg2KEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int
ImagingJpeg2KEncodeCleanup(ImagingCodecState state);
#endif
#ifdef HAVE_LIBTIFF
extern int ImagingLibTiffDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingLibTiffEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int
ImagingLibTiffDecode(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
#endif
#ifdef HAVE_LIBMPEG
extern int ImagingMpegDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int
ImagingMpegDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
#endif
extern int ImagingMspDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingPcdDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingPcxDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingPcxEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingRawDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingRawEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingSunRleDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingTgaRleEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingXbmDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingXbmEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int
ImagingMspDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingPackbitsDecode(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingPcxEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int
ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingRawEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int
ImagingSgiRleDecode(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingSunRleDecode(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingTgaRleDecode(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingTgaRleEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int
ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingXbmEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
#ifdef HAVE_LIBZ
extern int ImagingZipDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, Py_ssize_t bytes);
extern int ImagingZipDecodeCleanup(ImagingCodecState state);
extern int ImagingZipEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingZipEncodeCleanup(ImagingCodecState state);
extern int
ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes);
extern int
ImagingZipDecodeCleanup(ImagingCodecState state);
extern int
ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
extern int
ImagingZipEncodeCleanup(ImagingCodecState state);
#endif
typedef void (*ImagingShuffler)(UINT8 *out, const UINT8 *in, int pixels);
/* Public shufflers */
extern void ImagingPackBGR(UINT8* out, const UINT8* in, int pixels);
extern void ImagingUnpackYCC(UINT8* out, const UINT8* in, int pixels);
extern void ImagingUnpackYCCA(UINT8* out, const UINT8* in, int pixels);
extern void
ImagingPackBGR(UINT8 *out, const UINT8 *in, int pixels);
extern void
ImagingUnpackYCC(UINT8 *out, const UINT8 *in, int pixels);
extern void
ImagingUnpackYCCA(UINT8 *out, const UINT8 *in, int pixels);
extern void ImagingConvertRGB2YCbCr(UINT8* out, const UINT8* in, int pixels);
extern void ImagingConvertYCbCr2RGB(UINT8* out, const UINT8* in, int pixels);
extern void
ImagingConvertRGB2YCbCr(UINT8 *out, const UINT8 *in, int pixels);
extern void
ImagingConvertYCbCr2RGB(UINT8 *out, const UINT8 *in, int pixels);
extern ImagingShuffler ImagingFindUnpacker(const char* mode,
const char* rawmode, int* bits_out);
extern ImagingShuffler ImagingFindPacker(const char* mode,
const char* rawmode, int* bits_out);
extern ImagingShuffler
ImagingFindUnpacker(const char *mode, const char *rawmode, int *bits_out);
extern ImagingShuffler
ImagingFindPacker(const char *mode, const char *rawmode, int *bits_out);
struct ImagingCodecStateInstance {
int count;
@ -509,15 +667,15 @@ struct ImagingCodecStateInstance {
PyObject *fd;
};
/* Codec read/write python fd */
extern Py_ssize_t _imaging_read_pyFd(PyObject *fd, char* dest, Py_ssize_t bytes);
extern Py_ssize_t _imaging_write_pyFd(PyObject *fd, char* src, Py_ssize_t bytes);
extern int _imaging_seek_pyFd(PyObject *fd, Py_ssize_t offset, int whence);
extern Py_ssize_t _imaging_tell_pyFd(PyObject *fd);
extern Py_ssize_t
_imaging_read_pyFd(PyObject *fd, char *dest, Py_ssize_t bytes);
extern Py_ssize_t
_imaging_write_pyFd(PyObject *fd, char *src, Py_ssize_t bytes);
extern int
_imaging_seek_pyFd(PyObject *fd, Py_ssize_t offset, int whence);
extern Py_ssize_t
_imaging_tell_pyFd(PyObject *fd);
/* Errcodes */
#define IMAGING_CODEC_END 1
@ -527,12 +685,9 @@ extern Py_ssize_t _imaging_tell_pyFd(PyObject *fd);
#define IMAGING_CODEC_CONFIG -8
#define IMAGING_CODEC_MEMORY -9
#include "ImagingUtils.h"
extern UINT8 *clip8_lookups;
#if defined(__cplusplus)
}
#endif

23
src/libImaging/ImagingUtils.h
View File

@ -1,34 +1,29 @@
#ifdef WORDS_BIGENDIAN
#define MAKE_UINT32(u0, u1, u2, u3) ((UINT32)(u3) | ((UINT32)(u2)<<8) | ((UINT32)(u1)<<16) | ((UINT32)(u0)<<24))
#define MAKE_UINT32(u0, u1, u2, u3) \
((UINT32)(u3) | ((UINT32)(u2) << 8) | ((UINT32)(u1) << 16) | ((UINT32)(u0) << 24))
#define MASK_UINT32_CHANNEL_0 0xff000000
#define MASK_UINT32_CHANNEL_1 0x00ff0000
#define MASK_UINT32_CHANNEL_2 0x0000ff00
#define MASK_UINT32_CHANNEL_3 0x000000ff
#else
#define MAKE_UINT32(u0, u1, u2, u3) ((UINT32)(u0) | ((UINT32)(u1)<<8) | ((UINT32)(u2)<<16) | ((UINT32)(u3)<<24))
#define MAKE_UINT32(u0, u1, u2, u3) \
((UINT32)(u0) | ((UINT32)(u1) << 8) | ((UINT32)(u2) << 16) | ((UINT32)(u3) << 24))
#define MASK_UINT32_CHANNEL_0 0x000000ff
#define MASK_UINT32_CHANNEL_1 0x0000ff00
#define MASK_UINT32_CHANNEL_2 0x00ff0000
#define MASK_UINT32_CHANNEL_3 0xff000000
#endif
#define SHIFTFORDIV255(a)\
((((a) >> 8) + a) >> 8)
#define SHIFTFORDIV255(a) ((((a) >> 8) + a) >> 8)
/* like (a * b + 127) / 255), but much faster on most platforms */
#define MULDIV255(a, b, tmp)\
(tmp = (a) * (b) + 128, SHIFTFORDIV255(tmp))
#define MULDIV255(a, b, tmp) (tmp = (a) * (b) + 128, SHIFTFORDIV255(tmp))
#define DIV255(a, tmp)\
(tmp = (a) + 128, SHIFTFORDIV255(tmp))
#define DIV255(a, tmp) (tmp = (a) + 128, SHIFTFORDIV255(tmp))
#define BLEND(mask, in1, in2, tmp1)\
DIV255(in1 * (255 - mask) + in2 * mask, tmp1)
#define PREBLEND(mask, in1, in2, tmp1)\
(MULDIV255(in1, (255 - mask), tmp1) + in2)
#define BLEND(mask, in1, in2, tmp1) DIV255(in1 *(255 - mask) + in2 * mask, tmp1)
#define PREBLEND(mask, in1, in2, tmp1) (MULDIV255(in1, (255 - mask), tmp1) + in2)
#define CLIP8(v) ((v) <= 0 ? 0 : (v) < 256 ? (v) : 255)

8
src/libImaging/Jpeg.h
View File

@ -12,13 +12,11 @@
#include <setjmp.h>
typedef struct {
struct jpeg_error_mgr pub; /* "public" fields */
jmp_buf setjmp_buffer; /* for return to caller */
} JPEGERROR;
/* -------------------------------------------------------------------- */
/* Decoder */
@ -28,7 +26,6 @@ typedef struct {
} JPEGSOURCE;
typedef struct {
/* CONFIGURATION */
/* Jpeg file mode (empty if not known) */
@ -54,7 +51,6 @@ typedef struct {
} JPEGSTATE;
/* -------------------------------------------------------------------- */
/* Encoder */
@ -64,7 +60,6 @@ typedef struct {
} JPEGDESTINATION;
typedef struct {
/* CONFIGURATION */
/* Quality (0-100, -1 means default) */
@ -98,7 +93,8 @@ typedef struct {
int qtablesLen;
/* Extra data (to be injected after header) */
char* extra; int extra_size;
char *extra;
int extra_size;
/* PRIVATE CONTEXT (set by encoder) */

1
src/libImaging/Jpeg2K.h
View File

@ -91,7 +91,6 @@ typedef struct {
/* PRIVATE CONTEXT (set by decoder) */
const char *error_msg;
} JPEG2KENCODESTATE;
/*

228
src/libImaging/Jpeg2KDecode.c
View File

@ -32,8 +32,7 @@ typedef struct {
/* -------------------------------------------------------------------- */
static void
j2k_error(const char *msg, void *client_data)
{
j2k_error(const char *msg, void *client_data) {
JPEG2KDECODESTATE *state = (JPEG2KDECODESTATE *)client_data;
free((void *)state->error_msg);
state->error_msg = strdup(msg);
@ -44,8 +43,7 @@ j2k_error(const char *msg, void *client_data)
/* -------------------------------------------------------------------- */
static OPJ_SIZE_T
j2k_read(void *p_buffer, OPJ_SIZE_T p_nb_bytes, void *p_user_data)
{
j2k_read(void *p_buffer, OPJ_SIZE_T p_nb_bytes, void *p_user_data) {
ImagingCodecState state = (ImagingCodecState)p_user_data;
size_t len = _imaging_read_pyFd(state->fd, p_buffer, p_nb_bytes);
@ -54,8 +52,7 @@ j2k_read(void *p_buffer, OPJ_SIZE_T p_nb_bytes, void *p_user_data)
}
static OPJ_OFF_T
j2k_skip(OPJ_OFF_T p_nb_bytes, void *p_user_data)
{
j2k_skip(OPJ_OFF_T p_nb_bytes, void *p_user_data) {
off_t pos;
ImagingCodecState state = (ImagingCodecState)p_user_data;
@ -69,10 +66,8 @@ j2k_skip(OPJ_OFF_T p_nb_bytes, void *p_user_data)
/* Unpackers */
/* -------------------------------------------------------------------- */
typedef void (*j2k_unpacker_t)(opj_image_t *in,
const JPEG2KTILEINFO *tileInfo,
const UINT8 *data,
Imaging im);
typedef void (*j2k_unpacker_t)(
opj_image_t *in, const JPEG2KTILEINFO *tileInfo, const UINT8 *data, Imaging im);
struct j2k_decode_unpacker {
const char *mode;
@ -81,9 +76,8 @@ struct j2k_decode_unpacker {
j2k_unpacker_t unpacker;
};
static inline
unsigned j2ku_shift(unsigned x, int n)
{
static inline unsigned
j2ku_shift(unsigned x, int n) {
if (n < 0) {
return x >> -n;
} else {
@ -92,9 +86,11 @@ unsigned j2ku_shift(unsigned x, int n)
}
static void
j2ku_gray_l(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_gray_l(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -145,11 +141,12 @@ j2ku_gray_l(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
}
}
static void
j2ku_gray_i(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_gray_i(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -199,11 +196,12 @@ j2ku_gray_i(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
}
}
static void
j2ku_gray_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_gray_rgb(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -263,9 +261,11 @@ j2ku_gray_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
}
static void
j2ku_graya_la(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_graya_la(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -304,15 +304,31 @@ j2ku_graya_la(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
UINT32 word = 0, aword = 0, byte;
switch (csiz) {
case 1: word = *data++; break;
case 2: word = *(const UINT16 *)data; data += 2; break;
case 4: word = *(const UINT32 *)data; data += 4; break;
case 1:
word = *data++;
break;
case 2:
word = *(const UINT16 *)data;
data += 2;
break;
case 4:
word = *(const UINT32 *)data;
data += 4;
break;
}
switch (acsiz) {
case 1: aword = *adata++; break;
case 2: aword = *(const UINT16 *)adata; adata += 2; break;
case 4: aword = *(const UINT32 *)adata; adata += 4; break;
case 1:
aword = *adata++;
break;
case 2:
aword = *(const UINT16 *)adata;
adata += 2;
break;
case 4:
aword = *(const UINT32 *)adata;
adata += 4;
break;
}
byte = j2ku_shift(offset + word, shift);
@ -324,9 +340,11 @@ j2ku_graya_la(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
}
static void
j2ku_srgb_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_srgb_rgb(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -365,9 +383,17 @@ j2ku_srgb_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
UINT32 word = 0;
switch (csiz[n]) {
case 1: word = *data[n]++; break;
case 2: word = *(const UINT16 *)data[n]; data[n] += 2; break;
case 4: word = *(const UINT32 *)data[n]; data[n] += 4; break;
case 1:
word = *data[n]++;
break;
case 2:
word = *(const UINT16 *)data[n];
data[n] += 2;
break;
case 4:
word = *(const UINT32 *)data[n];
data[n] += 4;
break;
}
row[n] = j2ku_shift(offsets[n] + word, shifts[n]);
@ -379,9 +405,11 @@ j2ku_srgb_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
}
static void
j2ku_sycc_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_sycc_rgb(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -421,9 +449,17 @@ j2ku_sycc_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
UINT32 word = 0;
switch (csiz[n]) {
case 1: word = *data[n]++; break;
case 2: word = *(const UINT16 *)data[n]; data[n] += 2; break;
case 4: word = *(const UINT32 *)data[n]; data[n] += 4; break;
case 1:
word = *data[n]++;
break;
case 2:
word = *(const UINT16 *)data[n];
data[n] += 2;
break;
case 4:
word = *(const UINT32 *)data[n];
data[n] += 4;
break;
}
row[n] = j2ku_shift(offsets[n] + word, shifts[n]);
@ -437,9 +473,11 @@ j2ku_sycc_rgb(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
}
static void
j2ku_srgba_rgba(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_srgba_rgba(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -478,9 +516,17 @@ j2ku_srgba_rgba(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
UINT32 word = 0;
switch (csiz[n]) {
case 1: word = *data[n]++; break;
case 2: word = *(const UINT16 *)data[n]; data[n] += 2; break;
case 4: word = *(const UINT32 *)data[n]; data[n] += 4; break;
case 1:
word = *data[n]++;
break;
case 2:
word = *(const UINT16 *)data[n];
data[n] += 2;
break;
case 4:
word = *(const UINT32 *)data[n];
data[n] += 4;
break;
}
row[n] = j2ku_shift(offsets[n] + word, shifts[n]);
@ -491,9 +537,11 @@ j2ku_srgba_rgba(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
}
static void
j2ku_sycca_rgba(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata, Imaging im)
{
j2ku_sycca_rgba(
opj_image_t *in,
const JPEG2KTILEINFO *tileinfo,
const UINT8 *tiledata,
Imaging im) {
unsigned x0 = tileinfo->x0 - in->x0, y0 = tileinfo->y0 - in->y0;
unsigned w = tileinfo->x1 - tileinfo->x0;
unsigned h = tileinfo->y1 - tileinfo->y0;
@ -533,9 +581,17 @@ j2ku_sycca_rgba(opj_image_t *in, const JPEG2KTILEINFO *tileinfo,
UINT32 word = 0;
switch (csiz[n]) {
case 1: word = *data[n]++; break;
case 2: word = *(const UINT16 *)data[n]; data[n] += 2; break;
case 4: word = *(const UINT32 *)data[n]; data[n] += 4; break;
case 1:
word = *data[n]++;
break;
case 2:
word = *(const UINT16 *)data[n];
data[n] += 2;
break;
case 4:
word = *(const UINT32 *)data[n];
data[n] += 4;
break;
}
row[n] = j2ku_shift(offsets[n] + word, shifts[n]);
@ -578,8 +634,7 @@ enum {
};
static int
j2k_decode_entry(Imaging im, ImagingCodecState state)
{
j2k_decode_entry(Imaging im, ImagingCodecState state) {
JPEG2KDECODESTATE *context = (JPEG2KDECODESTATE *)state->context;
opj_stream_t *stream = NULL;
opj_image_t *image = NULL;
@ -591,7 +646,6 @@ j2k_decode_entry(Imaging im, ImagingCodecState state)
unsigned n, tile_height, tile_width;
int components;
stream = opj_stream_create(BUFFER_SIZE, OPJ_TRUE);
if (!stream) {
@ -645,8 +699,8 @@ j2k_decode_entry(Imaging im, ImagingCodecState state)
}
/* Check that this image is something we can handle */
if (image->numcomps < 1 || image->numcomps > 4
|| image->color_space == OPJ_CLRSPC_UNKNOWN) {
if (image->numcomps < 1 || image->numcomps > 4 ||
image->color_space == OPJ_CLRSPC_UNKNOWN) {
state->errcode = IMAGING_CODEC_BROKEN;
state->state = J2K_STATE_FAILED;
goto quick_exit;
@ -686,15 +740,21 @@ j2k_decode_entry(Imaging im, ImagingCodecState state)
if (color_space == OPJ_CLRSPC_UNSPECIFIED) {
switch (image->numcomps) {
case 1: case 2: color_space = OPJ_CLRSPC_GRAY; break;
case 3: case 4: color_space = OPJ_CLRSPC_SRGB; break;
case 1:
case 2:
color_space = OPJ_CLRSPC_GRAY;
break;
case 3:
case 4:
color_space = OPJ_CLRSPC_SRGB;
break;
}
}
for (n = 0; n < sizeof(j2k_unpackers) / sizeof(j2k_unpackers[0]); ++n) {
if (color_space == j2k_unpackers[n].color_space
&& image->numcomps == j2k_unpackers[n].components
&& strcmp (im->mode, j2k_unpackers[n].mode) == 0) {
if (color_space == j2k_unpackers[n].color_space &&
image->numcomps == j2k_unpackers[n].components &&
strcmp(im->mode, j2k_unpackers[n].mode) == 0) {
unpack = j2k_unpackers[n].unpacker;
break;
}
@ -713,12 +773,15 @@ j2k_decode_entry(Imaging im, ImagingCodecState state)
OPJ_BOOL should_continue;
unsigned correction = (1 << params.cp_reduce) - 1;
if (!opj_read_tile_header(codec,
if (!opj_read_tile_header(
codec,
stream,
&tile_info.tile_index,
&tile_info.data_size,
&tile_info.x0, &tile_info.y0,
&tile_info.x1, &tile_info.y1,
&tile_info.x0,
&tile_info.y0,
&tile_info.x1,
&tile_info.y1,
&tile_info.nb_comps,
&should_continue)) {
state->errcode = IMAGING_CODEC_BROKEN;
@ -740,14 +803,12 @@ j2k_decode_entry(Imaging im, ImagingCodecState state)
/* Check the tile bounds; if the tile is outside the image area,
or if it has a negative width or height (i.e. the coordinates are
swapped), bail. */
if (tile_info.x0 >= tile_info.x1
|| tile_info.y0 >= tile_info.y1
|| tile_info.x0 < 0
|| tile_info.y0 < 0
|| (OPJ_UINT32)tile_info.x0 < image->x0
|| (OPJ_UINT32)tile_info.y0 < image->y0
|| (OPJ_INT32)(tile_info.x1 - image->x0) > im->xsize
|| (OPJ_INT32)(tile_info.y1 - image->y0) > im->ysize) {
if (tile_info.x0 >= tile_info.x1 || tile_info.y0 >= tile_info.y1 ||
tile_info.x0 < 0 || tile_info.y0 < 0 ||
(OPJ_UINT32)tile_info.x0 < image->x0 ||
(OPJ_UINT32)tile_info.y0 < image->y0 ||
(OPJ_INT32)(tile_info.x1 - image->x0) > im->xsize ||
(OPJ_INT32)(tile_info.y1 - image->y0) > im->ysize) {
state->errcode = IMAGING_CODEC_BROKEN;
state->state = J2K_STATE_FAILED;
goto quick_exit;
@ -787,8 +848,8 @@ j2k_decode_entry(Imaging im, ImagingCodecState state)
buffer_size = tile_info.data_size;
}
if (!opj_decode_tile_data(codec,
if (!opj_decode_tile_data(
codec,
tile_info.tile_index,
(OPJ_BYTE *)state->buffer,
tile_info.data_size,
@ -831,9 +892,7 @@ j2k_decode_entry(Imaging im, ImagingCodecState state)
}
int
ImagingJpeg2KDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingJpeg2KDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
if (bytes) {
state->errcode = IMAGING_CODEC_BROKEN;
state->state = J2K_STATE_FAILED;
@ -876,8 +935,7 @@ ImagingJpeg2KDecodeCleanup(ImagingCodecState state) {
}
const char *
ImagingJpeg2KVersion(void)
{
ImagingJpeg2KVersion(void) {
return opj_version();
}

100
src/libImaging/Jpeg2KEncode.c
View File

@ -29,16 +29,14 @@
/* -------------------------------------------------------------------- */
static void
j2k_error(const char *msg, void *client_data)
{
j2k_error(const char *msg, void *client_data) {
JPEG2KENCODESTATE *state = (JPEG2KENCODESTATE *)client_data;
free((void *)state->error_msg);
state->error_msg = strdup(msg);
}
static void
j2k_warn(const char *msg, void *client_data)
{
j2k_warn(const char *msg, void *client_data) {
// Null handler
}
@ -47,8 +45,7 @@ j2k_warn(const char *msg, void *client_data)
/* -------------------------------------------------------------------- */
static OPJ_SIZE_T
j2k_write(void *p_buffer, OPJ_SIZE_T p_nb_bytes, void *p_user_data)
{
j2k_write(void *p_buffer, OPJ_SIZE_T p_nb_bytes, void *p_user_data) {
ImagingCodecState state = (ImagingCodecState)p_user_data;
unsigned int result;
@ -57,10 +54,8 @@ j2k_write(void *p_buffer, OPJ_SIZE_T p_nb_bytes, void *p_user_data)
return result ? result : (OPJ_SIZE_T)-1;
}
static OPJ_OFF_T
j2k_skip(OPJ_OFF_T p_nb_bytes, void *p_user_data)
{
j2k_skip(OPJ_OFF_T p_nb_bytes, void *p_user_data) {
ImagingCodecState state = (ImagingCodecState)p_user_data;
char *buffer;
int result;
@ -79,8 +74,7 @@ j2k_skip(OPJ_OFF_T p_nb_bytes, void *p_user_data)
}
static OPJ_BOOL
j2k_seek(OPJ_OFF_T p_nb_bytes, void *p_user_data)
{
j2k_seek(OPJ_OFF_T p_nb_bytes, void *p_user_data) {
ImagingCodecState state = (ImagingCodecState)p_user_data;
off_t pos = 0;
@ -94,14 +88,11 @@ j2k_seek(OPJ_OFF_T p_nb_bytes, void *p_user_data)
/* Encoder */
/* -------------------------------------------------------------------- */
typedef void (*j2k_pack_tile_t)(Imaging im, UINT8 *buf,
unsigned x0, unsigned y0,
unsigned w, unsigned h);
typedef void (*j2k_pack_tile_t)(
Imaging im, UINT8 *buf, unsigned x0, unsigned y0, unsigned w, unsigned h);
static void
j2k_pack_l(Imaging im, UINT8 *buf,
unsigned x0, unsigned y0, unsigned w, unsigned h)
{
j2k_pack_l(Imaging im, UINT8 *buf, unsigned x0, unsigned y0, unsigned w, unsigned h) {
UINT8 *ptr = buf;
unsigned x, y;
for (y = 0; y < h; ++y) {
@ -113,9 +104,7 @@ j2k_pack_l(Imaging im, UINT8 *buf,
}
static void
j2k_pack_i16(Imaging im, UINT8 *buf,
unsigned x0, unsigned y0, unsigned w, unsigned h)
{
j2k_pack_i16(Imaging im, UINT8 *buf, unsigned x0, unsigned y0, unsigned w, unsigned h) {
UINT8 *ptr = buf;
unsigned x, y;
for (y = 0; y < h; ++y) {
@ -127,11 +116,8 @@ j2k_pack_i16(Imaging im, UINT8 *buf,
}
}
static void
j2k_pack_la(Imaging im, UINT8 *buf,
unsigned x0, unsigned y0, unsigned w, unsigned h)
{
j2k_pack_la(Imaging im, UINT8 *buf, unsigned x0, unsigned y0, unsigned w, unsigned h) {
UINT8 *ptr = buf;
UINT8 *ptra = buf + w * h;
unsigned x, y;
@ -146,9 +132,7 @@ j2k_pack_la(Imaging im, UINT8 *buf,
}
static void
j2k_pack_rgb(Imaging im, UINT8 *buf,
unsigned x0, unsigned y0, unsigned w, unsigned h)
{
j2k_pack_rgb(Imaging im, UINT8 *buf, unsigned x0, unsigned y0, unsigned w, unsigned h) {
UINT8 *pr = buf;
UINT8 *pg = pr + w * h;
UINT8 *pb = pg + w * h;
@ -165,9 +149,8 @@ j2k_pack_rgb(Imaging im, UINT8 *buf,
}
static void
j2k_pack_rgba(Imaging im, UINT8 *buf,
unsigned x0, unsigned y0, unsigned w, unsigned h)
{
j2k_pack_rgba(
Imaging im, UINT8 *buf, unsigned x0, unsigned y0, unsigned w, unsigned h) {
UINT8 *pr = buf;
UINT8 *pg = pr + w * h;
UINT8 *pb = pg + w * h;
@ -192,8 +175,7 @@ enum {
};
static void
j2k_set_cinema_params(Imaging im, int components, opj_cparameters_t *params)
{
j2k_set_cinema_params(Imaging im, int components, opj_cparameters_t *params) {
float rate;
int n;
@ -215,8 +197,9 @@ j2k_set_cinema_params(Imaging im, int components, opj_cparameters_t *params)
params->irreversible = 1;
if (params->cp_cinema == OPJ_CINEMA4K_24) {
float max_rate = ((float)(components * im->xsize * im->ysize * 8)
/ (CINEMA_24_CS_LENGTH * 8));
float max_rate =
((float)(components * im->xsize * im->ysize * 8) /
(CINEMA_24_CS_LENGTH * 8));
params->POC[0].tile = 1;
params->POC[0].resno0 = 0;
@ -239,8 +222,9 @@ j2k_set_cinema_params(Imaging im, int components, opj_cparameters_t *params)
if (params->tcp_rates[0] == 0) {
params->tcp_rates[n] = max_rate;
} else {
rate = ((float)(components * im->xsize * im->ysize * 8)
/ (params->tcp_rates[n] * 8));
rate =
((float)(components * im->xsize * im->ysize * 8) /
(params->tcp_rates[n] * 8));
if (rate > CINEMA_24_CS_LENGTH) {
params->tcp_rates[n] = max_rate;
}
@ -249,16 +233,18 @@ j2k_set_cinema_params(Imaging im, int components, opj_cparameters_t *params)
params->max_comp_size = COMP_24_CS_MAX_LENGTH;
} else {
float max_rate = ((float)(components * im->xsize * im->ysize * 8)
/ (CINEMA_48_CS_LENGTH * 8));
float max_rate =
((float)(components * im->xsize * im->ysize * 8) /
(CINEMA_48_CS_LENGTH * 8));
for (n = 0; n < params->tcp_numlayers; ++n) {
rate = 0;
if (params->tcp_rates[0] == 0) {
params->tcp_rates[n] = max_rate;
} else {
rate = ((float)(components * im->xsize * im->ysize * 8)
/ (params->tcp_rates[n] * 8));
rate =
((float)(components * im->xsize * im->ysize * 8) /
(params->tcp_rates[n] * 8));
if (rate > CINEMA_48_CS_LENGTH) {
params->tcp_rates[n] = max_rate;
}
@ -270,8 +256,7 @@ j2k_set_cinema_params(Imaging im, int components, opj_cparameters_t *params)
}
static int
j2k_encode_entry(Imaging im, ImagingCodecState state)
{
j2k_encode_entry(Imaging im, ImagingCodecState state) {
JPEG2KENCODESTATE *context = (JPEG2KENCODESTATE *)state->context;
opj_stream_t *stream = NULL;
opj_image_t *image = NULL;
@ -400,7 +385,8 @@ j2k_encode_entry(Imaging im, ImagingCodecState state)
float *pq;
if (len > 0) {
if ((unsigned)len > sizeof(params.tcp_rates) / sizeof(params.tcp_rates[0])) {
if ((unsigned)len >
sizeof(params.tcp_rates) / sizeof(params.tcp_rates[0])) {
len = sizeof(params.tcp_rates) / sizeof(params.tcp_rates[0]);
}
@ -431,16 +417,16 @@ j2k_encode_entry(Imaging im, ImagingCodecState state)
params.numresolution = context->num_resolutions;
}
if (context->cblk_width >= 4 && context->cblk_width <= 1024
&& context->cblk_height >= 4 && context->cblk_height <= 1024
&& context->cblk_width * context->cblk_height <= 4096) {
if (context->cblk_width >= 4 && context->cblk_width <= 1024 &&
context->cblk_height >= 4 && context->cblk_height <= 1024 &&
context->cblk_width * context->cblk_height <= 4096) {
params.cblockw_init = context->cblk_width;
params.cblockh_init = context->cblk_height;
}
if (context->precinct_width >= 4 && context->precinct_height >= 4
&& context->precinct_width >= context->cblk_width
&& context->precinct_height > context->cblk_height) {
if (context->precinct_width >= 4 && context->precinct_height >= 4 &&
context->precinct_width >= context->cblk_width &&
context->precinct_height > context->cblk_height) {
params.prcw_init[0] = context->precinct_width;
params.prch_init[0] = context->precinct_height;
params.res_spec = 1;
@ -504,10 +490,10 @@ j2k_encode_entry(Imaging im, ImagingCodecState state)
}
/* Write each tile */
tiles_x = (im->xsize + (params.image_offset_x0 - params.cp_tx0)
+ tile_width - 1) / tile_width;
tiles_y = (im->ysize + (params.image_offset_y0 - params.cp_ty0)
+ tile_height - 1) / tile_height;
tiles_x = (im->xsize + (params.image_offset_x0 - params.cp_tx0) + tile_width - 1) /
tile_width;
tiles_y = (im->ysize + (params.image_offset_y0 - params.cp_ty0) + tile_height - 1) /
tile_height;
/* check for integer overflow for the malloc line, checking any expression
that may multiply either tile_width or tile_height */
@ -564,8 +550,7 @@ j2k_encode_entry(Imaging im, ImagingCodecState state)
data_size = pixw * pixh * components * prec / 8;
if (!opj_write_tile(codec, tile_ndx++, state->buffer,
data_size, stream)) {
if (!opj_write_tile(codec, tile_ndx++, state->buffer, data_size, stream)) {
state->errcode = IMAGING_CODEC_BROKEN;
state->state = J2K_STATE_FAILED;
goto quick_exit;
@ -598,14 +583,12 @@ j2k_encode_entry(Imaging im, ImagingCodecState state)
}
int
ImagingJpeg2KEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes)
{
ImagingJpeg2KEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
if (state->state == J2K_STATE_FAILED) {
return -1;
}
if (state->state == J2K_STATE_START) {
state->state = J2K_STATE_ENCODING;
return j2k_encode_entry(im, state);
@ -633,7 +616,6 @@ ImagingJpeg2KEncodeCleanup(ImagingCodecState state) {
context->error_msg = NULL;
return -1;
}

51
src/libImaging/JpegDecode.c
View File

@ -21,7 +21,6 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
#ifdef HAVE_LIBJPEG
@ -37,7 +36,6 @@
#include "Jpeg.h"
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
@ -50,8 +48,7 @@ char *libjpeg_turbo_version = NULL;
#endif
int
ImagingJpegUseJCSExtensions()
{
ImagingJpegUseJCSExtensions() {
int use_jcs_extensions = 0;
#ifdef JCS_EXTENSIONS
#if defined(LIBJPEG_TURBO_VERSION_NUMBER)
@ -72,21 +69,16 @@ ImagingJpegUseJCSExtensions()
/* -------------------------------------------------------------------- */
METHODDEF(void)
stub(j_decompress_ptr cinfo)
{
/* empty */
}
stub(j_decompress_ptr cinfo) { /* empty */ }
METHODDEF(boolean)
fill_input_buffer(j_decompress_ptr cinfo)
{
fill_input_buffer(j_decompress_ptr cinfo) {
/* Suspension */
return FALSE;
}
METHODDEF(void)
skip_input_data(j_decompress_ptr cinfo, long num_bytes)
{
skip_input_data(j_decompress_ptr cinfo, long num_bytes) {
JPEGSOURCE *source = (JPEGSOURCE *)cinfo->src;
if (num_bytes > (long)source->pub.bytes_in_buffer) {
@ -103,10 +95,8 @@ skip_input_data(j_decompress_ptr cinfo, long num_bytes)
}
}
GLOBAL(void)
jpeg_buffer_src(j_decompress_ptr cinfo, JPEGSOURCE* source)
{
jpeg_buffer_src(j_decompress_ptr cinfo, JPEGSOURCE *source) {
cinfo->src = (void *)source;
/* Prepare for suspending reader */
@ -120,32 +110,26 @@ jpeg_buffer_src(j_decompress_ptr cinfo, JPEGSOURCE* source)
source->skip = 0;
}
/* -------------------------------------------------------------------- */
/* Error handler */
/* -------------------------------------------------------------------- */
METHODDEF(void)
error(j_common_ptr cinfo)
{
error(j_common_ptr cinfo) {
JPEGERROR *error;
error = (JPEGERROR *)cinfo->err;
longjmp(error->setjmp_buffer, 1);
}
METHODDEF(void)
output(j_common_ptr cinfo)
{
/* nothing */
}
output(j_common_ptr cinfo) { /* nothing */ }
/* -------------------------------------------------------------------- */
/* Decoder */
/* -------------------------------------------------------------------- */
int
ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
JPEGSTATE *context = (JPEGSTATE *)state->context;
int ok;
@ -157,7 +141,6 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t by
}
if (!state->state) {
/* Setup decompression context */
context->cinfo.err = jpeg_std_error(&context->error.pub);
context->error.pub.error_exit = error;
@ -167,7 +150,6 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t by
/* Ready to decode */
state->state = 1;
}
/* Load the source buffer */
@ -182,12 +164,10 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t by
}
switch (state->state) {
case 1:
/* Read JPEG header, until we find an image body. */
do {
/* Note that we cannot return unless we have decoded
as much data as possible. */
ok = jpeg_read_header(&context->cinfo, FALSE);
@ -226,7 +206,8 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t by
context->cinfo.out_color_space = JCS_EXT_RGBX;
}
#endif
else if (strcmp(context->rawmode, "CMYK") == 0 ||
else if (
strcmp(context->rawmode, "CMYK") == 0 ||
strcmp(context->rawmode, "CMYK;I") == 0) {
context->cinfo.out_color_space = JCS_CMYK;
} else if (strcmp(context->rawmode, "YCbCr") == 0) {
@ -271,8 +252,10 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t by
if (ok != 1) {
break;
}
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->buffer,
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->buffer,
state->xsize);
state->y++;
}
@ -296,19 +279,18 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t by
jpeg_destroy_decompress(&context->cinfo);
/* if (jerr.pub.num_warnings) return BROKEN; */
return -1;
}
/* Return number of bytes consumed */
return context->source.pub.next_input_byte - buf;
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
int ImagingJpegDecodeCleanup(ImagingCodecState state){
int
ImagingJpegDecodeCleanup(ImagingCodecState state) {
/* called to free the decompression engine when the decode terminates
due to a corrupt or truncated image
*/
@ -320,4 +302,3 @@ int ImagingJpegDecodeCleanup(ImagingCodecState state){
}
#endif

68
src/libImaging/JpegEncode.c
View File

@ -19,7 +19,6 @@
* See the README file for details on usage and redistribution.
*/
#include "Imaging.h"
#ifdef HAVE_LIBJPEG
@ -40,21 +39,16 @@
/* -------------------------------------------------------------------- */
METHODDEF(void)
stub(j_compress_ptr cinfo)
{
/* empty */
}
stub(j_compress_ptr cinfo) { /* empty */ }
METHODDEF(boolean)
empty_output_buffer (j_compress_ptr cinfo)
{
empty_output_buffer(j_compress_ptr cinfo) {
/* Suspension */
return FALSE;
}
GLOBAL(void)
jpeg_buffer_dest(j_compress_ptr cinfo, JPEGDESTINATION* destination)
{
jpeg_buffer_dest(j_compress_ptr cinfo, JPEGDESTINATION *destination) {
cinfo->dest = (void *)destination;
destination->pub.init_destination = stub;
@ -62,28 +56,24 @@ jpeg_buffer_dest(j_compress_ptr cinfo, JPEGDESTINATION* destination)
destination->pub.term_destination = stub;
}
/* -------------------------------------------------------------------- */
/* Error handler */
/* -------------------------------------------------------------------- */
METHODDEF(void)
error(j_common_ptr cinfo)
{
error(j_common_ptr cinfo) {
JPEGERROR *error;
error = (JPEGERROR *)cinfo->err;
(*cinfo->err->output_message)(cinfo);
longjmp(error->setjmp_buffer, 1);
}
/* -------------------------------------------------------------------- */
/* Encoder */
/* -------------------------------------------------------------------- */
int
ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
JPEGENCODERSTATE *context = (JPEGENCODERSTATE *)state->context;
int ok;
@ -95,7 +85,6 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
if (!state->state) {
/* Setup compression context (very similar to the decoder) */
context->cinfo.err = jpeg_std_error(&context->error.pub);
context->error.pub.error_exit = error;
@ -106,7 +95,6 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
/* Ready to encode */
state->state = 1;
}
/* Load the destination buffer */
@ -114,7 +102,6 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
context->destination.pub.free_in_buffer = bytes;
switch (state->state) {
case 1:
context->cinfo.image_width = state->xsize;
@ -159,15 +146,20 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
quality = context->quality;
}
for (i = 0; i < context->qtablesLen; i++) {
jpeg_add_quant_table(&context->cinfo, i, &context->qtables[i * DCTSIZE2],
quality, FALSE);
jpeg_add_quant_table(
&context->cinfo,
i,
&context->qtables[i * DCTSIZE2],
quality,
FALSE);
context->cinfo.comp_info[i].quant_tbl_no = i;
last_q = i;
}
if (context->qtablesLen == 1) {
// jpeg_set_defaults created two qtables internally, but we only wanted one.
jpeg_add_quant_table(&context->cinfo, 1, &context->qtables[0],
quality, FALSE);
// jpeg_set_defaults created two qtables internally, but we only
// wanted one.
jpeg_add_quant_table(
&context->cinfo, 1, &context->qtables[0], quality, FALSE);
}
for (i = last_q; i < context->cinfo.num_components; i++) {
context->cinfo.comp_info[i].quant_tbl_no = last_q;
@ -177,8 +169,7 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
/* Set subsampling options */
switch (context->subsampling)
{
switch (context->subsampling) {
case 0: /* 1x1 1x1 1x1 (4:4:4) : None */
{
context->cinfo.comp_info[0].h_samp_factor = 1;
@ -209,8 +200,7 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
context->cinfo.comp_info[2].v_samp_factor = 1;
break;
}
default:
{
default: {
/* Use the lib's default */
break;
}
@ -253,8 +243,11 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
// add exif header
if (context->rawExifLen > 0) {
jpeg_write_marker(&context->cinfo, JPEG_APP0+1,
(unsigned char*)context->rawExif, context->rawExifLen);
jpeg_write_marker(
&context->cinfo,
JPEG_APP0 + 1,
(unsigned char *)context->rawExif,
context->rawExifLen);
}
state->state++;
@ -267,8 +260,10 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
if (n > context->destination.pub.free_in_buffer) {
n = context->destination.pub.free_in_buffer;
}
memcpy(context->destination.pub.next_output_byte,
context->extra + context->extra_offset, n);
memcpy(
context->destination.pub.next_output_byte,
context->extra + context->extra_offset,
n);
context->destination.pub.next_output_byte += n;
context->destination.pub.free_in_buffer -= n;
context->extra_offset += n;
@ -288,9 +283,11 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
ok = 1;
while (state->y < state->ysize) {
state->shuffle(state->buffer,
state->shuffle(
state->buffer,
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->xsize);
state->xoff * im->pixelsize,
state->xsize);
ok = jpeg_write_scanlines(&context->cinfo, &state->buffer, 1);
if (ok != 1) {
break;
@ -330,17 +327,14 @@ ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
/* if (jerr.pub.num_warnings) return BROKEN; */
state->errcode = IMAGING_CODEC_END;
break;
}
/* Return number of bytes in output buffer */
return context->destination.pub.next_output_byte - buf;
}
const char *
ImagingJpegVersion(void)
{
ImagingJpegVersion(void) {
static char version[20];
sprintf(version, "%d.%d", JPEG_LIB_VERSION / 10, JPEG_LIB_VERSION % 10);
return version;

11
src/libImaging/Matrix.c
View File

@ -13,16 +13,12 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#define CLIPF(v) ((v <= 0.0) ? 0 : (v >= 255.0F) ? 255 : (UINT8)v)
Imaging
ImagingConvertMatrix(Imaging im, const char *mode, float m[])
{
ImagingConvertMatrix(Imaging im, const char *mode, float m[]) {
Imaging imOut;
int x, y;
@ -32,7 +28,6 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[])
}
if (strcmp(mode, "L") == 0 && im->bands == 3) {
imOut = ImagingNewDirty("L", im->xsize, im->ysize);
if (!imOut) {
return NULL;
@ -50,7 +45,6 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[])
}
} else if (strlen(mode) == 3 && im->bands == 3) {
imOut = ImagingNewDirty(mode, im->xsize, im->ysize);
if (!imOut) {
return NULL;
@ -67,7 +61,8 @@ ImagingConvertMatrix(Imaging im, const char *mode, float m[])
out[0] = CLIPF(v0);
out[1] = CLIPF(v1);
out[2] = CLIPF(v2);
in += 4; out += 4;
in += 4;
out += 4;
}
}
} else {

6
src/libImaging/ModeFilter.c
View File

@ -16,8 +16,7 @@
#include "Imaging.h"
Imaging
ImagingModeFilter(Imaging im, int size)
{
ImagingModeFilter(Imaging im, int size) {
Imaging imOut;
int x, y, i;
int xx, yy;
@ -39,7 +38,6 @@ ImagingModeFilter(Imaging im, int size)
for (y = 0; y < imOut->ysize; y++) {
UINT8 *out = &IMAGING_PIXEL_L(imOut, 0, y);
for (x = 0; x < imOut->xsize; x++) {
/* calculate histogram over current area */
/* FIXME: brute force! to improve, update the histogram
@ -74,9 +72,7 @@ ImagingModeFilter(Imaging im, int size)
} else {
out[x] = IMAGING_PIXEL_L(im, x, y);
}
}
}
ImagingCopyPalette(imOut, im);

6
src/libImaging/Negative.c
View File

@ -16,13 +16,10 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
Imaging
ImagingNegative(Imaging im)
{
ImagingNegative(Imaging im) {
Imaging imOut;
int x, y;
@ -43,4 +40,3 @@ ImagingNegative(Imaging im)
return imOut;
}

5
src/libImaging/Offset.c
View File

@ -14,13 +14,10 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
Imaging
ImagingOffset(Imaging im, int xoffset, int yoffset)
{
ImagingOffset(Imaging im, int xoffset, int yoffset) {
int x, y;
Imaging imOut;

227
src/libImaging/Pack.c
View File

@ -25,7 +25,6 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#define R 0
@ -41,20 +40,28 @@
/* byte swapping macros */
#define C16N\
(out[0]=tmp[0], out[1]=tmp[1]);
#define C16S\
(out[1]=tmp[0], out[0]=tmp[1]);
#define C32N\
(out[0]=tmp[0], out[1]=tmp[1], out[2]=tmp[2], out[3]=tmp[3]);
#define C32S\
(out[3]=tmp[0], out[2]=tmp[1], out[1]=tmp[2], out[0]=tmp[3]);
#define C16N (out[0] = tmp[0], out[1] = tmp[1]);
#define C16S (out[1] = tmp[0], out[0] = tmp[1]);
#define C32N (out[0] = tmp[0], out[1] = tmp[1], out[2] = tmp[2], out[3] = tmp[3]);
#define C32S (out[3] = tmp[0], out[2] = tmp[1], out[1] = tmp[2], out[0] = tmp[3]);
#define C64N \
(out[0]=tmp[0], out[1]=tmp[1], out[2]=tmp[2], out[3]=tmp[3],\
out[4]=tmp[4], out[5]=tmp[5], out[6]=tmp[6], out[7]=tmp[7]);
(out[0] = tmp[0], \
out[1] = tmp[1], \
out[2] = tmp[2], \
out[3] = tmp[3], \
out[4] = tmp[4], \
out[5] = tmp[5], \
out[6] = tmp[6], \
out[7] = tmp[7]);
#define C64S \
(out[7]=tmp[0], out[6]=tmp[1], out[5]=tmp[2], out[4]=tmp[3],\
out[3]=tmp[4], out[2]=tmp[5], out[1]=tmp[6], out[0]=tmp[7]);
(out[7] = tmp[0], \
out[6] = tmp[1], \
out[5] = tmp[2], \
out[4] = tmp[3], \
out[3] = tmp[4], \
out[2] = tmp[5], \
out[1] = tmp[6], \
out[0] = tmp[7]);
#ifdef WORDS_BIGENDIAN
#define C16B C16N
@ -72,13 +79,12 @@
#define C64L C64N
#endif
static void
pack1(UINT8* out, const UINT8* in, int pixels)
{
pack1(UINT8 *out, const UINT8 *in, int pixels) {
int i, m, b;
/* bilevel (black is 0) */
b = 0; m = 128;
b = 0;
m = 128;
for (i = 0; i < pixels; i++) {
if (in[i] != 0) {
b |= m;
@ -86,7 +92,8 @@ pack1(UINT8* out, const UINT8* in, int pixels)
m >>= 1;
if (m == 0) {
*out++ = b;
b = 0; m = 128;
b = 0;
m = 128;
}
}
if (m != 128) {
@ -95,11 +102,11 @@ pack1(UINT8* out, const UINT8* in, int pixels)
}
static void
pack1I(UINT8* out, const UINT8* in, int pixels)
{
pack1I(UINT8 *out, const UINT8 *in, int pixels) {
int i, m, b;
/* bilevel (black is 1) */
b = 0; m = 128;
b = 0;
m = 128;
for (i = 0; i < pixels; i++) {
if (in[i] == 0) {
b |= m;
@ -107,7 +114,8 @@ pack1I(UINT8* out, const UINT8* in, int pixels)
m >>= 1;
if (m == 0) {
*out++ = b;
b = 0; m = 128;
b = 0;
m = 128;
}
}
if (m != 128) {
@ -116,11 +124,11 @@ pack1I(UINT8* out, const UINT8* in, int pixels)
}
static void
pack1R(UINT8* out, const UINT8* in, int pixels)
{
pack1R(UINT8 *out, const UINT8 *in, int pixels) {
int i, m, b;
/* bilevel, lsb first (black is 0) */
b = 0; m = 1;
b = 0;
m = 1;
for (i = 0; i < pixels; i++) {
if (in[i] != 0) {
b |= m;
@ -128,7 +136,8 @@ pack1R(UINT8* out, const UINT8* in, int pixels)
m <<= 1;
if (m == 256) {
*out++ = b;
b = 0; m = 1;
b = 0;
m = 1;
}
}
if (m != 1) {
@ -137,11 +146,11 @@ pack1R(UINT8* out, const UINT8* in, int pixels)
}
static void
pack1IR(UINT8* out, const UINT8* in, int pixels)
{
pack1IR(UINT8 *out, const UINT8 *in, int pixels) {
int i, m, b;
/* bilevel, lsb first (black is 1) */
b = 0; m = 1;
b = 0;
m = 1;
for (i = 0; i < pixels; i++) {
if (in[i] == 0) {
b |= m;
@ -149,7 +158,8 @@ pack1IR(UINT8* out, const UINT8* in, int pixels)
m <<= 1;
if (m == 256) {
*out++ = b;
b = 0; m = 1;
b = 0;
m = 1;
}
}
if (m != 1) {
@ -158,8 +168,7 @@ pack1IR(UINT8* out, const UINT8* in, int pixels)
}
static void
pack1L(UINT8* out, const UINT8* in, int pixels)
{
pack1L(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* bilevel, stored as bytes */
for (i = 0; i < pixels; i++) {
@ -168,12 +177,11 @@ pack1L(UINT8* out, const UINT8* in, int pixels)
}
static void
packP4(UINT8* out, const UINT8* in, int pixels)
{
packP4(UINT8 *out, const UINT8 *in, int pixels) {
while (pixels >= 2) {
*out++ = (in[0] << 4) |
(in[1] & 15);
in += 2; pixels -= 2;
*out++ = (in[0] << 4) | (in[1] & 15);
in += 2;
pixels -= 2;
}
if (pixels) {
@ -182,25 +190,19 @@ packP4(UINT8* out, const UINT8* in, int pixels)
}
static void
packP2(UINT8* out, const UINT8* in, int pixels)
{
packP2(UINT8 *out, const UINT8 *in, int pixels) {
while (pixels >= 4) {
*out++ = (in[0] << 6) |
((in[1] & 3) << 4) |
((in[2] & 3) << 2) |
(in[3] & 3);
in += 4; pixels -= 4;
*out++ = (in[0] << 6) | ((in[1] & 3) << 4) | ((in[2] & 3) << 2) | (in[3] & 3);
in += 4;
pixels -= 4;
}
switch (pixels) {
case 3:
out[0] = (in[0] << 6) |
((in[1] & 3) << 4) |
((in[2] & 3) << 2);
out[0] = (in[0] << 6) | ((in[1] & 3) << 4) | ((in[2] & 3) << 2);
break;
case 2:
out[0] = (in[0] << 6) |
((in[1] & 3) << 4);
out[0] = (in[0] << 6) | ((in[1] & 3) << 4);
break;
case 1:
out[0] = (in[0] << 6);
@ -208,8 +210,7 @@ packP2(UINT8* out, const UINT8* in, int pixels)
}
static void
packL16(UINT8* out, const UINT8* in, int pixels)
{
packL16(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* L -> L;16, e.g: \xff77 -> \x00\xff\x00\x77 */
for (i = 0; i < pixels; i++) {
@ -220,8 +221,7 @@ packL16(UINT8* out, const UINT8* in, int pixels)
}
static void
packL16B(UINT8* out, const UINT8* in, int pixels)
{
packL16B(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* L -> L;16B, e.g: \xff77 -> \xff\x00\x77\x00 */
for (i = 0; i < pixels; i++) {
@ -231,22 +231,20 @@ packL16B(UINT8* out, const UINT8* in, int pixels)
}
}
static void
packLA(UINT8* out, const UINT8* in, int pixels)
{
packLA(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* LA, pixel interleaved */
for (i = 0; i < pixels; i++) {
out[0] = in[R];
out[1] = in[A];
out += 2; in += 4;
out += 2;
in += 4;
}
}
static void
packLAL(UINT8* out, const UINT8* in, int pixels)
{
packLAL(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* LA, line interleaved */
for (i = 0; i < pixels; i++) {
@ -257,8 +255,7 @@ packLAL(UINT8* out, const UINT8* in, int pixels)
}
void
ImagingPackRGB(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackRGB(UINT8 *out, const UINT8 *in, int pixels) {
int i = 0;
/* RGB triplets */
#ifdef __sparc
@ -267,7 +264,8 @@ ImagingPackRGB(UINT8* out, const UINT8* in, int pixels)
out[0] = in[R];
out[1] = in[G];
out[2] = in[B];
out += 3; in += 4;
out += 3;
in += 4;
}
#else
for (; i < pixels - 1; i++) {
@ -284,8 +282,7 @@ ImagingPackRGB(UINT8* out, const UINT8* in, int pixels)
}
void
ImagingPackXRGB(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackXRGB(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* XRGB, triplets with left padding */
for (i = 0; i < pixels; i++) {
@ -293,26 +290,26 @@ ImagingPackXRGB(UINT8* out, const UINT8* in, int pixels)
out[1] = in[R];
out[2] = in[G];
out[3] = in[B];
out += 4; in += 4;
out += 4;
in += 4;
}
}
void
ImagingPackBGR(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackBGR(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* RGB, reversed bytes */
for (i = 0; i < pixels; i++) {
out[0] = in[B];
out[1] = in[G];
out[2] = in[R];
out += 3; in += 4;
out += 3;
in += 4;
}
}
void
ImagingPackBGRX(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackBGRX(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* BGRX, reversed bytes with right padding */
for (i = 0; i < pixels; i++) {
@ -320,13 +317,13 @@ ImagingPackBGRX(UINT8* out, const UINT8* in, int pixels)
out[1] = in[G];
out[2] = in[R];
out[3] = 0;
out += 4; in += 4;
out += 4;
in += 4;
}
}
void
ImagingPackXBGR(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackXBGR(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* XBGR, reversed bytes with left padding */
for (i = 0; i < pixels; i++) {
@ -334,13 +331,13 @@ ImagingPackXBGR(UINT8* out, const UINT8* in, int pixels)
out[1] = in[B];
out[2] = in[G];
out[3] = in[R];
out += 4; in += 4;
out += 4;
in += 4;
}
}
void
ImagingPackBGRA(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackBGRA(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* BGRX, reversed bytes with right padding */
for (i = 0; i < pixels; i++) {
@ -348,13 +345,13 @@ ImagingPackBGRA(UINT8* out, const UINT8* in, int pixels)
out[1] = in[G];
out[2] = in[R];
out[3] = in[A];
out += 4; in += 4;
out += 4;
in += 4;
}
}
void
ImagingPackABGR(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackABGR(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* XBGR, reversed bytes with left padding */
for (i = 0; i < pixels; i++) {
@ -362,13 +359,13 @@ ImagingPackABGR(UINT8* out, const UINT8* in, int pixels)
out[1] = in[B];
out[2] = in[G];
out[3] = in[R];
out += 4; in += 4;
out += 4;
in += 4;
}
}
void
ImagingPackBGRa(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackBGRa(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* BGRa, reversed bytes with premultiplied alpha */
for (i = 0; i < pixels; i++) {
@ -377,13 +374,13 @@ ImagingPackBGRa(UINT8* out, const UINT8* in, int pixels)
out[0] = MULDIV255(in[B], alpha, tmp);
out[1] = MULDIV255(in[G], alpha, tmp);
out[2] = MULDIV255(in[R], alpha, tmp);
out += 4; in += 4;
out += 4;
in += 4;
}
}
static void
packRGBL(UINT8* out, const UINT8* in, int pixels)
{
packRGBL(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* RGB, line interleaved */
for (i = 0; i < pixels; i++) {
@ -395,8 +392,7 @@ packRGBL(UINT8* out, const UINT8* in, int pixels)
}
static void
packRGBXL(UINT8* out, const UINT8* in, int pixels)
{
packRGBXL(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* RGBX, line interleaved */
for (i = 0; i < pixels; i++) {
@ -409,8 +405,7 @@ packRGBXL(UINT8* out, const UINT8* in, int pixels)
}
static void
packI16B(UINT8* out, const UINT8* in_, int pixels)
{
packI16B(UINT8 *out, const UINT8 *in_, int pixels) {
int i;
UINT16 tmp_;
UINT8 *tmp = (UINT8 *)&tmp_;
@ -425,7 +420,8 @@ packI16B(UINT8* out, const UINT8* in_, int pixels)
tmp_ = in;
}
C16B;
out += 2; in_ += sizeof(in);
out += 2;
in_ += sizeof(in);
}
}
@ -435,9 +431,9 @@ packI16N_I16B(UINT8* out, const UINT8* in, int pixels){
UINT8 *tmp = (UINT8 *)in;
for (i = 0; i < pixels; i++) {
C16B;
out += 2; tmp += 2;
out += 2;
tmp += 2;
}
}
static void
packI16N_I16(UINT8 *out, const UINT8 *in, int pixels) {
@ -445,66 +441,61 @@ packI16N_I16(UINT8* out, const UINT8* in, int pixels){
UINT8 *tmp = (UINT8 *)in;
for (i = 0; i < pixels; i++) {
C16L;
out += 2; tmp += 2;
out += 2;
tmp += 2;
}
}
static void
packI32S(UINT8* out, const UINT8* in, int pixels)
{
packI32S(UINT8 *out, const UINT8 *in, int pixels) {
int i;
UINT8 *tmp = (UINT8 *)in;
for (i = 0; i < pixels; i++) {
C32L;
out += 4; tmp += 4;
out += 4;
tmp += 4;
}
}
void
ImagingPackLAB(UINT8* out, const UINT8* in, int pixels)
{
ImagingPackLAB(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* LAB triplets */
for (i = 0; i < pixels; i++) {
out[0] = in[0];
out[1] = in[1] ^ 128; /* signed in outside world */
out[2] = in[2] ^ 128;
out += 3; in += 4;
out += 3;
in += 4;
}
}
static void
copy1(UINT8* out, const UINT8* in, int pixels)
{
copy1(UINT8 *out, const UINT8 *in, int pixels) {
/* L, P */
memcpy(out, in, pixels);
}
static void
copy2(UINT8* out, const UINT8* in, int pixels)
{
copy2(UINT8 *out, const UINT8 *in, int pixels) {
/* I;16, etc */
memcpy(out, in, pixels * 2);
}
static void
copy3(UINT8* out, const UINT8* in, int pixels)
{
copy3(UINT8 *out, const UINT8 *in, int pixels) {
/* BGR;24, etc */
memcpy(out, in, pixels * 3);
}
static void
copy4(UINT8* out, const UINT8* in, int pixels)
{
copy4(UINT8 *out, const UINT8 *in, int pixels) {
/* RGBA, CMYK quadruples */
memcpy(out, in, 4 * pixels);
}
static void
copy4I(UINT8* out, const UINT8* in, int pixels)
{
copy4I(UINT8 *out, const UINT8 *in, int pixels) {
/* RGBA, CMYK quadruples, inverted */
int i;
for (i = 0; i < pixels * 4; i++) {
@ -513,8 +504,7 @@ copy4I(UINT8* out, const UINT8* in, int pixels)
}
static void
band0(UINT8* out, const UINT8* in, int pixels)
{
band0(UINT8 *out, const UINT8 *in, int pixels) {
int i;
for (i = 0; i < pixels; i++, in += 4) {
out[i] = in[0];
@ -522,8 +512,7 @@ band0(UINT8* out, const UINT8* in, int pixels)
}
static void
band1(UINT8* out, const UINT8* in, int pixels)
{
band1(UINT8 *out, const UINT8 *in, int pixels) {
int i;
for (i = 0; i < pixels; i++, in += 4) {
out[i] = in[1];
@ -531,8 +520,7 @@ band1(UINT8* out, const UINT8* in, int pixels)
}
static void
band2(UINT8* out, const UINT8* in, int pixels)
{
band2(UINT8 *out, const UINT8 *in, int pixels) {
int i;
for (i = 0; i < pixels; i++, in += 4) {
out[i] = in[2];
@ -540,8 +528,7 @@ band2(UINT8* out, const UINT8* in, int pixels)
}
static void
band3(UINT8* out, const UINT8* in, int pixels)
{
band3(UINT8 *out, const UINT8 *in, int pixels) {
int i;
for (i = 0; i < pixels; i++, in += 4) {
out[i] = in[3];
@ -682,10 +669,8 @@ static struct {
{NULL} /* sentinel */
};
ImagingShuffler
ImagingFindPacker(const char* mode, const char* rawmode, int* bits_out)
{
ImagingFindPacker(const char *mode, const char *rawmode, int *bits_out) {
int i;
/* find a suitable pixel packer */

27
src/libImaging/PackDecode.c
View File

@ -13,13 +13,11 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
UINT8* buf, Py_ssize_t bytes)
{
ImagingPackbitsDecode(
Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
UINT8 n;
UINT8 *ptr;
int i;
@ -27,16 +25,15 @@ ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
ptr = buf;
for (;;) {
if (bytes < 1) {
return ptr - buf;
}
if (ptr[0] & 0x80) {
if (ptr[0] == 0x80) {
/* Nop */
ptr++; bytes--;
ptr++;
bytes--;
continue;
}
@ -53,10 +50,10 @@ ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
state->buffer[state->x++] = ptr[1];
}
ptr += 2; bytes -= 2;
ptr += 2;
bytes -= 2;
} else {
/* Literal */
n = ptr[0] + 2;
@ -72,15 +69,16 @@ ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
state->buffer[state->x++] = ptr[i];
}
ptr += n; bytes -= n;
ptr += n;
bytes -= n;
}
if (state->x >= state->bytes) {
/* Got a full line, unpack it */
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->buffer,
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->buffer,
state->xsize);
state->x = 0;
@ -90,6 +88,5 @@ ImagingPackbitsDecode(Imaging im, ImagingCodecState state,
return -1;
}
}
}
}

59
src/libImaging/Palette.c
View File

@ -16,15 +16,12 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include <math.h>
ImagingPalette
ImagingPaletteNew(const char* mode)
{
ImagingPaletteNew(const char *mode) {
/* Create a palette object */
int i;
@ -44,8 +41,7 @@ ImagingPaletteNew(const char* mode)
/* Initialize to ramp */
for (i = 0; i < 256; i++) {
palette->palette[i*4+0] =
palette->palette[i*4+1] =
palette->palette[i * 4 + 0] = palette->palette[i * 4 + 1] =
palette->palette[i * 4 + 2] = (UINT8)i;
palette->palette[i * 4 + 3] = 255; /* opaque */
}
@ -54,8 +50,7 @@ ImagingPaletteNew(const char* mode)
}
ImagingPalette
ImagingPaletteNewBrowser(void)
{
ImagingPaletteNewBrowser(void) {
/* Create a standard "browser" palette object */
int i, r, g, b;
@ -70,8 +65,7 @@ ImagingPaletteNewBrowser(void)
/* FIXME: Add 10-level windows palette here? */
for (i = 0; i < 10; i++) {
palette->palette[i*4+0] =
palette->palette[i*4+1] =
palette->palette[i * 4 + 0] = palette->palette[i * 4 + 1] =
palette->palette[i * 4 + 2] = 0;
}
@ -92,8 +86,7 @@ ImagingPaletteNewBrowser(void)
/* FIXME: add 30-level greyscale wedge here? */
for (; i < 256; i++) {
palette->palette[i*4+0] =
palette->palette[i*4+1] =
palette->palette[i * 4 + 0] = palette->palette[i * 4 + 1] =
palette->palette[i * 4 + 2] = 0;
}
@ -101,8 +94,7 @@ ImagingPaletteNewBrowser(void)
}
ImagingPalette
ImagingPaletteDuplicate(ImagingPalette palette)
{
ImagingPaletteDuplicate(ImagingPalette palette) {
/* Duplicate palette descriptor */
ImagingPalette new_palette;
@ -125,8 +117,7 @@ ImagingPaletteDuplicate(ImagingPalette palette)
}
void
ImagingPaletteDelete(ImagingPalette palette)
{
ImagingPaletteDelete(ImagingPalette palette) {
/* Destroy palette object */
if (palette) {
@ -137,7 +128,6 @@ ImagingPaletteDelete(ImagingPalette palette)
}
}
/* -------------------------------------------------------------------- */
/* Colour mapping */
/* -------------------------------------------------------------------- */
@ -174,8 +164,7 @@ ImagingPaletteDelete(ImagingPalette palette)
#define BOXVOLUME BOX *BOX *BOX
void
ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b)
{
ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b) {
int i, j;
unsigned int dmin[256], dmax;
int r0, g0, b0;
@ -187,9 +176,15 @@ ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b)
/* Get box boundaries for the given (r,g,b)-triplet. Each box
covers eight cache slots (32 colour values, that is). */
r0 = r & 0xe0; r1 = r0 + 0x1f; rc = (r0 + r1) / 2;
g0 = g & 0xe0; g1 = g0 + 0x1f; gc = (g0 + g1) / 2;
b0 = b & 0xe0; b1 = b0 + 0x1f; bc = (b0 + b1) / 2;
r0 = r & 0xe0;
r1 = r0 + 0x1f;
rc = (r0 + r1) / 2;
g0 = g & 0xe0;
g1 = g0 + 0x1f;
gc = (g0 + g1) / 2;
b0 = b & 0xe0;
b1 = b0 + 0x1f;
bc = (b0 + b1) / 2;
/* Step 1 -- Select relevant palette entries (after Heckbert) */
@ -199,7 +194,6 @@ ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b)
dmax = (unsigned int)~0;
for (i = 0; i < 256; i++) {
int r, g, b;
unsigned int tmin, tmax;
@ -220,7 +214,6 @@ ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b)
if (tmax < dmax) {
dmax = tmax; /* keep the smallest max distance only */
}
}
/* Step 2 -- Incrementally update cache slot (after Thomas) */
@ -234,9 +227,7 @@ ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b)
}
for (i = 0; i < 256; i++) {
if (dmin[i] <= dmax) {
int rd, gd, bd;
int ri, gi, bi;
int rx, gx, bx;
@ -253,9 +244,11 @@ ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b)
rx = ri;
for (r = j = 0; r < BOX; r++) {
gd = rd; gx = gi;
gd = rd;
gx = gi;
for (g = 0; g < BOX; g++) {
bd = gd; bx = bi;
bd = gd;
bx = bi;
for (b = 0; b < BOX; b++) {
if ((unsigned int)bd < d[j]) {
d[j] = bd;
@ -289,17 +282,14 @@ ImagingPaletteCacheUpdate(ImagingPalette palette, int r, int g, int b)
}
}
int
ImagingPaletteCachePrepare(ImagingPalette palette)
{
ImagingPaletteCachePrepare(ImagingPalette palette) {
/* Add a colour cache to a palette */
int i;
int entries = 64 * 64 * 64;
if (palette->cache == NULL) {
/* The cache is 512k. It might be a good idea to break it
up into a pointer array (e.g. an 8-bit image?) */
@ -314,16 +304,13 @@ ImagingPaletteCachePrepare(ImagingPalette palette)
for (i = 0; i < entries; i++) {
palette->cache[i] = 0x100;
}
}
return 0;
}
void
ImagingPaletteCacheDelete(ImagingPalette palette)
{
ImagingPaletteCacheDelete(ImagingPalette palette) {
/* Release the colour cache, if any */
if (palette && palette->cache) {

232
src/libImaging/Paste.c
View File

@ -23,11 +23,17 @@
#include "Imaging.h"
static inline void
paste(Imaging imOut, Imaging imIn, int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
paste(
Imaging imOut,
Imaging imIn,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* paste opaque region */
int y;
@ -43,16 +49,22 @@ paste(Imaging imOut, Imaging imIn, int dx, int dy, int sx, int sy,
}
static inline void
paste_mask_1(Imaging imOut, Imaging imIn, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
paste_mask_1(
Imaging imOut,
Imaging imIn,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* paste with mode "1" mask */
int x, y;
if (imOut->image8) {
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
UINT8 *in = imIn->image8[y + sy] + sx;
@ -66,7 +78,6 @@ paste_mask_1(Imaging imOut, Imaging imIn, Imaging imMask,
}
} else {
for (y = 0; y < ysize; y++) {
INT32 *out = imOut->image32[y + dy] + dx;
INT32 *in = imIn->image32[y + sy] + sx;
@ -82,17 +93,23 @@ paste_mask_1(Imaging imOut, Imaging imIn, Imaging imMask,
}
static inline void
paste_mask_L(Imaging imOut, Imaging imIn, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
paste_mask_L(
Imaging imOut,
Imaging imIn,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* paste with mode "L" matte */
int x, y;
unsigned int tmp1;
if (imOut->image8) {
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
UINT8 *in = imIn->image8[y + sy] + sx;
@ -104,7 +121,6 @@ paste_mask_L(Imaging imOut, Imaging imIn, Imaging imMask,
}
} else {
for (y = 0; y < ysize; y++) {
UINT8 *out = (UINT8 *)(imOut->image32[y + dy] + dx);
UINT8 *in = (UINT8 *)(imIn->image32[y + sy] + sx);
@ -115,24 +131,32 @@ paste_mask_L(Imaging imOut, Imaging imIn, Imaging imMask,
out[1] = BLEND(a, out[1], in[1], tmp1);
out[2] = BLEND(a, out[2], in[2], tmp1);
out[3] = BLEND(a, out[3], in[3], tmp1);
out += 4; in += 4; mask ++;
out += 4;
in += 4;
mask++;
}
}
}
}
static inline void
paste_mask_RGBA(Imaging imOut, Imaging imIn, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
paste_mask_RGBA(
Imaging imOut,
Imaging imIn,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* paste with mode "RGBA" matte */
int x, y;
unsigned int tmp1;
if (imOut->image8) {
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
UINT8 *in = imIn->image8[y + sy] + sx;
@ -144,7 +168,6 @@ paste_mask_RGBA(Imaging imOut, Imaging imIn, Imaging imMask,
}
} else {
for (y = 0; y < ysize; y++) {
UINT8 *out = (UINT8 *)(imOut->image32[y + dy] + dx);
UINT8 *in = (UINT8 *)(imIn->image32[y + sy] + sx);
@ -155,25 +178,32 @@ paste_mask_RGBA(Imaging imOut, Imaging imIn, Imaging imMask,
out[1] = BLEND(a, out[1], in[1], tmp1);
out[2] = BLEND(a, out[2], in[2], tmp1);
out[3] = BLEND(a, out[3], in[3], tmp1);
out += 4; in += 4; mask += 4;
out += 4;
in += 4;
mask += 4;
}
}
}
}
static inline void
paste_mask_RGBa(Imaging imOut, Imaging imIn, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
paste_mask_RGBa(
Imaging imOut,
Imaging imIn,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* paste with mode "RGBa" matte */
int x, y;
unsigned int tmp1;
if (imOut->image8) {
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
UINT8 *in = imIn->image8[y + sy] + sx;
@ -185,7 +215,6 @@ paste_mask_RGBa(Imaging imOut, Imaging imIn, Imaging imMask,
}
} else {
for (y = 0; y < ysize; y++) {
UINT8 *out = (UINT8 *)(imOut->image32[y + dy] + dx);
UINT8 *in = (UINT8 *)(imIn->image32[y + sy] + sx);
@ -196,16 +225,17 @@ paste_mask_RGBa(Imaging imOut, Imaging imIn, Imaging imMask,
out[1] = PREBLEND(a, out[1], in[1], tmp1);
out[2] = PREBLEND(a, out[2], in[2], tmp1);
out[3] = PREBLEND(a, out[3], in[3], tmp1);
out += 4; in += 4; mask += 4;
out += 4;
in += 4;
mask += 4;
}
}
}
}
int
ImagingPaste(Imaging imOut, Imaging imIn, Imaging imMask,
int dx0, int dy0, int dx1, int dy1)
{
ImagingPaste(
Imaging imOut, Imaging imIn, Imaging imMask, int dx0, int dy0, int dx1, int dy1) {
int xsize, ysize;
int pixelsize;
int sx0, sy0;
@ -221,8 +251,7 @@ ImagingPaste(Imaging imOut, Imaging imIn, Imaging imMask,
xsize = dx1 - dx0;
ysize = dy1 - dy0;
if (xsize != imIn->xsize || ysize != imIn->ysize ||
pixelsize != imIn->pixelsize) {
if (xsize != imIn->xsize || ysize != imIn->ysize || pixelsize != imIn->pixelsize) {
(void)ImagingError_Mismatch();
return -1;
}
@ -258,26 +287,24 @@ ImagingPaste(Imaging imOut, Imaging imIn, Imaging imMask,
} else if (strcmp(imMask->mode, "1") == 0) {
ImagingSectionEnter(&cookie);
paste_mask_1(imOut, imIn, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
paste_mask_1(imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else if (strcmp(imMask->mode, "L") == 0) {
ImagingSectionEnter(&cookie);
paste_mask_L(imOut, imIn, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
paste_mask_L(imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else if (strcmp(imMask->mode, "RGBA") == 0) {
ImagingSectionEnter(&cookie);
paste_mask_RGBA(imOut, imIn, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
paste_mask_RGBA(
imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else if (strcmp(imMask->mode, "RGBa") == 0) {
ImagingSectionEnter(&cookie);
paste_mask_RGBa(imOut, imIn, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
paste_mask_RGBa(
imOut, imIn, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else {
@ -289,9 +316,14 @@ ImagingPaste(Imaging imOut, Imaging imIn, Imaging imMask,
}
static inline void
fill(Imaging imOut, const void* ink_, int dx, int dy,
int xsize, int ysize, int pixelsize)
{
fill(
Imaging imOut,
const void *ink_,
int dx,
int dy,
int xsize,
int ysize,
int pixelsize) {
/* fill opaque region */
int x, y;
@ -302,7 +334,6 @@ fill(Imaging imOut, const void* ink_, int dx, int dy,
memcpy(&ink8, ink_, sizeof(ink8));
if (imOut->image8 || ink32 == 0L) {
dx *= pixelsize;
xsize *= pixelsize;
for (y = 0; y < ysize; y++) {
@ -310,22 +341,27 @@ fill(Imaging imOut, const void* ink_, int dx, int dy,
}
} else {
for (y = 0; y < ysize; y++) {
INT32 *out = imOut->image32[y + dy] + dx;
for (x = 0; x < xsize; x++) {
out[x] = ink32;
}
}
}
}
static inline void
fill_mask_1(Imaging imOut, const void* ink_, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
fill_mask_1(
Imaging imOut,
const void *ink_,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* fill with mode "1" mask */
int x, y;
@ -336,7 +372,6 @@ fill_mask_1(Imaging imOut, const void* ink_, Imaging imMask,
memcpy(&ink8, ink_, sizeof(ink8));
if (imOut->image8) {
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
UINT8 *mask = imMask->image8[y + sy] + sx;
@ -349,7 +384,6 @@ fill_mask_1(Imaging imOut, const void* ink_, Imaging imMask,
}
} else {
for (y = 0; y < ysize; y++) {
INT32 *out = imOut->image32[y + dy] + dx;
UINT8 *mask = imMask->image8[y + sy] + sx;
@ -364,17 +398,23 @@ fill_mask_1(Imaging imOut, const void* ink_, Imaging imMask,
}
static inline void
fill_mask_L(Imaging imOut, const UINT8* ink, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
fill_mask_L(
Imaging imOut,
const UINT8 *ink,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* fill with mode "L" matte */
int x, y, i;
unsigned int tmp1;
if (imOut->image8) {
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
UINT8 *mask = imMask->image8[y + sy] + sx;
@ -385,21 +425,20 @@ fill_mask_L(Imaging imOut, const UINT8* ink, Imaging imMask,
}
} else {
for (y = 0; y < ysize; y++) {
UINT8 *out = (UINT8 *)imOut->image[y + dy] + dx * pixelsize;
UINT8 *mask = (UINT8 *)imMask->image[y + sy] + sx;
for (x = 0; x < xsize; x++) {
for (i = 0; i < pixelsize; i++) {
UINT8 channel_mask = *mask;
if ((
strcmp(imOut->mode, "RGBa") == 0 ||
if ((strcmp(imOut->mode, "RGBa") == 0 ||
strcmp(imOut->mode, "RGBA") == 0 ||
strcmp(imOut->mode, "La") == 0 ||
strcmp(imOut->mode, "LA") == 0 ||
strcmp(imOut->mode, "PA") == 0
) && i != 3) {
channel_mask = 255 - (255 - channel_mask) * (1 - (255 - out[3]) / 255);
strcmp(imOut->mode, "PA") == 0) &&
i != 3) {
channel_mask =
255 - (255 - channel_mask) * (1 - (255 - out[3]) / 255);
}
out[i] = BLEND(channel_mask, out[i], ink[i], tmp1);
}
@ -411,17 +450,23 @@ fill_mask_L(Imaging imOut, const UINT8* ink, Imaging imMask,
}
static inline void
fill_mask_RGBA(Imaging imOut, const UINT8* ink, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
fill_mask_RGBA(
Imaging imOut,
const UINT8 *ink,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* fill with mode "RGBA" matte */
int x, y, i;
unsigned int tmp1;
if (imOut->image8) {
sx = sx * 4 + 3;
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
@ -433,7 +478,6 @@ fill_mask_RGBA(Imaging imOut, const UINT8* ink, Imaging imMask,
}
} else {
dx *= pixelsize;
sx = sx * 4 + 3;
for (y = 0; y < ysize; y++) {
@ -451,17 +495,23 @@ fill_mask_RGBA(Imaging imOut, const UINT8* ink, Imaging imMask,
}
static inline void
fill_mask_RGBa(Imaging imOut, const UINT8* ink, Imaging imMask,
int dx, int dy, int sx, int sy,
int xsize, int ysize, int pixelsize)
{
fill_mask_RGBa(
Imaging imOut,
const UINT8 *ink,
Imaging imMask,
int dx,
int dy,
int sx,
int sy,
int xsize,
int ysize,
int pixelsize) {
/* fill with mode "RGBa" matte */
int x, y, i;
unsigned int tmp1;
if (imOut->image8) {
sx = sx * 4 + 3;
for (y = 0; y < ysize; y++) {
UINT8 *out = imOut->image8[y + dy] + dx;
@ -473,7 +523,6 @@ fill_mask_RGBa(Imaging imOut, const UINT8* ink, Imaging imMask,
}
} else {
dx *= pixelsize;
sx = sx * 4 + 3;
for (y = 0; y < ysize; y++) {
@ -491,9 +540,14 @@ fill_mask_RGBa(Imaging imOut, const UINT8* ink, Imaging imMask,
}
int
ImagingFill2(Imaging imOut, const void* ink, Imaging imMask,
int dx0, int dy0, int dx1, int dy1)
{
ImagingFill2(
Imaging imOut,
const void *ink,
Imaging imMask,
int dx0,
int dy0,
int dx1,
int dy1) {
ImagingSectionCookie cookie;
int xsize, ysize;
int pixelsize;
@ -540,26 +594,22 @@ ImagingFill2(Imaging imOut, const void* ink, Imaging imMask,
} else if (strcmp(imMask->mode, "1") == 0) {
ImagingSectionEnter(&cookie);
fill_mask_1(imOut, ink, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
fill_mask_1(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else if (strcmp(imMask->mode, "L") == 0) {
ImagingSectionEnter(&cookie);
fill_mask_L(imOut, ink, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
fill_mask_L(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else if (strcmp(imMask->mode, "RGBA") == 0) {
ImagingSectionEnter(&cookie);
fill_mask_RGBA(imOut, ink, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
fill_mask_RGBA(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else if (strcmp(imMask->mode, "RGBa") == 0) {
ImagingSectionEnter(&cookie);
fill_mask_RGBa(imOut, ink, imMask, dx0, dy0, sx0, sy0,
xsize, ysize, pixelsize);
fill_mask_RGBa(imOut, ink, imMask, dx0, dy0, sx0, sy0, xsize, ysize, pixelsize);
ImagingSectionLeave(&cookie);
} else {

13
src/libImaging/PcdDecode.c
View File

@ -19,13 +19,10 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
int x;
int chunk;
UINT8 *out;
@ -36,7 +33,6 @@ ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
chunk = 3 * state->xsize;
for (;;) {
/* We need data for two full lines before we can do anything */
if (bytes < chunk) {
return ptr - buf;
@ -51,8 +47,7 @@ ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
out += 3;
}
state->shuffle((UINT8*) im->image[state->y],
state->buffer, state->xsize);
state->shuffle((UINT8 *)im->image[state->y], state->buffer, state->xsize);
if (++state->y >= state->ysize) {
return -1; /* This can hardly happen */
@ -67,8 +62,7 @@ ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
out += 3;
}
state->shuffle((UINT8*) im->image[state->y],
state->buffer, state->xsize);
state->shuffle((UINT8 *)im->image[state->y], state->buffer, state->xsize);
if (++state->y >= state->ysize) {
return -1;
@ -76,6 +70,5 @@ ImagingPcdDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
ptr += chunk;
bytes -= chunk;
}
}

24
src/libImaging/PcxDecode.c
View File

@ -13,12 +13,10 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
UINT8 n;
UINT8 *ptr;
@ -30,13 +28,11 @@ ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
ptr = buf;
for (;;) {
if (bytes < 1) {
return ptr - buf;
}
if ((*ptr & 0xC0) == 0xC0) {
/* Run */
if (bytes < 2) {
return ptr - buf;
@ -53,14 +49,14 @@ ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
n--;
}
ptr += 2; bytes -= 2;
ptr += 2;
bytes -= 2;
} else {
/* Literal */
state->buffer[state->x++] = ptr[0];
ptr++; bytes--;
ptr++;
bytes--;
}
if (state->x >= state->bytes) {
@ -69,14 +65,17 @@ ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
int stride = state->bytes / bands;
int i;
for (i = 1; i < bands; i++) { // note -- skipping first band
memmove(&state->buffer[i*state->xsize],
memmove(
&state->buffer[i * state->xsize],
&state->buffer[i * stride],
state->xsize);
}
}
/* Got a full line, unpack it */
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->buffer,
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->buffer,
state->xsize);
state->x = 0;
@ -86,6 +85,5 @@ ImagingPcxDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
return -1;
}
}
}
}

14
src/libImaging/PcxEncode.c
View File

@ -13,7 +13,6 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
enum { INIT, FETCH, ENCODE };
@ -22,8 +21,7 @@ enum { INIT, FETCH, ENCODE };
#define LAST ystep
int
ImagingPcxEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingPcxEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
UINT8 *ptr;
int this;
int bytes_per_line = 0;
@ -59,9 +57,7 @@ ImagingPcxEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
padding = stride - bytes_per_line;
for (;;) {
switch (state->state) {
case FETCH:
@ -71,9 +67,11 @@ ImagingPcxEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
return ptr - buf;
}
state->shuffle(state->buffer,
state->shuffle(
state->buffer,
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->xsize);
state->xoff * im->pixelsize,
state->xsize);
state->y += 1;
@ -100,7 +98,6 @@ ImagingPcxEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
the double loop
*/
while (state->x % bytes_per_line) {
if (state->count == 63) {
/* this run is full; flush it */
if (bytes < 2) {
@ -188,4 +185,3 @@ ImagingPcxEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
}
}

41
src/libImaging/Point.c
View File

@ -19,7 +19,6 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
typedef struct {
@ -27,8 +26,7 @@ typedef struct {
} im_point_context;
static void
im_point_8_8(Imaging imOut, Imaging imIn, im_point_context* context)
{
im_point_8_8(Imaging imOut, Imaging imIn, im_point_context *context) {
int x, y;
/* 8-bit source, 8-bit destination */
UINT8 *table = (UINT8 *)context->table;
@ -42,8 +40,7 @@ im_point_8_8(Imaging imOut, Imaging imIn, im_point_context* context)
}
static void
im_point_2x8_2x8(Imaging imOut, Imaging imIn, im_point_context* context)
{
im_point_2x8_2x8(Imaging imOut, Imaging imIn, im_point_context *context) {
int x, y;
/* 2x8-bit source, 2x8-bit destination */
UINT8 *table = (UINT8 *)context->table;
@ -53,14 +50,14 @@ im_point_2x8_2x8(Imaging imOut, Imaging imIn, im_point_context* context)
for (x = 0; x < imIn->xsize; x++) {
out[0] = table[in[0]];
out[3] = table[in[3] + 256];
in += 4; out += 4;
in += 4;
out += 4;
}
}
}
static void
im_point_3x8_3x8(Imaging imOut, Imaging imIn, im_point_context* context)
{
im_point_3x8_3x8(Imaging imOut, Imaging imIn, im_point_context *context) {
int x, y;
/* 3x8-bit source, 3x8-bit destination */
UINT8 *table = (UINT8 *)context->table;
@ -71,14 +68,14 @@ im_point_3x8_3x8(Imaging imOut, Imaging imIn, im_point_context* context)
out[0] = table[in[0]];
out[1] = table[in[1] + 256];
out[2] = table[in[2] + 512];
in += 4; out += 4;
in += 4;
out += 4;
}
}
}
static void
im_point_4x8_4x8(Imaging imOut, Imaging imIn, im_point_context* context)
{
im_point_4x8_4x8(Imaging imOut, Imaging imIn, im_point_context *context) {
int x, y;
/* 4x8-bit source, 4x8-bit destination */
UINT8 *table = (UINT8 *)context->table;
@ -90,14 +87,14 @@ im_point_4x8_4x8(Imaging imOut, Imaging imIn, im_point_context* context)
out[1] = table[in[1] + 256];
out[2] = table[in[2] + 512];
out[3] = table[in[3] + 768];
in += 4; out += 4;
in += 4;
out += 4;
}
}
}
static void
im_point_8_32(Imaging imOut, Imaging imIn, im_point_context* context)
{
im_point_8_32(Imaging imOut, Imaging imIn, im_point_context *context) {
int x, y;
/* 8-bit source, 32-bit destination */
char *table = (char *)context->table;
@ -111,8 +108,7 @@ im_point_8_32(Imaging imOut, Imaging imIn, im_point_context* context)
}
static void
im_point_32_8(Imaging imOut, Imaging imIn, im_point_context* context)
{
im_point_32_8(Imaging imOut, Imaging imIn, im_point_context *context) {
int x, y;
/* 32-bit source, 8-bit destination */
UINT8 *table = (UINT8 *)context->table;
@ -132,8 +128,7 @@ im_point_32_8(Imaging imOut, Imaging imIn, im_point_context* context)
}
Imaging
ImagingPoint(Imaging imIn, const char* mode, const void* table)
{
ImagingPoint(Imaging imIn, const char *mode, const void *table) {
/* lookup table transform */
ImagingSectionCookie cookie;
@ -203,22 +198,18 @@ ImagingPoint(Imaging imIn, const char* mode, const void* table)
mode_mismatch:
return (Imaging)ImagingError_ValueError(
"point operation not supported for this mode"
);
"point operation not supported for this mode");
}
Imaging
ImagingPointTransform(Imaging imIn, double scale, double offset)
{
ImagingPointTransform(Imaging imIn, double scale, double offset) {
/* scale/offset transform */
ImagingSectionCookie cookie;
Imaging imOut;
int x, y;
if (!imIn || (strcmp(imIn->mode, "I") != 0 &&
strcmp(imIn->mode, "I;16") != 0 &&
if (!imIn || (strcmp(imIn->mode, "I") != 0 && strcmp(imIn->mode, "I;16") != 0 &&
strcmp(imIn->mode, "F") != 0)) {
return (Imaging)ImagingError_ModeError();
}

377
src/libImaging/Quant.c
View File

@ -66,29 +66,24 @@ typedef struct _BoxNode {
#define MAX_HASH_ENTRIES 65536
#define PIXEL_HASH(r, g, b) \
(((unsigned int)(r) )*463 ^ \
((unsigned int)(g)<< 8)*10069 ^ \
(((unsigned int)(r)) * 463 ^ ((unsigned int)(g) << 8) * 10069 ^ \
((unsigned int)(b) << 16) * 64997)
#define PIXEL_UNSCALE(p, q, s) \
((q)->c.r=(p)->c.r<<(s)), \
((q)->c.g=(p)->c.g<<(s)), \
((q)->c.r = (p)->c.r << (s)), ((q)->c.g = (p)->c.g << (s)), \
((q)->c.b = (p)->c.b << (s))
#define PIXEL_SCALE(p, q, s) \
((q)->c.r=(p)->c.r>>(s)), \
((q)->c.g=(p)->c.g>>(s)), \
((q)->c.r = (p)->c.r >> (s)), ((q)->c.g = (p)->c.g >> (s)), \
((q)->c.b = (p)->c.b >> (s))
static uint32_t
unshifted_pixel_hash(const HashTable *h, const Pixel pixel)
{
unshifted_pixel_hash(const HashTable *h, const Pixel pixel) {
return PIXEL_HASH(pixel.c.r, pixel.c.g, pixel.c.b);
}
static int
unshifted_pixel_cmp(const HashTable *h, const Pixel pixel1, const Pixel pixel2)
{
unshifted_pixel_cmp(const HashTable *h, const Pixel pixel1, const Pixel pixel2) {
if (pixel1.c.r == pixel2.c.r) {
if (pixel1.c.g == pixel2.c.g) {
if (pixel1.c.b == pixel2.c.b) {
@ -105,49 +100,43 @@ unshifted_pixel_cmp(const HashTable *h, const Pixel pixel1, const Pixel pixel2)
}
static uint32_t
pixel_hash(const HashTable *h,const Pixel pixel)
{
pixel_hash(const HashTable *h, const Pixel pixel) {
PixelHashData *d = (PixelHashData *)hashtable_get_user_data(h);
return PIXEL_HASH(pixel.c.r>>d->scale, pixel.c.g>>d->scale, pixel.c.b>>d->scale);
return PIXEL_HASH(
pixel.c.r >> d->scale, pixel.c.g >> d->scale, pixel.c.b >> d->scale);
}
static int
pixel_cmp(const HashTable *h,const Pixel pixel1, const Pixel pixel2)
{
pixel_cmp(const HashTable *h, const Pixel pixel1, const Pixel pixel2) {
PixelHashData *d = (PixelHashData *)hashtable_get_user_data(h);
uint32_t A, B;
A=PIXEL_HASH(pixel1.c.r>>d->scale, pixel1.c.g>>d->scale, pixel1.c.b>>d->scale);
B=PIXEL_HASH(pixel2.c.r>>d->scale, pixel2.c.g>>d->scale, pixel2.c.b>>d->scale);
A = PIXEL_HASH(
pixel1.c.r >> d->scale, pixel1.c.g >> d->scale, pixel1.c.b >> d->scale);
B = PIXEL_HASH(
pixel2.c.r >> d->scale, pixel2.c.g >> d->scale, pixel2.c.b >> d->scale);
return (A == B) ? 0 : ((A < B) ? -1 : 1);
}
static void
exists_count_func(const HashTable *h, const Pixel key, uint32_t *val)
{
exists_count_func(const HashTable *h, const Pixel key, uint32_t *val) {
*val += 1;
}
static void
new_count_func(const HashTable *h, const Pixel key, uint32_t *val)
{
new_count_func(const HashTable *h, const Pixel key, uint32_t *val) {
*val = 1;
}
static void
rehash_collide(const HashTable *h,
Pixel *keyp,
uint32_t *valp,
Pixel newkey,
uint32_t newval)
{
rehash_collide(
const HashTable *h, Pixel *keyp, uint32_t *valp, Pixel newkey, uint32_t newval) {
*valp += newval;
}
/* %% */
static HashTable *
create_pixel_hash(Pixel *pixelData,uint32_t nPixels)
{
create_pixel_hash(Pixel *pixelData, uint32_t nPixels) {
PixelHashData *d;
HashTable *hash;
uint32_t i;
@ -167,10 +156,9 @@ create_pixel_hash(Pixel *pixelData,uint32_t nPixels)
timer = timer3 = clock();
#endif
for (i = 0; i < nPixels; i++) {
if (!hashtable_insert_or_update_computed(hash,
pixelData[i],
new_count_func,
exists_count_func)) {;
if (!hashtable_insert_or_update_computed(
hash, pixelData[i], new_count_func, exists_count_func)) {
;
}
while (hashtable_get_count(hash) > MAX_HASH_ENTRIES) {
d->scale++;
@ -196,8 +184,7 @@ create_pixel_hash(Pixel *pixelData,uint32_t nPixels)
}
static void
destroy_pixel_hash(HashTable *hash)
{
destroy_pixel_hash(HashTable *hash) {
PixelHashData *d = (PixelHashData *)hashtable_get_user_data(hash);
if (d) {
free(d);
@ -205,7 +192,6 @@ destroy_pixel_hash(HashTable *hash)
hashtable_free(hash);
}
/* 1. hash quantized pixels. */
/* 2. create R,G,B lists of sorted quantized pixels. */
/* 3. median cut. */
@ -215,8 +201,7 @@ destroy_pixel_hash(HashTable *hash)
/* 7. map each pixel to nearest average. */
static int
compute_box_volume(BoxNode *b)
{
compute_box_volume(BoxNode *b) {
unsigned char rl, rh, gl, gh, bl, bh;
if (b->volume >= 0) {
return b->volume;
@ -236,8 +221,7 @@ compute_box_volume(BoxNode *b)
}
static void
hash_to_list(const HashTable *h, const Pixel pixel, const uint32_t count, void *u)
{
hash_to_list(const HashTable *h, const Pixel pixel, const uint32_t count, void *u) {
PixelHashData *d = (PixelHashData *)hashtable_get_user_data(h);
PixelList **pl = (PixelList **)u;
PixelList *p;
@ -266,8 +250,7 @@ hash_to_list(const HashTable *h, const Pixel pixel, const uint32_t count, void *
}
static PixelList *
mergesort_pixels(PixelList *head, int i)
{
mergesort_pixels(PixelList *head, int i) {
PixelList *c, *t, *a, *b, *p;
if (!head || !head->next[i]) {
if (head) {
@ -276,7 +259,9 @@ mergesort_pixels(PixelList *head, int i)
}
return head;
}
for (c=t=head;c&&t;c=c->next[i],t=(t->next[i])?t->next[i]->next[i]:NULL);
for (c = t = head; c && t;
c = c->next[i], t = (t->next[i]) ? t->next[i]->next[i] : NULL)
;
if (c) {
if (c->prev[i]) {
c->prev[i]->next[i] = NULL;
@ -317,8 +302,7 @@ mergesort_pixels(PixelList *head, int i)
#if defined(TEST_MERGESORT) || defined(TEST_SORTED)
static int
test_sorted(PixelList *pl[3])
{
test_sorted(PixelList *pl[3]) {
int i, n, l;
PixelList *t;
@ -326,7 +310,8 @@ test_sorted(PixelList *pl[3])
n = 0;
l = 256;
for (t = pl[i]; t; t = t->next[i]) {
if (l<t->p.a.v[i]) return 0;
if (l < t->p.a.v[i])
return 0;
l = t->p.a.v[i];
}
}
@ -335,8 +320,7 @@ test_sorted(PixelList *pl[3])
#endif
static int
box_heap_cmp(const Heap *h, const void *A, const void *B)
{
box_heap_cmp(const Heap *h, const void *A, const void *B) {
BoxNode *a = (BoxNode *)A;
BoxNode *b = (BoxNode *)B;
return (int)a->pixelCount - (int)b->pixelCount;
@ -345,14 +329,14 @@ box_heap_cmp(const Heap *h, const void *A, const void *B)
#define LUMINANCE(p) (77 * (p)->c.r + 150 * (p)->c.g + 29 * (p)->c.b)
static int
splitlists(PixelList *h[3],
splitlists(
PixelList *h[3],
PixelList *t[3],
PixelList *nh[2][3],
PixelList *nt[2][3],
uint32_t nCount[2],
int axis,
uint32_t pixelCount)
{
uint32_t pixelCount) {
uint32_t left;
PixelList *l, *r, *c, *n;
@ -365,8 +349,14 @@ splitlists(PixelList *h[3],
PixelList *_prevTest, *_nextTest;
int _i, _nextCount[3], _prevCount[3];
for (_i = 0; _i < 3; _i++) {
for (_nextCount[_i]=0,_nextTest=h[_i];_nextTest&&_nextTest->next[_i];_nextTest=_nextTest->next[_i],_nextCount[_i]++);
for (_prevCount[_i]=0,_prevTest=t[_i];_prevTest&&_prevTest->prev[_i];_prevTest=_prevTest->prev[_i],_prevCount[_i]++);
for (_nextCount[_i] = 0, _nextTest = h[_i];
_nextTest && _nextTest->next[_i];
_nextTest = _nextTest->next[_i], _nextCount[_i]++)
;
for (_prevCount[_i] = 0, _prevTest = t[_i];
_prevTest && _prevTest->prev[_i];
_prevTest = _prevTest->prev[_i], _prevCount[_i]++)
;
if (_nextTest != t[_i]) {
printf("next-list of axis %d does not end at tail\n", _i);
exit(1);
@ -375,8 +365,10 @@ splitlists(PixelList *h[3],
printf("prev-list of axis %d does not end at head\n", _i);
exit(1);
}
for (;_nextTest&&_nextTest->prev[_i];_nextTest=_nextTest->prev[_i]);
for (;_prevTest&&_prevTest->next[_i];_prevTest=_prevTest->next[_i]);
for (; _nextTest && _nextTest->prev[_i]; _nextTest = _nextTest->prev[_i])
;
for (; _prevTest && _prevTest->next[_i]; _prevTest = _prevTest->next[_i])
;
if (_nextTest != h[_i]) {
printf("next-list of axis %d does not loop back to head\n", _i);
exit(1);
@ -390,7 +382,8 @@ splitlists(PixelList *h[3],
if (_prevCount[_i] != _prevCount[_i - 1] ||
_nextCount[_i] != _nextCount[_i - 1] ||
_prevCount[_i] != _nextCount[_i]) {
printf ("{%d %d %d} {%d %d %d}\n",
printf(
"{%d %d %d} {%d %d %d}\n",
_prevCount[0],
_prevCount[1],
_prevCount[2],
@ -488,8 +481,7 @@ splitlists(PixelList *h[3],
}
static int
split(BoxNode *node)
{
split(BoxNode *node) {
unsigned char rl, rh, gl, gh, bl, bh;
int f[3];
int best, axis;
@ -515,7 +507,10 @@ split(BoxNode *node)
best = f[0];
axis = 0;
for (i = 1; i < 3; i++) {
if (best<f[i]) { best=f[i]; axis=i; }
if (best < f[i]) {
best = f[i];
axis = i;
}
}
#ifdef TEST_SPLIT
printf("along axis %d\n", axis + 1);
@ -528,25 +523,35 @@ split(BoxNode *node)
for (_i = 0; _i < 3; _i++) {
if (node->tail[_i]->next[_i]) {
printf("tail is not tail\n");
printf ("node->tail[%d]->next[%d]=%p\n",_i,_i,node->tail[_i]->next[_i]);
printf(
"node->tail[%d]->next[%d]=%p\n", _i, _i, node->tail[_i]->next[_i]);
}
if (node->head[_i]->prev[_i]) {
printf("head is not head\n");
printf ("node->head[%d]->prev[%d]=%p\n",_i,_i,node->head[_i]->prev[_i]);
printf(
"node->head[%d]->prev[%d]=%p\n", _i, _i, node->head[_i]->prev[_i]);
}
}
for (_i = 0; _i < 3; _i++) {
for (_nextCount[_i]=0,_nextTest=node->head[_i];_nextTest&&_nextTest->next[_i];_nextTest=_nextTest->next[_i],_nextCount[_i]++);
for (_prevCount[_i]=0,_prevTest=node->tail[_i];_prevTest&&_prevTest->prev[_i];_prevTest=_prevTest->prev[_i],_prevCount[_i]++);
for (_nextCount[_i] = 0, _nextTest = node->head[_i];
_nextTest && _nextTest->next[_i];
_nextTest = _nextTest->next[_i], _nextCount[_i]++)
;
for (_prevCount[_i] = 0, _prevTest = node->tail[_i];
_prevTest && _prevTest->prev[_i];
_prevTest = _prevTest->prev[_i], _prevCount[_i]++)
;
if (_nextTest != node->tail[_i]) {
printf("next-list of axis %d does not end at tail\n", _i);
}
if (_prevTest != node->head[_i]) {
printf("prev-list of axis %d does not end at head\n", _i);
}
for (;_nextTest&&_nextTest->prev[_i];_nextTest=_nextTest->prev[_i]);
for (;_prevTest&&_prevTest->next[_i];_prevTest=_prevTest->next[_i]);
for (; _nextTest && _nextTest->prev[_i]; _nextTest = _nextTest->prev[_i])
;
for (; _prevTest && _prevTest->next[_i]; _prevTest = _prevTest->next[_i])
;
if (_nextTest != node->head[_i]) {
printf("next-list of axis %d does not loop back to head\n", _i);
}
@ -558,7 +563,8 @@ split(BoxNode *node)
if (_prevCount[_i] != _prevCount[_i - 1] ||
_nextCount[_i] != _nextCount[_i - 1] ||
_prevCount[_i] != _nextCount[_i]) {
printf ("{%d %d %d} {%d %d %d}\n",
printf(
"{%d %d %d} {%d %d %d}\n",
_prevCount[0],
_prevCount[1],
_prevCount[2],
@ -570,13 +576,8 @@ split(BoxNode *node)
}
#endif
node->axis = axis;
if (!splitlists(node->head,
node->tail,
heads,
tails,
newCounts,
axis,
node->pixelCount)) {
if (!splitlists(
node->head, node->tail, heads, tails, newCounts, axis, node->pixelCount)) {
#ifndef NO_OUTPUT
printf("list split failed.\n");
#endif
@ -640,10 +641,7 @@ split(BoxNode *node)
}
static BoxNode *
median_cut(PixelList *hl[3],
uint32_t imPixelCount,
int nPixels)
{
median_cut(PixelList *hl[3], uint32_t imPixelCount, int nPixels) {
PixelList *tl[3];
int i;
BoxNode *root;
@ -653,9 +651,13 @@ median_cut(PixelList *hl[3],
h = ImagingQuantHeapNew(box_heap_cmp);
/* malloc check ok, small constant allocation */
root = malloc(sizeof(BoxNode));
if (!root) { ImagingQuantHeapFree(h); return NULL; }
if (!root) {
ImagingQuantHeapFree(h);
return NULL;
}
for (i = 0; i < 3; i++) {
for (tl[i]=hl[i];tl[i]&&tl[i]->next[i];tl[i]=tl[i]->next[i]);
for (tl[i] = hl[i]; tl[i] && tl[i]->next[i]; tl[i] = tl[i]->next[i])
;
root->head[i] = hl[i];
root->tail[i] = tl[i];
}
@ -686,8 +688,7 @@ done:
}
static void
free_box_tree(BoxNode *n)
{
free_box_tree(BoxNode *n) {
PixelList *p, *pp;
if (n->l) {
free_box_tree(n->l);
@ -704,8 +705,7 @@ free_box_tree(BoxNode *n)
#ifdef TEST_SPLIT_INTEGRITY
static int
checkContained(BoxNode *n,Pixel *pp)
{
checkContained(BoxNode *n, Pixel *pp) {
if (n->l && n->r) {
return checkContained(n->l, pp) + checkContained(n->r, pp);
}
@ -715,13 +715,9 @@ checkContained(BoxNode *n,Pixel *pp)
#endif
return 0;
}
if (
pp->c.r<=n->head[0]->p.c.r &&
pp->c.r>=n->tail[0]->p.c.r &&
pp->c.g<=n->head[1]->p.c.g &&
pp->c.g>=n->tail[1]->p.c.g &&
pp->c.b<=n->head[2]->p.c.b &&
pp->c.b>=n->tail[2]->p.c.b) {
if (pp->c.r <= n->head[0]->p.c.r && pp->c.r >= n->tail[0]->p.c.r &&
pp->c.g <= n->head[1]->p.c.g && pp->c.g >= n->tail[1]->p.c.g &&
pp->c.b <= n->head[2]->p.c.b && pp->c.b >= n->tail[2]->p.c.b) {
return 1;
}
return 0;
@ -729,8 +725,7 @@ checkContained(BoxNode *n,Pixel *pp)
#endif
static int
annotate_hash_table(BoxNode *n,HashTable *h,uint32_t *box)
{
annotate_hash_table(BoxNode *n, HashTable *h, uint32_t *box) {
PixelList *p;
PixelHashData *d = (PixelHashData *)hashtable_get_user_data(h);
Pixel q;
@ -759,19 +754,15 @@ annotate_hash_table(BoxNode *n,HashTable *h,uint32_t *box)
}
static int
_sort_ulong_ptr_keys(const void *a, const void *b)
{
_sort_ulong_ptr_keys(const void *a, const void *b) {
uint32_t A = **(uint32_t **)a;
uint32_t B = **(uint32_t **)b;
return (A == B) ? 0 : ((A < B) ? -1 : +1);
}
static int
resort_distance_tables(uint32_t *avgDist,
uint32_t **avgDistSortKey,
Pixel *p,
uint32_t nEntries)
{
resort_distance_tables(
uint32_t *avgDist, uint32_t **avgDistSortKey, Pixel *p, uint32_t nEntries) {
uint32_t i, j, k;
uint32_t **skRow;
uint32_t *skElt;
@ -779,8 +770,8 @@ resort_distance_tables(uint32_t *avgDist,
for (i = 0; i < nEntries; i++) {
avgDist[i * nEntries + i] = 0;
for (j = 0; j < i; j++) {
avgDist[j*nEntries+i]=
avgDist[i*nEntries+j]=_DISTSQR(p+i,p+j);
avgDist[j * nEntries + i] = avgDist[i * nEntries + j] =
_DISTSQR(p + i, p + j);
}
}
for (i = 0; i < nEntries; i++) {
@ -799,25 +790,23 @@ resort_distance_tables(uint32_t *avgDist,
}
static int
build_distance_tables(uint32_t *avgDist,
uint32_t **avgDistSortKey,
Pixel *p,
uint32_t nEntries)
{
build_distance_tables(
uint32_t *avgDist, uint32_t **avgDistSortKey, Pixel *p, uint32_t nEntries) {
uint32_t i, j;
for (i = 0; i < nEntries; i++) {
avgDist[i * nEntries + i] = 0;
avgDistSortKey[i * nEntries + i] = &(avgDist[i * nEntries + i]);
for (j = 0; j < i; j++) {
avgDist[j*nEntries+i]=
avgDist[i*nEntries+j]=_DISTSQR(p+i,p+j);
avgDist[j * nEntries + i] = avgDist[i * nEntries + j] =
_DISTSQR(p + i, p + j);
avgDistSortKey[j * nEntries + i] = &(avgDist[j * nEntries + i]);
avgDistSortKey[i * nEntries + j] = &(avgDist[i * nEntries + j]);
}
}
for (i = 0; i < nEntries; i++) {
qsort(avgDistSortKey+i*nEntries,
qsort(
avgDistSortKey + i * nEntries,
nEntries,
sizeof(uint32_t *),
_sort_ulong_ptr_keys);
@ -826,14 +815,14 @@ build_distance_tables(uint32_t *avgDist,
}
static int
map_image_pixels(Pixel *pixelData,
map_image_pixels(
Pixel *pixelData,
uint32_t nPixels,
Pixel *paletteData,
uint32_t nPaletteEntries,
uint32_t *avgDist,
uint32_t **avgDistSortKey,
uint32_t *pixelArray)
{
uint32_t *pixelArray) {
uint32_t *aD, **aDSK;
uint32_t idx;
uint32_t i, j;
@ -880,8 +869,7 @@ map_image_pixels_from_quantized_pixels(
uint32_t **avgDistSortKey,
uint32_t *pixelArray,
uint32_t *avg[3],
uint32_t *count)
{
uint32_t *count) {
uint32_t *aD, **aDSK;
uint32_t idx;
uint32_t i, j;
@ -939,8 +927,7 @@ map_image_pixels_from_median_box(
HashTable *medianBoxHash,
uint32_t *avgDist,
uint32_t **avgDistSortKey,
uint32_t *pixelArray)
{
uint32_t *pixelArray) {
uint32_t *aD, **aDSK;
uint32_t idx;
uint32_t i, j;
@ -992,8 +979,7 @@ compute_palette_from_median_cut(
uint32_t nPixels,
HashTable *medianBoxHash,
Pixel **palette,
uint32_t nPaletteEntries)
{
uint32_t nPaletteEntries) {
uint32_t i;
uint32_t paletteEntry;
Pixel *p;
@ -1022,7 +1008,10 @@ compute_palette_from_median_cut(
}
for (i = 0; i < nPixels; i++) {
#ifdef TEST_SPLIT_INTEGRITY
if (!(i%100)) { printf ("%05d\r",i); fflush(stdout); }
if (!(i % 100)) {
printf("%05d\r", i);
fflush(stdout);
}
if (checkContained(root, pixelData + i) > 1) {
printf("pixel in two boxes\n");
for (i = 0; i < 3; i++) {
@ -1044,7 +1033,10 @@ compute_palette_from_median_cut(
}
if (paletteEntry >= nPaletteEntries) {
#ifndef NO_OUTPUT
printf ("panic - paletteEntry>=nPaletteEntries (%d>=%d)\n",(int)paletteEntry,(int)nPaletteEntries);
printf(
"panic - paletteEntry>=nPaletteEntries (%d>=%d)\n",
(int)paletteEntry,
(int)nPaletteEntries);
#endif
for (i = 0; i < 3; i++) {
free(avg[i]);
@ -1081,11 +1073,7 @@ compute_palette_from_median_cut(
static int
recompute_palette_from_averages(
Pixel *palette,
uint32_t nPaletteEntries,
uint32_t *avg[3],
uint32_t *count)
{
Pixel *palette, uint32_t nPaletteEntries, uint32_t *avg[3], uint32_t *count) {
uint32_t i;
for (i = 0; i < nPaletteEntries; i++) {
@ -1104,8 +1092,7 @@ compute_palette_from_quantized_pixels(
uint32_t nPaletteEntries,
uint32_t *avg[3],
uint32_t *count,
uint32_t *qp)
{
uint32_t *qp) {
uint32_t i;
memset(count, 0, sizeof(uint32_t) * nPaletteEntries);
@ -1133,13 +1120,13 @@ compute_palette_from_quantized_pixels(
}
static int
k_means(Pixel *pixelData,
k_means(
Pixel *pixelData,
uint32_t nPixels,
Pixel *paletteData,
uint32_t nPaletteEntries,
uint32_t *qp,
int threshold)
{
int threshold) {
uint32_t *avg[3];
uint32_t *count;
uint32_t i;
@ -1171,25 +1158,34 @@ k_means(Pixel *pixelData,
}
/* malloc check ok, using calloc, checking n*n above */
avgDist = calloc(nPaletteEntries * nPaletteEntries, sizeof(uint32_t));
if (!avgDist) { goto error_1; }
if (!avgDist) {
goto error_1;
}
/* malloc check ok, using calloc, checking n*n above */
avgDistSortKey = calloc(nPaletteEntries * nPaletteEntries, sizeof(uint32_t *));
if (!avgDistSortKey) { goto error_2; }
if (!avgDistSortKey) {
goto error_2;
}
#ifndef NO_OUTPUT
printf("[");fflush(stdout);
printf("[");
fflush(stdout);
#endif
while (1) {
if (!built) {
compute_palette_from_quantized_pixels(pixelData,nPixels,paletteData,nPaletteEntries,avg,count,qp);
build_distance_tables(avgDist,avgDistSortKey,paletteData,nPaletteEntries);
compute_palette_from_quantized_pixels(
pixelData, nPixels, paletteData, nPaletteEntries, avg, count, qp);
build_distance_tables(
avgDist, avgDistSortKey, paletteData, nPaletteEntries);
built = 1;
} else {
recompute_palette_from_averages(paletteData, nPaletteEntries, avg, count);
resort_distance_tables(avgDist,avgDistSortKey,paletteData,nPaletteEntries);
resort_distance_tables(
avgDist, avgDistSortKey, paletteData, nPaletteEntries);
}
changes=map_image_pixels_from_quantized_pixels(pixelData,
changes = map_image_pixels_from_quantized_pixels(
pixelData,
nPixels,
paletteData,
nPaletteEntries,
@ -1202,7 +1198,8 @@ k_means(Pixel *pixelData,
goto error_3;
}
#ifndef NO_OUTPUT
printf (".(%d)",changes);fflush(stdout);
printf(".(%d)", changes);
fflush(stdout);
#endif
if (changes <= threshold) {
break;
@ -1248,14 +1245,14 @@ error_1:
}
int
quantize(Pixel *pixelData,
quantize(
Pixel *pixelData,
uint32_t nPixels,
uint32_t nQuantPixels,
Pixel **palette,
uint32_t *paletteLength,
uint32_t **quantizedPixels,
int kmeans)
{
int kmeans) {
PixelList *hl[3];
HashTable *h;
BoxNode *root;
@ -1273,7 +1270,9 @@ quantize(Pixel *pixelData,
#ifndef NO_OUTPUT
timer2 = clock();
printf ("create hash table..."); fflush(stdout); timer=clock();
printf("create hash table...");
fflush(stdout);
timer = clock();
#endif
h = create_pixel_hash(pixelData, nPixels);
#ifndef NO_OUTPUT
@ -1284,7 +1283,9 @@ quantize(Pixel *pixelData,
}
#ifndef NO_OUTPUT
printf ("create lists from hash table..."); fflush(stdout); timer=clock();
printf("create lists from hash table...");
fflush(stdout);
timer = clock();
#endif
hl[0] = hl[1] = hl[2] = NULL;
hashtable_foreach(h, hash_to_list, hl);
@ -1297,7 +1298,9 @@ quantize(Pixel *pixelData,
}
#ifndef NO_OUTPUT
printf ("mergesort lists..."); fflush(stdout); timer=clock();
printf("mergesort lists...");
fflush(stdout);
timer = clock();
#endif
for (i = 0; i < 3; i++) {
hl[i] = mergesort_pixels(hl[i], i);
@ -1313,7 +1316,9 @@ quantize(Pixel *pixelData,
#endif
#ifndef NO_OUTPUT
printf ("median cut..."); fflush(stdout); timer=clock();
printf("median cut...");
fflush(stdout);
timer = clock();
#endif
root = median_cut(hl, nPixels, nQuantPixels);
#ifndef NO_OUTPUT
@ -1324,14 +1329,18 @@ quantize(Pixel *pixelData,
}
nPaletteEntries = 0;
#ifndef NO_OUTPUT
printf ("median cut tree to hash table..."); fflush(stdout); timer=clock();
printf("median cut tree to hash table...");
fflush(stdout);
timer = clock();
#endif
annotate_hash_table(root, h, &nPaletteEntries);
#ifndef NO_OUTPUT
printf("done (%f)\n", (clock() - timer) / (double)CLOCKS_PER_SEC);
#endif
#ifndef NO_OUTPUT
printf ("compute palette...\n"); fflush(stdout); timer=clock();
printf("compute palette...\n");
fflush(stdout);
timer = clock();
#endif
if (!compute_palette_from_median_cut(pixelData, nPixels, h, &p, nPaletteEntries)) {
goto error_3;
@ -1345,24 +1354,31 @@ quantize(Pixel *pixelData,
/* malloc check ok, using calloc for overflow */
qp = calloc(nPixels, sizeof(uint32_t));
if (!qp) { goto error_4; }
if (!qp) {
goto error_4;
}
if (nPaletteEntries > UINT32_MAX / nPaletteEntries) {
goto error_5;
}
/* malloc check ok, using calloc for overflow, check of n*n above */
avgDist = calloc(nPaletteEntries * nPaletteEntries, sizeof(uint32_t));
if (!avgDist) { goto error_5; }
if (!avgDist) {
goto error_5;
}
/* malloc check ok, using calloc for overflow, check of n*n above */
avgDistSortKey = calloc(nPaletteEntries * nPaletteEntries, sizeof(uint32_t *));
if (!avgDistSortKey) { goto error_6; }
if (!avgDistSortKey) {
goto error_6;
}
if (!build_distance_tables(avgDist, avgDistSortKey, p, nPaletteEntries)) {
goto error_7;
}
if (!map_image_pixels_from_median_box(pixelData,nPixels,p,nPaletteEntries,h,avgDist,avgDistSortKey,qp)) {
if (!map_image_pixels_from_median_box(
pixelData, nPixels, p, nPaletteEntries, h, avgDist, avgDistSortKey, qp)) {
goto error_7;
}
@ -1371,20 +1387,20 @@ quantize(Pixel *pixelData,
{
uint32_t bestmatch, bestdist, dist;
HashTable *h2;
printf ("nearest neighbour search (full search)..."); fflush(stdout); timer=clock();
printf("nearest neighbour search (full search)...");
fflush(stdout);
timer = clock();
h2 = hashtable_new(unshifted_pixel_hash, unshifted_pixel_cmp);
for (i = 0; i < nPixels; i++) {
if (hashtable_lookup(h2, pixelData[i], &paletteEntry)) {
bestmatch = paletteEntry;
} else {
bestmatch = 0;
bestdist=
_SQR(pixelData[i].c.r-p[0].c.r)+
bestdist = _SQR(pixelData[i].c.r - p[0].c.r) +
_SQR(pixelData[i].c.g - p[0].c.g) +
_SQR(pixelData[i].c.b - p[0].c.b);
for (j = 1; j < nPaletteEntries; j++) {
dist=
_SQR(pixelData[i].c.r-p[j].c.r)+
dist = _SQR(pixelData[i].c.r - p[j].c.r) +
_SQR(pixelData[i].c.g - p[j].c.g) +
_SQR(pixelData[i].c.b - p[j].c.b);
if (dist == bestdist && j == qp[i]) {
@ -1413,7 +1429,9 @@ quantize(Pixel *pixelData,
}
#endif
#ifndef NO_OUTPUT
printf ("k means...\n"); fflush(stdout); timer=clock();
printf("k means...\n");
fflush(stdout);
timer = clock();
#endif
if (kmeans) {
k_means(pixelData, nPixels, p, nPaletteEntries, qp, kmeans - 1);
@ -1427,7 +1445,9 @@ quantize(Pixel *pixelData,
*paletteLength = nPaletteEntries;
#ifndef NO_OUTPUT
printf ("cleanup..."); fflush(stdout); timer=clock();
printf("cleanup...");
fflush(stdout);
timer = clock();
#endif
if (avgDist) {
free(avgDist);
@ -1479,8 +1499,7 @@ typedef struct {
} DistanceData;
static void
compute_distances(const HashTable *h, const Pixel pixel, uint32_t *dist, void *u)
{
compute_distances(const HashTable *h, const Pixel pixel, uint32_t *dist, void *u) {
DistanceData *data = (DistanceData *)u;
uint32_t oldDist = *dist;
uint32_t newDist;
@ -1496,14 +1515,14 @@ compute_distances(const HashTable *h, const Pixel pixel, uint32_t *dist, void *u
}
int
quantize2(Pixel *pixelData,
quantize2(
Pixel *pixelData,
uint32_t nPixels,
uint32_t nQuantPixels,
Pixel **palette,
uint32_t *paletteLength,
uint32_t **quantizedPixels,
int kmeans)
{
int kmeans) {
HashTable *h;
uint32_t i;
uint32_t mean[3];
@ -1541,7 +1560,9 @@ quantize2(Pixel *pixelData,
/* malloc check ok, using calloc */
qp = calloc(nPixels, sizeof(uint32_t));
if (!qp) { goto error_1; }
if (!qp) {
goto error_1;
}
if (nQuantPixels > UINT32_MAX / nQuantPixels) {
goto error_2;
@ -1549,17 +1570,22 @@ quantize2(Pixel *pixelData,
/* malloc check ok, using calloc for overflow, check of n*n above */
avgDist = calloc(nQuantPixels * nQuantPixels, sizeof(uint32_t));
if (!avgDist) { goto error_2; }
if (!avgDist) {
goto error_2;
}
/* malloc check ok, using calloc for overflow, check of n*n above */
avgDistSortKey = calloc(nQuantPixels * nQuantPixels, sizeof(uint32_t *));
if (!avgDistSortKey) { goto error_3; }
if (!avgDistSortKey) {
goto error_3;
}
if (!build_distance_tables(avgDist, avgDistSortKey, p, nQuantPixels)) {
goto error_4;
}
if (!map_image_pixels(pixelData,nPixels,p,nQuantPixels,avgDist,avgDistSortKey,qp)) {
if (!map_image_pixels(
pixelData, nPixels, p, nQuantPixels, avgDist, avgDistSortKey, qp)) {
goto error_4;
}
if (kmeans) {
@ -1585,8 +1611,7 @@ error_1:
}
Imaging
ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
{
ImagingQuantize(Imaging im, int colors, int mode, int kmeans) {
int i, j;
int x, y, v;
UINT8 *pp;
@ -1686,8 +1711,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
&palette,
&paletteLength,
&newData,
kmeans
);
kmeans);
break;
case 1:
/* maximum coverage */
@ -1698,8 +1722,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
&palette,
&paletteLength,
&newData,
kmeans
);
kmeans);
break;
case 2:
if (!strcmp(im->mode, "RGBA")) {
@ -1712,8 +1735,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
&palette,
&paletteLength,
&newData,
withAlpha
);
withAlpha);
break;
case 3:
#ifdef HAVE_LIBIMAGEQUANT
@ -1728,8 +1750,7 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
&palette,
&paletteLength,
&newData,
withAlpha
);
withAlpha);
#else
result = -1;
#endif
@ -1783,7 +1804,6 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
return imOut;
} else {
if (result == -1) {
return (Imaging)ImagingError_ValueError(
"dependency required by this method was not "
@ -1791,6 +1811,5 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
}
return (Imaging)ImagingError_ValueError("quantization error");
}
}

69
src/libImaging/QuantHash.c
View File

@ -41,24 +41,32 @@ struct _HashTable {
#define MIN_LENGTH 11
#define RESIZE_FACTOR 3
static int _hashtable_insert_node(HashTable *,HashNode *,int,int,CollisionFunc);
static int
_hashtable_insert_node(HashTable *, HashNode *, int, int, CollisionFunc);
HashTable *hashtable_new(HashFunc hf,HashCmpFunc cf) {
HashTable *
hashtable_new(HashFunc hf, HashCmpFunc cf) {
HashTable *h;
h = malloc(sizeof(HashTable));
if (!h) { return NULL; }
if (!h) {
return NULL;
}
h->hashFunc = hf;
h->cmpFunc = cf;
h->length = MIN_LENGTH;
h->count = 0;
h->userData = NULL;
h->table = malloc(sizeof(HashNode *) * h->length);
if (!h->table) { free(h); return NULL; }
if (!h->table) {
free(h);
return NULL;
}
memset(h->table, 0, sizeof(HashNode *) * h->length);
return h;
}
static uint32_t _findPrime(uint32_t start,int dir) {
static uint32_t
_findPrime(uint32_t start, int dir) {
static int unit[] = {0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0};
uint32_t t;
while (start > 1) {
@ -79,7 +87,8 @@ static uint32_t _findPrime(uint32_t start,int dir) {
return start;
}
static void _hashtable_rehash(HashTable *h,CollisionFunc cf,uint32_t newSize) {
static void
_hashtable_rehash(HashTable *h, CollisionFunc cf, uint32_t newSize) {
HashNode **oldTable = h->table;
uint32_t i;
HashNode *n, *nn;
@ -102,7 +111,8 @@ static void _hashtable_rehash(HashTable *h,CollisionFunc cf,uint32_t newSize) {
free(oldTable);
}
static void _hashtable_resize(HashTable *h) {
static void
_hashtable_resize(HashTable *h) {
uint32_t newSize;
uint32_t oldSize;
oldSize = h->length;
@ -112,13 +122,17 @@ static void _hashtable_resize(HashTable *h) {
} else if (h->length * RESIZE_FACTOR < h->count) {
newSize = _findPrime(h->length * 2 + 1, +1);
}
if (newSize<MIN_LENGTH) { newSize=oldSize; }
if (newSize < MIN_LENGTH) {
newSize = oldSize;
}
if (newSize != oldSize) {
_hashtable_rehash(h, NULL, newSize);
}
}
static int _hashtable_insert_node(HashTable *h,HashNode *node,int resize,int update,CollisionFunc cf) {
static int
_hashtable_insert_node(
HashTable *h, HashNode *node, int resize, int update, CollisionFunc cf) {
uint32_t hash = h->hashFunc(h, node->key) % h->length;
HashNode **n, *nv;
int i;
@ -155,7 +169,8 @@ static int _hashtable_insert_node(HashTable *h,HashNode *node,int resize,int upd
}
}
static int _hashtable_insert(HashTable *h,HashKey_t key,HashVal_t val,int resize,int update) {
static int
_hashtable_insert(HashTable *h, HashKey_t key, HashVal_t val, int resize, int update) {
HashNode **n, *nv;
HashNode *t;
int i;
@ -190,10 +205,9 @@ static int _hashtable_insert(HashTable *h,HashKey_t key,HashVal_t val,int resize
}
}
int hashtable_insert_or_update_computed(HashTable *h,
HashKey_t key,
ComputeFunc newFunc,
ComputeFunc existsFunc) {
int
hashtable_insert_or_update_computed(
HashTable *h, HashKey_t key, ComputeFunc newFunc, ComputeFunc existsFunc) {
HashNode **n, *nv;
HashNode *t;
int i;
@ -231,11 +245,13 @@ int hashtable_insert_or_update_computed(HashTable *h,
return 1;
}
int hashtable_insert(HashTable *h,HashKey_t key,HashVal_t val) {
int
hashtable_insert(HashTable *h, HashKey_t key, HashVal_t val) {
return _hashtable_insert(h, key, val, 1, 0);
}
void hashtable_foreach_update(HashTable *h,IteratorUpdateFunc i,void *u) {
void
hashtable_foreach_update(HashTable *h, IteratorUpdateFunc i, void *u) {
HashNode *n;
uint32_t x;
@ -248,7 +264,8 @@ void hashtable_foreach_update(HashTable *h,IteratorUpdateFunc i,void *u) {
}
}
void hashtable_foreach(HashTable *h,IteratorFunc i,void *u) {
void
hashtable_foreach(HashTable *h, IteratorFunc i, void *u) {
HashNode *n;
uint32_t x;
@ -261,7 +278,8 @@ void hashtable_foreach(HashTable *h,IteratorFunc i,void *u) {
}
}
void hashtable_free(HashTable *h) {
void
hashtable_free(HashTable *h) {
HashNode *n, *nn;
uint32_t i;
@ -277,11 +295,13 @@ void hashtable_free(HashTable *h) {
free(h);
}
void hashtable_rehash_compute(HashTable *h,CollisionFunc cf) {
void
hashtable_rehash_compute(HashTable *h, CollisionFunc cf) {
_hashtable_rehash(h, cf, h->length);
}
int hashtable_lookup(const HashTable *h,const HashKey_t key,HashVal_t *valp) {
int
hashtable_lookup(const HashTable *h, const HashKey_t key, HashVal_t *valp) {
uint32_t hash = h->hashFunc(h, key) % h->length;
HashNode *n;
int i;
@ -298,15 +318,18 @@ int hashtable_lookup(const HashTable *h,const HashKey_t key,HashVal_t *valp) {
return 0;
}
uint32_t hashtable_get_count(const HashTable *h) {
uint32_t
hashtable_get_count(const HashTable *h) {
return h->count;
}
void *hashtable_get_user_data(const HashTable *h) {
void *
hashtable_get_user_data(const HashTable *h) {
return h->userData;
}
void *hashtable_set_user_data(HashTable *h,void *data) {
void *
hashtable_set_user_data(HashTable *h, void *data) {
void *r = h->userData;
h->userData = data;
return r;

43
src/libImaging/QuantHash.h
View File

@ -20,21 +20,36 @@ typedef uint32_t HashVal_t;
typedef uint32_t (*HashFunc)(const HashTable *, const HashKey_t);
typedef int (*HashCmpFunc)(const HashTable *, const HashKey_t, const HashKey_t);
typedef void (*IteratorFunc)(const HashTable *,const HashKey_t,const HashVal_t,void *);
typedef void (*IteratorUpdateFunc)(const HashTable *,const HashKey_t,HashVal_t *,void *);
typedef void (*IteratorFunc)(
const HashTable *, const HashKey_t, const HashVal_t, void *);
typedef void (*IteratorUpdateFunc)(
const HashTable *, const HashKey_t, HashVal_t *, void *);
typedef void (*ComputeFunc)(const HashTable *, const HashKey_t, HashVal_t *);
typedef void (*CollisionFunc)(const HashTable *,HashKey_t *,HashVal_t *,HashKey_t,HashVal_t);
typedef void (*CollisionFunc)(
const HashTable *, HashKey_t *, HashVal_t *, HashKey_t, HashVal_t);
HashTable * hashtable_new(HashFunc hf,HashCmpFunc cf);
void hashtable_free(HashTable *h);
void hashtable_foreach(HashTable *h,IteratorFunc i,void *u);
void hashtable_foreach_update(HashTable *h,IteratorUpdateFunc i,void *u);
int hashtable_insert(HashTable *h,HashKey_t key,HashVal_t val);
int hashtable_lookup(const HashTable *h,const HashKey_t key,HashVal_t *valp);
int hashtable_insert_or_update_computed(HashTable *h,HashKey_t key,ComputeFunc newFunc,ComputeFunc existsFunc);
void *hashtable_set_user_data(HashTable *h,void *data);
void *hashtable_get_user_data(const HashTable *h);
uint32_t hashtable_get_count(const HashTable *h);
void hashtable_rehash_compute(HashTable *h,CollisionFunc cf);
HashTable *
hashtable_new(HashFunc hf, HashCmpFunc cf);
void
hashtable_free(HashTable *h);
void
hashtable_foreach(HashTable *h, IteratorFunc i, void *u);
void
hashtable_foreach_update(HashTable *h, IteratorUpdateFunc i, void *u);
int
hashtable_insert(HashTable *h, HashKey_t key, HashVal_t val);
int
hashtable_lookup(const HashTable *h, const HashKey_t key, HashVal_t *valp);
int
hashtable_insert_or_update_computed(
HashTable *h, HashKey_t key, ComputeFunc newFunc, ComputeFunc existsFunc);
void *
hashtable_set_user_data(HashTable *h, void *data);
void *
hashtable_get_user_data(const HashTable *h);
uint32_t
hashtable_get_count(const HashTable *h);
void
hashtable_rehash_compute(HashTable *h, CollisionFunc cf);
#endif // __QUANTHASH_H__

34
src/libImaging/QuantHeap.c
View File

@ -36,15 +36,18 @@ struct _Heap {
// #define DEBUG
#ifdef DEBUG
static int _heap_test(Heap *);
static int
_heap_test(Heap *);
#endif
void ImagingQuantHeapFree(Heap *h) {
void
ImagingQuantHeapFree(Heap *h) {
free(h->heap);
free(h);
}
static int _heap_grow(Heap *h,unsigned int newsize) {
static int
_heap_grow(Heap *h, unsigned int newsize) {
void *newheap;
if (!newsize) {
newsize = h->heapsize << 1;
@ -69,7 +72,8 @@ static int _heap_grow(Heap *h,unsigned int newsize) {
}
#ifdef DEBUG
static int _heap_test(Heap *h) {
static int
_heap_test(Heap *h) {
unsigned int k;
for (k = 1; k * 2 <= h->heapcount; k++) {
if (h->cf(h, h->heap[k], h->heap[k * 2]) < 0) {
@ -85,7 +89,8 @@ static int _heap_test(Heap *h) {
}
#endif
int ImagingQuantHeapRemove(Heap* h,void **r) {
int
ImagingQuantHeapRemove(Heap *h, void **r) {
unsigned int k, l;
void *v;
@ -108,12 +113,16 @@ int ImagingQuantHeapRemove(Heap* h,void **r) {
}
h->heap[k] = v;
#ifdef DEBUG
if (!_heap_test(h)) { printf ("oops - heap_remove messed up the heap\n"); exit(1); }
if (!_heap_test(h)) {
printf("oops - heap_remove messed up the heap\n");
exit(1);
}
#endif
return 1;
}
int ImagingQuantHeapAdd(Heap *h,void *val) {
int
ImagingQuantHeapAdd(Heap *h, void *val) {
int k;
if (h->heapcount == h->heapsize - 1) {
_heap_grow(h, 0);
@ -128,12 +137,16 @@ int ImagingQuantHeapAdd(Heap *h,void *val) {
}
h->heap[k] = val;
#ifdef DEBUG
if (!_heap_test(h)) { printf ("oops - heap_add messed up the heap\n"); exit(1); }
if (!_heap_test(h)) {
printf("oops - heap_add messed up the heap\n");
exit(1);
}
#endif
return 1;
}
int ImagingQuantHeapTop(Heap *h,void **r) {
int
ImagingQuantHeapTop(Heap *h, void **r) {
if (!h->heapcount) {
return 0;
}
@ -141,7 +154,8 @@ int ImagingQuantHeapTop(Heap *h,void **r) {
return 1;
}
Heap *ImagingQuantHeapNew(HeapCmpFunc cf) {
Heap *
ImagingQuantHeapNew(HeapCmpFunc cf) {
Heap *h;
/* malloc check ok, small constant allocation */

12
src/libImaging/QuantHeap.h
View File

@ -18,10 +18,14 @@ typedef struct _Heap Heap;
typedef int (*HeapCmpFunc)(const Heap *, const void *, const void *);
void ImagingQuantHeapFree(Heap *);
int ImagingQuantHeapRemove(Heap *,void **);
int ImagingQuantHeapAdd(Heap *,void *);
int ImagingQuantHeapTop(Heap *,void **);
void
ImagingQuantHeapFree(Heap *);
int
ImagingQuantHeapRemove(Heap *, void **);
int
ImagingQuantHeapAdd(Heap *, void *);
int
ImagingQuantHeapTop(Heap *, void **);
Heap *ImagingQuantHeapNew(HeapCmpFunc);
#endif // __QUANTHEAP_H__

88
src/libImaging/QuantOctree.c
View File

@ -106,10 +106,14 @@ free_color_cube(ColorCube cube) {
}
static long
color_bucket_offset_pos(const ColorCube cube,
unsigned int r, unsigned int g, unsigned int b, unsigned int a)
{
return r<<cube->rOffset | g<<cube->gOffset | b<<cube->bOffset | a<<cube->aOffset;
color_bucket_offset_pos(
const ColorCube cube,
unsigned int r,
unsigned int g,
unsigned int b,
unsigned int a) {
return r << cube->rOffset | g << cube->gOffset | b << cube->bOffset |
a << cube->aOffset;
}
static long
@ -183,13 +187,17 @@ create_sorted_color_palette(const ColorCube cube) {
}
memcpy(buckets, cube->buckets, sizeof(struct _ColorBucket) * cube->size);
qsort(buckets, cube->size, sizeof(struct _ColorBucket),
qsort(
buckets,
cube->size,
sizeof(struct _ColorBucket),
(int (*)(void const *, void const *)) & compare_bucket_count);
return buckets;
}
void add_bucket_values(ColorBucket src, ColorBucket dst) {
void
add_bucket_values(ColorBucket src, ColorBucket dst) {
dst->count += src->count;
dst->r += src->r;
dst->g += src->g;
@ -198,9 +206,13 @@ void add_bucket_values(ColorBucket src, ColorBucket dst) {
}
/* expand or shrink a given cube to level */
static ColorCube copy_color_cube(const ColorCube cube,
unsigned int rBits, unsigned int gBits, unsigned int bBits, unsigned int aBits)
{
static ColorCube
copy_color_cube(
const ColorCube cube,
unsigned int rBits,
unsigned int gBits,
unsigned int bBits,
unsigned int aBits) {
unsigned int r, g, b, a;
long src_pos, dst_pos;
unsigned int src_reduce[4] = {0}, dst_reduce[4] = {0};
@ -245,20 +257,20 @@ static ColorCube copy_color_cube(const ColorCube cube,
for (g = 0; g < width[1]; g++) {
for (b = 0; b < width[2]; b++) {
for (a = 0; a < width[3]; a++) {
src_pos = color_bucket_offset_pos(cube,
src_pos = color_bucket_offset_pos(
cube,
r >> src_reduce[0],
g >> src_reduce[1],
b >> src_reduce[2],
a >> src_reduce[3]);
dst_pos = color_bucket_offset_pos(result,
dst_pos = color_bucket_offset_pos(
result,
r >> dst_reduce[0],
g >> dst_reduce[1],
b >> dst_reduce[2],
a >> dst_reduce[3]);
add_bucket_values(
&cube->buckets[src_pos],
&result->buckets[dst_pos]
);
&cube->buckets[src_pos], &result->buckets[dst_pos]);
}
}
}
@ -301,7 +313,8 @@ lookup_color(const ColorCube cube, const Pixel *p) {
return bucket->count;
}
void add_lookup_buckets(ColorCube cube, ColorBucket palette, long nColors, long offset) {
void
add_lookup_buckets(ColorCube cube, ColorBucket palette, long nColors, long offset) {
long i;
Pixel p;
for (i = offset; i < offset + nColors; i++) {
@ -311,7 +324,11 @@ void add_lookup_buckets(ColorCube cube, ColorBucket palette, long nColors, long
}
ColorBucket
combined_palette(ColorBucket bucketsA, unsigned long nBucketsA, ColorBucket bucketsB, unsigned long nBucketsB) {
combined_palette(
ColorBucket bucketsA,
unsigned long nBucketsA,
ColorBucket bucketsB,
unsigned long nBucketsB) {
ColorBucket result;
if (nBucketsA > LONG_MAX - nBucketsB ||
(nBucketsA + nBucketsB) > LONG_MAX / sizeof(struct _ColorBucket)) {
@ -345,11 +362,11 @@ create_palette_array(const ColorBucket palette, unsigned int paletteLength) {
}
static void
map_image_pixels(const Pixel *pixelData,
map_image_pixels(
const Pixel *pixelData,
uint32_t nPixels,
const ColorCube lookupCube,
uint32_t *pixelArray)
{
uint32_t *pixelArray) {
long i;
for (i = 0; i < nPixels; i++) {
pixelArray[i] = lookup_color(lookupCube, &pixelData[i]);
@ -359,14 +376,15 @@ map_image_pixels(const Pixel *pixelData,
const unsigned int CUBE_LEVELS[8] = {4, 4, 4, 0, 2, 2, 2, 0};
const unsigned int CUBE_LEVELS_ALPHA[8] = {3, 4, 3, 3, 2, 2, 2, 2};
int quantize_octree(Pixel *pixelData,
int
quantize_octree(
Pixel *pixelData,
uint32_t nPixels,
uint32_t nQuantPixels,
Pixel **palette,
uint32_t *paletteLength,
uint32_t **quantizedPixels,
int withAlpha)
{
int withAlpha) {
ColorCube fineCube = NULL;
ColorCube coarseCube = NULL;
ColorCube lookupCube = NULL;
@ -381,8 +399,7 @@ int quantize_octree(Pixel *pixelData,
if (withAlpha) {
cubeBits = CUBE_LEVELS_ALPHA;
}
else {
} else {
cubeBits = CUBE_LEVELS;
}
@ -402,8 +419,7 @@ int quantize_octree(Pixel *pixelData,
*/
/* create fine cube */
fineCube = new_color_cube(cubeBits[0], cubeBits[1],
cubeBits[2], cubeBits[3]);
fineCube = new_color_cube(cubeBits[0], cubeBits[1], cubeBits[2], cubeBits[3]);
if (!fineCube) {
goto error;
}
@ -412,8 +428,8 @@ int quantize_octree(Pixel *pixelData,
}
/* create coarse cube */
coarseCube = copy_color_cube(fineCube, cubeBits[4], cubeBits[5],
cubeBits[6], cubeBits[7]);
coarseCube =
copy_color_cube(fineCube, cubeBits[4], cubeBits[5], cubeBits[6], cubeBits[7]);
if (!coarseCube) {
goto error;
}
@ -442,7 +458,9 @@ int quantize_octree(Pixel *pixelData,
nAlreadySubtracted = nFineColors;
nCoarseColors = count_used_color_buckets(coarseCube);
nFineColors = nQuantPixels - nCoarseColors;
subtract_color_buckets(coarseCube, &paletteBucketsFine[nAlreadySubtracted],
subtract_color_buckets(
coarseCube,
&paletteBucketsFine[nAlreadySubtracted],
nFineColors - nAlreadySubtracted);
}
@ -451,8 +469,8 @@ int quantize_octree(Pixel *pixelData,
if (!paletteBucketsCoarse) {
goto error;
}
paletteBuckets = combined_palette(paletteBucketsCoarse, nCoarseColors,
paletteBucketsFine, nFineColors);
paletteBuckets = combined_palette(
paletteBucketsCoarse, nCoarseColors, paletteBucketsFine, nFineColors);
free(paletteBucketsFine);
paletteBucketsFine = NULL;
@ -463,8 +481,8 @@ int quantize_octree(Pixel *pixelData,
}
/* add all coarse colors to our coarse lookup cube. */
coarseLookupCube = new_color_cube(cubeBits[4], cubeBits[5],
cubeBits[6], cubeBits[7]);
coarseLookupCube =
new_color_cube(cubeBits[4], cubeBits[5], cubeBits[6], cubeBits[7]);
if (!coarseLookupCube) {
goto error;
}
@ -472,8 +490,8 @@ int quantize_octree(Pixel *pixelData,
/* expand coarse cube (64) to larger fine cube (4k). the value of each
coarse bucket is then present in the according 64 fine buckets. */
lookupCube = copy_color_cube(coarseLookupCube, cubeBits[0], cubeBits[1],
cubeBits[2], cubeBits[3]);
lookupCube = copy_color_cube(
coarseLookupCube, cubeBits[0], cubeBits[1], cubeBits[2], cubeBits[3]);
if (!lookupCube) {
goto error;
}

9
src/libImaging/QuantOctree.h
View File

@ -3,12 +3,7 @@
#include "QuantTypes.h"
int quantize_octree(Pixel *,
uint32_t,
uint32_t,
Pixel **,
uint32_t *,
uint32_t **,
int);
int
quantize_octree(Pixel *, uint32_t, uint32_t, Pixel **, uint32_t *, uint32_t **, int);
#endif

41
src/libImaging/QuantPngQuant.c
View File

@ -26,8 +26,7 @@ quantize_pngquant(
Pixel **palette,
uint32_t *paletteLength,
uint32_t **quantizedPixels,
int withAlpha)
{
int withAlpha) {
int result = 0;
liq_image *image = NULL;
liq_attr *attr = NULL;
@ -41,23 +40,24 @@ quantize_pngquant(
/* configure pngquant */
attr = liq_attr_create();
if (!attr) { goto err; }
if (!attr) {
goto err;
}
if (quantPixels) {
liq_set_max_colors(attr, quantPixels);
}
/* prepare input image */
image = liq_image_create_rgba(
attr,
pixelData,
width,
height,
0.45455 /* gamma */);
if (!image) { goto err; }
image = liq_image_create_rgba(attr, pixelData, width, height, 0.45455 /* gamma */);
if (!image) {
goto err;
}
/* quantize the image */
remap = liq_quantize_image(attr, image);
if (!remap) { goto err; }
if (!remap) {
goto err;
}
liq_set_output_gamma(remap, 0.45455);
liq_set_dithering_level(remap, 1);
@ -65,7 +65,9 @@ quantize_pngquant(
const liq_palette *l_palette = liq_get_palette(remap);
*paletteLength = l_palette->count;
*palette = malloc(sizeof(Pixel) * l_palette->count);
if (!*palette) { goto err; }
if (!*palette) {
goto err;
}
for (i = 0; i < l_palette->count; i++) {
(*palette)[i].c.b = l_palette->entries[i].b;
(*palette)[i].c.g = l_palette->entries[i].g;
@ -75,9 +77,13 @@ quantize_pngquant(
/* write output pixels (pngquant uses char array) */
charMatrix = malloc(width * height);
if (!charMatrix) { goto err; }
if (!charMatrix) {
goto err;
}
charMatrixRows = malloc(height * sizeof(unsigned char *));
if (!charMatrixRows) { goto err; }
if (!charMatrixRows) {
goto err;
}
for (y = 0; y < height; y++) {
charMatrixRows[y] = &charMatrix[y * width];
}
@ -87,7 +93,9 @@ quantize_pngquant(
/* transcribe output pixels (pillow uses uint32_t array) */
*quantizedPixels = malloc(sizeof(uint32_t) * width * height);
if (!*quantizedPixels) { goto err; }
if (!*quantizedPixels) {
goto err;
}
for (i = 0; i < width * height; i++) {
(*quantizedPixels)[i] = charMatrix[i];
}
@ -114,8 +122,7 @@ err:
}
const char *
ImagingImageQuantVersion(void)
{
ImagingImageQuantVersion(void) {
static char version[20];
int number = liq_version();
sprintf(version, "%d.%d.%d", number / 10000, (number / 100) % 100, number % 100);

4
src/libImaging/QuantPngQuant.h
View File

@ -3,7 +3,9 @@
#include "QuantTypes.h"
int quantize_pngquant(Pixel *,
int
quantize_pngquant(
Pixel *,
unsigned int,
unsigned int,
uint32_t,

34
src/libImaging/RankFilter.c
View File

@ -17,14 +17,19 @@
/* Fast rank algorithm (due to Wirth), based on public domain code
by Nicolas Devillard, available at http://ndevilla.free.fr */
#define SWAP(type,a,b) { register type t=(a);(a)=(b);(b)=t; }
#define SWAP(type, a, b) \
{ \
register type t = (a); \
(a) = (b); \
(b) = t; \
}
#define MakeRankFunction(type) \
static type Rank##type(type a[], int n, int k)\
{\
static type Rank##type(type a[], int n, int k) { \
register int i, j, l, m; \
register type x; \
l = 0; m = n-1;\
l = 0; \
m = n - 1; \
while (l < m) { \
x = a[k]; \
i = l; \
@ -38,7 +43,8 @@ static type Rank##type(type a[], int n, int k)\
} \
if (i <= j) { \
SWAP(type, a[i], a[j]); \
i++; j--;\
i++; \
j--; \
} \
} while (i <= j); \
if (j < k) { \
@ -51,13 +57,9 @@ static type Rank##type(type a[], int n, int k)\
return a[k]; \
}
MakeRankFunction(UINT8)
MakeRankFunction(INT32)
MakeRankFunction(FLOAT32)
MakeRankFunction(UINT8) MakeRankFunction(INT32) MakeRankFunction(FLOAT32)
Imaging
ImagingRankFilter(Imaging im, int size, int rank)
{
Imaging ImagingRankFilter(Imaging im, int size, int rank) {
Imaging imOut = NULL;
int x, y;
int i, margin, size2;
@ -71,8 +73,7 @@ ImagingRankFilter(Imaging im, int size, int rank)
}
/* malloc check ok, for overflow in the define below */
if (size > INT_MAX / size ||
size > INT_MAX / (size * (int)sizeof(FLOAT32))) {
if (size > INT_MAX / size || size > INT_MAX / (size * (int)sizeof(FLOAT32))) {
return (Imaging)ImagingError_ValueError("filter size too large");
}
@ -89,7 +90,8 @@ ImagingRankFilter(Imaging im, int size, int rank)
}
/* malloc check ok, checked above */
#define RANK_BODY(type) do {\
#define RANK_BODY(type) \
do { \
type *buf = malloc(size2 * sizeof(type)); \
if (!buf) { \
goto nomemory; \
@ -97,7 +99,9 @@ ImagingRankFilter(Imaging im, int size, int rank)
for (y = 0; y < imOut->ysize; y++) { \
for (x = 0; x < imOut->xsize; x++) { \
for (i = 0; i < size; i++) { \
memcpy(buf + i*size, &IMAGING_PIXEL_##type(im, x, y+i),\
memcpy( \
buf + i * size, \
&IMAGING_PIXEL_##type(im, x, y + i), \
size * sizeof(type)); \
} \
IMAGING_PIXEL_##type(imOut, x, y) = Rank##type(buf, size2, rank); \

1
src/libImaging/Raw.h
View File

@ -1,7 +1,6 @@
/* Raw.h */
typedef struct {
/* CONFIGURATION */
/* Distance between lines (0=no padding) */

18
src/libImaging/RawDecode.c
View File

@ -13,22 +13,18 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include "Raw.h"
int
ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
enum { LINE = 1, SKIP };
RAWSTATE *rawstate = state->context;
UINT8 *ptr;
if (state->state == 0) {
/* Initialize context variables */
/* get size of image data and padding */
@ -52,15 +48,12 @@ ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
}
state->state = LINE;
}
ptr = buf;
for (;;) {
if (state->state == SKIP) {
/* Skip padding between lines */
if (bytes < rawstate->skip) {
@ -71,7 +64,6 @@ ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
bytes -= rawstate->skip;
state->state = LINE;
}
if (bytes < state->bytes) {
@ -79,8 +71,10 @@ ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
}
/* Unpack data */
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, ptr, state->xsize);
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff] + state->xoff * im->pixelsize,
ptr,
state->xsize);
ptr += state->bytes;
bytes -= state->bytes;
@ -93,7 +87,5 @@ ImagingRawDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
}
state->state = SKIP;
}
}

15
src/libImaging/RawEncode.c
View File

@ -17,16 +17,13 @@
*
* See the README file for information on usage and redistribution. */
#include "Imaging.h"
int
ImagingRawEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingRawEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
UINT8 *ptr;
if (!state->state) {
/* The "count" field holds the stride, if specified. Fix
things up so "bytes" is the full size, and "count" the
packed size */
@ -55,7 +52,6 @@ ImagingRawEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
state->state = 1;
}
if (bytes < state->bytes) {
@ -66,9 +62,10 @@ ImagingRawEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
ptr = buf;
while (bytes >= state->bytes) {
state->shuffle(ptr, (UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->xsize);
state->shuffle(
ptr,
(UINT8 *)im->image[state->y + state->yoff] + state->xoff * im->pixelsize,
state->xsize);
if (state->bytes > state->count) {
/* zero-pad the buffer, if necessary */
@ -84,9 +81,7 @@ ImagingRawEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
state->errcode = IMAGING_CODEC_END;
break;
}
}
return ptr - buf;
}

615
src/libImaging/Reduce.c
View File

@ -4,19 +4,15 @@
#define ROUND_UP(f) ((int)((f) >= 0.0 ? (f) + 0.5F : (f)-0.5F))
UINT32
division_UINT32(int divider, int result_bits)
{
division_UINT32(int divider, int result_bits) {
UINT32 max_dividend = (1 << result_bits) * divider;
float max_int = (1 << 30) * 4.0;
return (UINT32)(max_int / max_dividend);
}
void
ImagingReduceNxN(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale)
{
ImagingReduceNxN(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale) {
/* The most general implementation for any xscale and yscale
*/
int x, y, xx, yy;
@ -33,8 +29,8 @@ ImagingReduceNxN(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale
UINT8 *line0 = (UINT8 *)imIn->image8[yy];
UINT8 *line1 = (UINT8 *)imIn->image8[yy + 1];
for (xx = xx_from; xx < xx_from + xscale - 1; xx += 2) {
ss += line0[xx + 0] + line0[xx + 1] +
line1[xx + 0] + line1[xx + 1];
ss += line0[xx + 0] + line0[xx + 1] + line1[xx + 0] +
line1[xx + 1];
}
if (xscale & 0x01) {
ss += line0[xx + 0] + line1[xx + 0];
@ -86,8 +82,7 @@ ImagingReduceNxN(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale
}
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, 0,
0, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24, 0, 0, (ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
@ -126,8 +121,10 @@ ImagingReduceNxN(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale
}
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, 0);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
@ -171,8 +168,10 @@ ImagingReduceNxN(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale
}
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
(ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -180,10 +179,8 @@ ImagingReduceNxN(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale
}
}
void
ImagingReduce1xN(Imaging imOut, Imaging imIn, int box[4], int yscale)
{
ImagingReduce1xN(Imaging imOut, Imaging imIn, int box[4], int yscale) {
/* Optimized implementation for xscale = 1.
*/
int x, y, yy;
@ -229,8 +226,7 @@ ImagingReduce1xN(Imaging imOut, Imaging imIn, int box[4], int yscale)
ss3 += line[xx * 4 + 3];
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, 0,
0, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24, 0, 0, (ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
@ -252,8 +248,10 @@ ImagingReduce1xN(Imaging imOut, Imaging imIn, int box[4], int yscale)
ss2 += line[xx * 4 + 2];
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, 0);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
@ -277,8 +275,10 @@ ImagingReduce1xN(Imaging imOut, Imaging imIn, int box[4], int yscale)
ss3 += line[xx * 4 + 3];
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
(ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -286,10 +286,8 @@ ImagingReduce1xN(Imaging imOut, Imaging imIn, int box[4], int yscale)
}
}
void
ImagingReduceNx1(Imaging imOut, Imaging imIn, int box[4], int xscale)
{
ImagingReduceNx1(Imaging imOut, Imaging imIn, int box[4], int xscale) {
/* Optimized implementation for yscale = 1.
*/
int x, y, xx;
@ -331,8 +329,7 @@ ImagingReduceNx1(Imaging imOut, Imaging imIn, int box[4], int xscale)
ss3 += line[xx * 4 + 3];
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, 0,
0, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24, 0, 0, (ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
@ -351,8 +348,10 @@ ImagingReduceNx1(Imaging imOut, Imaging imIn, int box[4], int xscale)
ss2 += line[xx * 4 + 2];
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, 0);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
@ -373,8 +372,10 @@ ImagingReduceNx1(Imaging imOut, Imaging imIn, int box[4], int xscale)
ss3 += line[xx * 4 + 3];
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
(ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -383,8 +384,7 @@ ImagingReduceNx1(Imaging imOut, Imaging imIn, int box[4], int xscale)
}
void
ImagingReduce1x2(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce1x2(Imaging imOut, Imaging imIn, int box[4]) {
/* Optimized implementation for xscale = 1 and yscale = 2.
*/
int xscale = 1, yscale = 2;
@ -399,8 +399,7 @@ ImagingReduce1x2(Imaging imOut, Imaging imIn, int box[4])
UINT8 *line1 = (UINT8 *)imIn->image8[yy + 1];
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
ss0 = line0[xx + 0] +
line1[xx + 0];
ss0 = line0[xx + 0] + line1[xx + 0];
imOut->image8[y][x] = (ss0 + amend) >> 1;
}
}
@ -413,42 +412,35 @@ ImagingReduce1x2(Imaging imOut, Imaging imIn, int box[4])
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] +
line1[xx*4 + 0];
ss3 = line0[xx*4 + 3] +
line1[xx*4 + 3];
v = MAKE_UINT32((ss0 + amend) >> 1, 0,
0, (ss3 + amend) >> 1);
ss0 = line0[xx * 4 + 0] + line1[xx * 4 + 0];
ss3 = line0[xx * 4 + 3] + line1[xx * 4 + 3];
v = MAKE_UINT32((ss0 + amend) >> 1, 0, 0, (ss3 + amend) >> 1);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] +
line1[xx*4 + 0];
ss1 = line0[xx*4 + 1] +
line1[xx*4 + 1];
ss2 = line0[xx*4 + 2] +
line1[xx*4 + 2];
v = MAKE_UINT32((ss0 + amend) >> 1, (ss1 + amend) >> 1,
(ss2 + amend) >> 1, 0);
ss0 = line0[xx * 4 + 0] + line1[xx * 4 + 0];
ss1 = line0[xx * 4 + 1] + line1[xx * 4 + 1];
ss2 = line0[xx * 4 + 2] + line1[xx * 4 + 2];
v = MAKE_UINT32(
(ss0 + amend) >> 1, (ss1 + amend) >> 1, (ss2 + amend) >> 1, 0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] +
line1[xx*4 + 0];
ss1 = line0[xx*4 + 1] +
line1[xx*4 + 1];
ss2 = line0[xx*4 + 2] +
line1[xx*4 + 2];
ss3 = line0[xx*4 + 3] +
line1[xx*4 + 3];
v = MAKE_UINT32((ss0 + amend) >> 1, (ss1 + amend) >> 1,
(ss2 + amend) >> 1, (ss3 + amend) >> 1);
ss0 = line0[xx * 4 + 0] + line1[xx * 4 + 0];
ss1 = line0[xx * 4 + 1] + line1[xx * 4 + 1];
ss2 = line0[xx * 4 + 2] + line1[xx * 4 + 2];
ss3 = line0[xx * 4 + 3] + line1[xx * 4 + 3];
v = MAKE_UINT32(
(ss0 + amend) >> 1,
(ss1 + amend) >> 1,
(ss2 + amend) >> 1,
(ss3 + amend) >> 1);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -456,10 +448,8 @@ ImagingReduce1x2(Imaging imOut, Imaging imIn, int box[4])
}
}
void
ImagingReduce2x1(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce2x1(Imaging imOut, Imaging imIn, int box[4]) {
/* Optimized implementation for xscale = 2 and yscale = 1.
*/
int xscale = 2, yscale = 1;
@ -487,8 +477,7 @@ ImagingReduce2x1(Imaging imOut, Imaging imIn, int box[4])
UINT32 v;
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7];
v = MAKE_UINT32((ss0 + amend) >> 1, 0,
0, (ss3 + amend) >> 1);
v = MAKE_UINT32((ss0 + amend) >> 1, 0, 0, (ss3 + amend) >> 1);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
@ -498,8 +487,8 @@ ImagingReduce2x1(Imaging imOut, Imaging imIn, int box[4])
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4];
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6];
v = MAKE_UINT32((ss0 + amend) >> 1, (ss1 + amend) >> 1,
(ss2 + amend) >> 1, 0);
v = MAKE_UINT32(
(ss0 + amend) >> 1, (ss1 + amend) >> 1, (ss2 + amend) >> 1, 0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
@ -510,8 +499,11 @@ ImagingReduce2x1(Imaging imOut, Imaging imIn, int box[4])
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7];
v = MAKE_UINT32((ss0 + amend) >> 1, (ss1 + amend) >> 1,
(ss2 + amend) >> 1, (ss3 + amend) >> 1);
v = MAKE_UINT32(
(ss0 + amend) >> 1,
(ss1 + amend) >> 1,
(ss2 + amend) >> 1,
(ss3 + amend) >> 1);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -519,10 +511,8 @@ ImagingReduce2x1(Imaging imOut, Imaging imIn, int box[4])
}
}
void
ImagingReduce2x2(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce2x2(Imaging imOut, Imaging imIn, int box[4]) {
/* Optimized implementation for xscale = 2 and yscale = 2.
*/
int xscale = 2, yscale = 2;
@ -537,8 +527,7 @@ ImagingReduce2x2(Imaging imOut, Imaging imIn, int box[4])
UINT8 *line1 = (UINT8 *)imIn->image8[yy + 1];
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
ss0 = line0[xx + 0] + line0[xx + 1] +
line1[xx + 0] + line1[xx + 1];
ss0 = line0[xx + 0] + line0[xx + 1] + line1[xx + 0] + line1[xx + 1];
imOut->image8[y][x] = (ss0 + amend) >> 2;
}
}
@ -551,42 +540,44 @@ ImagingReduce2x2(Imaging imOut, Imaging imIn, int box[4])
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] +
line1[xx*4 + 0] + line1[xx*4 + 4];
ss3 = line0[xx*4 + 3] + line0[xx*4 + 7] +
line1[xx*4 + 3] + line1[xx*4 + 7];
v = MAKE_UINT32((ss0 + amend) >> 2, 0,
0, (ss3 + amend) >> 2);
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line1[xx * 4 + 0] +
line1[xx * 4 + 4];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line1[xx * 4 + 3] +
line1[xx * 4 + 7];
v = MAKE_UINT32((ss0 + amend) >> 2, 0, 0, (ss3 + amend) >> 2);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] +
line1[xx*4 + 0] + line1[xx*4 + 4];
ss1 = line0[xx*4 + 1] + line0[xx*4 + 5] +
line1[xx*4 + 1] + line1[xx*4 + 5];
ss2 = line0[xx*4 + 2] + line0[xx*4 + 6] +
line1[xx*4 + 2] + line1[xx*4 + 6];
v = MAKE_UINT32((ss0 + amend) >> 2, (ss1 + amend) >> 2,
(ss2 + amend) >> 2, 0);
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line1[xx * 4 + 0] +
line1[xx * 4 + 4];
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5] + line1[xx * 4 + 1] +
line1[xx * 4 + 5];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line1[xx * 4 + 2] +
line1[xx * 4 + 6];
v = MAKE_UINT32(
(ss0 + amend) >> 2, (ss1 + amend) >> 2, (ss2 + amend) >> 2, 0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] +
line1[xx*4 + 0] + line1[xx*4 + 4];
ss1 = line0[xx*4 + 1] + line0[xx*4 + 5] +
line1[xx*4 + 1] + line1[xx*4 + 5];
ss2 = line0[xx*4 + 2] + line0[xx*4 + 6] +
line1[xx*4 + 2] + line1[xx*4 + 6];
ss3 = line0[xx*4 + 3] + line0[xx*4 + 7] +
line1[xx*4 + 3] + line1[xx*4 + 7];
v = MAKE_UINT32((ss0 + amend) >> 2, (ss1 + amend) >> 2,
(ss2 + amend) >> 2, (ss3 + amend) >> 2);
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line1[xx * 4 + 0] +
line1[xx * 4 + 4];
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5] + line1[xx * 4 + 1] +
line1[xx * 4 + 5];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line1[xx * 4 + 2] +
line1[xx * 4 + 6];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line1[xx * 4 + 3] +
line1[xx * 4 + 7];
v = MAKE_UINT32(
(ss0 + amend) >> 2,
(ss1 + amend) >> 2,
(ss2 + amend) >> 2,
(ss3 + amend) >> 2);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -594,10 +585,8 @@ ImagingReduce2x2(Imaging imOut, Imaging imIn, int box[4])
}
}
void
ImagingReduce1x3(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce1x3(Imaging imOut, Imaging imIn, int box[4]) {
/* Optimized implementation for xscale = 1 and yscale = 3.
*/
int xscale = 1, yscale = 3;
@ -614,9 +603,7 @@ ImagingReduce1x3(Imaging imOut, Imaging imIn, int box[4])
UINT8 *line2 = (UINT8 *)imIn->image8[yy + 2];
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
ss0 = line0[xx + 0] +
line1[xx + 0] +
line2[xx + 0];
ss0 = line0[xx + 0] + line1[xx + 0] + line2[xx + 0];
imOut->image8[y][x] = ((ss0 + amend) * multiplier) >> 24;
}
}
@ -630,54 +617,42 @@ ImagingReduce1x3(Imaging imOut, Imaging imIn, int box[4])
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] +
line1[xx*4 + 0] +
line2[xx*4 + 0];
ss3 = line0[xx*4 + 3] +
line1[xx*4 + 3] +
line2[xx*4 + 3];
ss0 = line0[xx * 4 + 0] + line1[xx * 4 + 0] + line2[xx * 4 + 0];
ss3 = line0[xx * 4 + 3] + line1[xx * 4 + 3] + line2[xx * 4 + 3];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, 0,
0, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
0,
0,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] +
line1[xx*4 + 0] +
line2[xx*4 + 0];
ss1 = line0[xx*4 + 1] +
line1[xx*4 + 1] +
line2[xx*4 + 1];
ss2 = line0[xx*4 + 2] +
line1[xx*4 + 2] +
line2[xx*4 + 2];
ss0 = line0[xx * 4 + 0] + line1[xx * 4 + 0] + line2[xx * 4 + 0];
ss1 = line0[xx * 4 + 1] + line1[xx * 4 + 1] + line2[xx * 4 + 1];
ss2 = line0[xx * 4 + 2] + line1[xx * 4 + 2] + line2[xx * 4 + 2];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, 0);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] +
line1[xx*4 + 0] +
line2[xx*4 + 0];
ss1 = line0[xx*4 + 1] +
line1[xx*4 + 1] +
line2[xx*4 + 1];
ss2 = line0[xx*4 + 2] +
line1[xx*4 + 2] +
line2[xx*4 + 2];
ss3 = line0[xx*4 + 3] +
line1[xx*4 + 3] +
line2[xx*4 + 3];
ss0 = line0[xx * 4 + 0] + line1[xx * 4 + 0] + line2[xx * 4 + 0];
ss1 = line0[xx * 4 + 1] + line1[xx * 4 + 1] + line2[xx * 4 + 1];
ss2 = line0[xx * 4 + 2] + line1[xx * 4 + 2] + line2[xx * 4 + 2];
ss3 = line0[xx * 4 + 3] + line1[xx * 4 + 3] + line2[xx * 4 + 3];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -685,10 +660,8 @@ ImagingReduce1x3(Imaging imOut, Imaging imIn, int box[4])
}
}
void
ImagingReduce3x1(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce3x1(Imaging imOut, Imaging imIn, int box[4]) {
/* Optimized implementation for xscale = 3 and yscale = 1.
*/
int xscale = 3, yscale = 1;
@ -718,8 +691,10 @@ ImagingReduce3x1(Imaging imOut, Imaging imIn, int box[4])
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line0[xx * 4 + 8];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line0[xx * 4 + 11];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, 0,
0, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
0,
0,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
@ -730,8 +705,10 @@ ImagingReduce3x1(Imaging imOut, Imaging imIn, int box[4])
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5] + line0[xx * 4 + 9];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line0[xx * 4 + 10];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, 0);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
@ -743,8 +720,10 @@ ImagingReduce3x1(Imaging imOut, Imaging imIn, int box[4])
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line0[xx * 4 + 10];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line0[xx * 4 + 11];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -752,10 +731,8 @@ ImagingReduce3x1(Imaging imOut, Imaging imIn, int box[4])
}
}
void
ImagingReduce3x3(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce3x3(Imaging imOut, Imaging imIn, int box[4]) {
/* Optimized implementation for xscale = 3 and yscale = 3.
*/
int xscale = 3, yscale = 3;
@ -772,9 +749,9 @@ ImagingReduce3x3(Imaging imOut, Imaging imIn, int box[4])
UINT8 *line2 = (UINT8 *)imIn->image8[yy + 2];
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
ss0 = line0[xx + 0] + line0[xx + 1] + line0[xx + 2] +
line1[xx + 0] + line1[xx + 1] + line1[xx + 2] +
line2[xx + 0] + line2[xx + 1] + line2[xx + 2];
ss0 = line0[xx + 0] + line0[xx + 1] + line0[xx + 2] + line1[xx + 0] +
line1[xx + 1] + line1[xx + 2] + line2[xx + 0] + line2[xx + 1] +
line2[xx + 2];
imOut->image8[y][x] = ((ss0 + amend) * multiplier) >> 24;
}
}
@ -795,8 +772,10 @@ ImagingReduce3x3(Imaging imOut, Imaging imIn, int box[4])
line1[xx * 4 + 3] + line1[xx * 4 + 7] + line1[xx * 4 + 11] +
line2[xx * 4 + 3] + line2[xx * 4 + 7] + line2[xx * 4 + 11];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, 0,
0, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
0,
0,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
@ -813,8 +792,10 @@ ImagingReduce3x3(Imaging imOut, Imaging imIn, int box[4])
line1[xx * 4 + 2] + line1[xx * 4 + 6] + line1[xx * 4 + 10] +
line2[xx * 4 + 2] + line2[xx * 4 + 6] + line2[xx * 4 + 10];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, 0);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
@ -834,8 +815,10 @@ ImagingReduce3x3(Imaging imOut, Imaging imIn, int box[4])
line1[xx * 4 + 3] + line1[xx * 4 + 7] + line1[xx * 4 + 11] +
line2[xx * 4 + 3] + line2[xx * 4 + 7] + line2[xx * 4 + 11];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -844,8 +827,7 @@ ImagingReduce3x3(Imaging imOut, Imaging imIn, int box[4])
}
void
ImagingReduce4x4(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce4x4(Imaging imOut, Imaging imIn, int box[4]) {
/* Optimized implementation for xscale = 4 and yscale = 4.
*/
int xscale = 4, yscale = 4;
@ -880,60 +862,80 @@ ImagingReduce4x4(Imaging imOut, Imaging imIn, int box[4])
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] + line0[xx*4 + 8] + line0[xx*4 + 12] +
line1[xx*4 + 0] + line1[xx*4 + 4] + line1[xx*4 + 8] + line1[xx*4 + 12] +
line2[xx*4 + 0] + line2[xx*4 + 4] + line2[xx*4 + 8] + line2[xx*4 + 12] +
line3[xx*4 + 0] + line3[xx*4 + 4] + line3[xx*4 + 8] + line3[xx*4 + 12];
ss3 = line0[xx*4 + 3] + line0[xx*4 + 7] + line0[xx*4 + 11] + line0[xx*4 + 15] +
line1[xx*4 + 3] + line1[xx*4 + 7] + line1[xx*4 + 11] + line1[xx*4 + 15] +
line2[xx*4 + 3] + line2[xx*4 + 7] + line2[xx*4 + 11] + line2[xx*4 + 15] +
line3[xx*4 + 3] + line3[xx*4 + 7] + line3[xx*4 + 11] + line3[xx*4 + 15];
v = MAKE_UINT32((ss0 + amend) >> 4, 0,
0, (ss3 + amend) >> 4);
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line0[xx * 4 + 8] +
line0[xx * 4 + 12] + line1[xx * 4 + 0] + line1[xx * 4 + 4] +
line1[xx * 4 + 8] + line1[xx * 4 + 12] + line2[xx * 4 + 0] +
line2[xx * 4 + 4] + line2[xx * 4 + 8] + line2[xx * 4 + 12] +
line3[xx * 4 + 0] + line3[xx * 4 + 4] + line3[xx * 4 + 8] +
line3[xx * 4 + 12];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line0[xx * 4 + 11] +
line0[xx * 4 + 15] + line1[xx * 4 + 3] + line1[xx * 4 + 7] +
line1[xx * 4 + 11] + line1[xx * 4 + 15] + line2[xx * 4 + 3] +
line2[xx * 4 + 7] + line2[xx * 4 + 11] + line2[xx * 4 + 15] +
line3[xx * 4 + 3] + line3[xx * 4 + 7] + line3[xx * 4 + 11] +
line3[xx * 4 + 15];
v = MAKE_UINT32((ss0 + amend) >> 4, 0, 0, (ss3 + amend) >> 4);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] + line0[xx*4 + 8] + line0[xx*4 + 12] +
line1[xx*4 + 0] + line1[xx*4 + 4] + line1[xx*4 + 8] + line1[xx*4 + 12] +
line2[xx*4 + 0] + line2[xx*4 + 4] + line2[xx*4 + 8] + line2[xx*4 + 12] +
line3[xx*4 + 0] + line3[xx*4 + 4] + line3[xx*4 + 8] + line3[xx*4 + 12];
ss1 = line0[xx*4 + 1] + line0[xx*4 + 5] + line0[xx*4 + 9] + line0[xx*4 + 13] +
line1[xx*4 + 1] + line1[xx*4 + 5] + line1[xx*4 + 9] + line1[xx*4 + 13] +
line2[xx*4 + 1] + line2[xx*4 + 5] + line2[xx*4 + 9] + line2[xx*4 + 13] +
line3[xx*4 + 1] + line3[xx*4 + 5] + line3[xx*4 + 9] + line3[xx*4 + 13];
ss2 = line0[xx*4 + 2] + line0[xx*4 + 6] + line0[xx*4 + 10] + line0[xx*4 + 14] +
line1[xx*4 + 2] + line1[xx*4 + 6] + line1[xx*4 + 10] + line1[xx*4 + 14] +
line2[xx*4 + 2] + line2[xx*4 + 6] + line2[xx*4 + 10] + line2[xx*4 + 14] +
line3[xx*4 + 2] + line3[xx*4 + 6] + line3[xx*4 + 10] + line3[xx*4 + 14];
v = MAKE_UINT32((ss0 + amend) >> 4, (ss1 + amend) >> 4,
(ss2 + amend) >> 4, 0);
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line0[xx * 4 + 8] +
line0[xx * 4 + 12] + line1[xx * 4 + 0] + line1[xx * 4 + 4] +
line1[xx * 4 + 8] + line1[xx * 4 + 12] + line2[xx * 4 + 0] +
line2[xx * 4 + 4] + line2[xx * 4 + 8] + line2[xx * 4 + 12] +
line3[xx * 4 + 0] + line3[xx * 4 + 4] + line3[xx * 4 + 8] +
line3[xx * 4 + 12];
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5] + line0[xx * 4 + 9] +
line0[xx * 4 + 13] + line1[xx * 4 + 1] + line1[xx * 4 + 5] +
line1[xx * 4 + 9] + line1[xx * 4 + 13] + line2[xx * 4 + 1] +
line2[xx * 4 + 5] + line2[xx * 4 + 9] + line2[xx * 4 + 13] +
line3[xx * 4 + 1] + line3[xx * 4 + 5] + line3[xx * 4 + 9] +
line3[xx * 4 + 13];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line0[xx * 4 + 10] +
line0[xx * 4 + 14] + line1[xx * 4 + 2] + line1[xx * 4 + 6] +
line1[xx * 4 + 10] + line1[xx * 4 + 14] + line2[xx * 4 + 2] +
line2[xx * 4 + 6] + line2[xx * 4 + 10] + line2[xx * 4 + 14] +
line3[xx * 4 + 2] + line3[xx * 4 + 6] + line3[xx * 4 + 10] +
line3[xx * 4 + 14];
v = MAKE_UINT32(
(ss0 + amend) >> 4, (ss1 + amend) >> 4, (ss2 + amend) >> 4, 0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] + line0[xx*4 + 8] + line0[xx*4 + 12] +
line1[xx*4 + 0] + line1[xx*4 + 4] + line1[xx*4 + 8] + line1[xx*4 + 12] +
line2[xx*4 + 0] + line2[xx*4 + 4] + line2[xx*4 + 8] + line2[xx*4 + 12] +
line3[xx*4 + 0] + line3[xx*4 + 4] + line3[xx*4 + 8] + line3[xx*4 + 12];
ss1 = line0[xx*4 + 1] + line0[xx*4 + 5] + line0[xx*4 + 9] + line0[xx*4 + 13] +
line1[xx*4 + 1] + line1[xx*4 + 5] + line1[xx*4 + 9] + line1[xx*4 + 13] +
line2[xx*4 + 1] + line2[xx*4 + 5] + line2[xx*4 + 9] + line2[xx*4 + 13] +
line3[xx*4 + 1] + line3[xx*4 + 5] + line3[xx*4 + 9] + line3[xx*4 + 13];
ss2 = line0[xx*4 + 2] + line0[xx*4 + 6] + line0[xx*4 + 10] + line0[xx*4 + 14] +
line1[xx*4 + 2] + line1[xx*4 + 6] + line1[xx*4 + 10] + line1[xx*4 + 14] +
line2[xx*4 + 2] + line2[xx*4 + 6] + line2[xx*4 + 10] + line2[xx*4 + 14] +
line3[xx*4 + 2] + line3[xx*4 + 6] + line3[xx*4 + 10] + line3[xx*4 + 14];
ss3 = line0[xx*4 + 3] + line0[xx*4 + 7] + line0[xx*4 + 11] + line0[xx*4 + 15] +
line1[xx*4 + 3] + line1[xx*4 + 7] + line1[xx*4 + 11] + line1[xx*4 + 15] +
line2[xx*4 + 3] + line2[xx*4 + 7] + line2[xx*4 + 11] + line2[xx*4 + 15] +
line3[xx*4 + 3] + line3[xx*4 + 7] + line3[xx*4 + 11] + line3[xx*4 + 15];
v = MAKE_UINT32((ss0 + amend) >> 4, (ss1 + amend) >> 4,
(ss2 + amend) >> 4, (ss3 + amend) >> 4);
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line0[xx * 4 + 8] +
line0[xx * 4 + 12] + line1[xx * 4 + 0] + line1[xx * 4 + 4] +
line1[xx * 4 + 8] + line1[xx * 4 + 12] + line2[xx * 4 + 0] +
line2[xx * 4 + 4] + line2[xx * 4 + 8] + line2[xx * 4 + 12] +
line3[xx * 4 + 0] + line3[xx * 4 + 4] + line3[xx * 4 + 8] +
line3[xx * 4 + 12];
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5] + line0[xx * 4 + 9] +
line0[xx * 4 + 13] + line1[xx * 4 + 1] + line1[xx * 4 + 5] +
line1[xx * 4 + 9] + line1[xx * 4 + 13] + line2[xx * 4 + 1] +
line2[xx * 4 + 5] + line2[xx * 4 + 9] + line2[xx * 4 + 13] +
line3[xx * 4 + 1] + line3[xx * 4 + 5] + line3[xx * 4 + 9] +
line3[xx * 4 + 13];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line0[xx * 4 + 10] +
line0[xx * 4 + 14] + line1[xx * 4 + 2] + line1[xx * 4 + 6] +
line1[xx * 4 + 10] + line1[xx * 4 + 14] + line2[xx * 4 + 2] +
line2[xx * 4 + 6] + line2[xx * 4 + 10] + line2[xx * 4 + 14] +
line3[xx * 4 + 2] + line3[xx * 4 + 6] + line3[xx * 4 + 10] +
line3[xx * 4 + 14];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line0[xx * 4 + 11] +
line0[xx * 4 + 15] + line1[xx * 4 + 3] + line1[xx * 4 + 7] +
line1[xx * 4 + 11] + line1[xx * 4 + 15] + line2[xx * 4 + 3] +
line2[xx * 4 + 7] + line2[xx * 4 + 11] + line2[xx * 4 + 15] +
line3[xx * 4 + 3] + line3[xx * 4 + 7] + line3[xx * 4 + 11] +
line3[xx * 4 + 15];
v = MAKE_UINT32(
(ss0 + amend) >> 4,
(ss1 + amend) >> 4,
(ss2 + amend) >> 4,
(ss3 + amend) >> 4);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -941,10 +943,8 @@ ImagingReduce4x4(Imaging imOut, Imaging imIn, int box[4])
}
}
void
ImagingReduce5x5(Imaging imOut, Imaging imIn, int box[4])
{
ImagingReduce5x5(Imaging imOut, Imaging imIn, int box[4]) {
/* Fast special case for xscale = 5 and yscale = 5.
*/
int xscale = 5, yscale = 5;
@ -963,11 +963,13 @@ ImagingReduce5x5(Imaging imOut, Imaging imIn, int box[4])
UINT8 *line4 = (UINT8 *)imIn->image8[yy + 4];
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
ss0 = line0[xx + 0] + line0[xx + 1] + line0[xx + 2] + line0[xx + 3] + line0[xx + 4] +
line1[xx + 0] + line1[xx + 1] + line1[xx + 2] + line1[xx + 3] + line1[xx + 4] +
line2[xx + 0] + line2[xx + 1] + line2[xx + 2] + line2[xx + 3] + line2[xx + 4] +
line3[xx + 0] + line3[xx + 1] + line3[xx + 2] + line3[xx + 3] + line3[xx + 4] +
line4[xx + 0] + line4[xx + 1] + line4[xx + 2] + line4[xx + 3] + line4[xx + 4];
ss0 = line0[xx + 0] + line0[xx + 1] + line0[xx + 2] + line0[xx + 3] +
line0[xx + 4] + line1[xx + 0] + line1[xx + 1] + line1[xx + 2] +
line1[xx + 3] + line1[xx + 4] + line2[xx + 0] + line2[xx + 1] +
line2[xx + 2] + line2[xx + 3] + line2[xx + 4] + line3[xx + 0] +
line3[xx + 1] + line3[xx + 2] + line3[xx + 3] + line3[xx + 4] +
line4[xx + 0] + line4[xx + 1] + line4[xx + 2] + line4[xx + 3] +
line4[xx + 4];
imOut->image8[y][x] = ((ss0 + amend) * multiplier) >> 24;
}
}
@ -983,72 +985,114 @@ ImagingReduce5x5(Imaging imOut, Imaging imIn, int box[4])
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] + line0[xx*4 + 8] + line0[xx*4 + 12] + line0[xx*4 + 16] +
line1[xx*4 + 0] + line1[xx*4 + 4] + line1[xx*4 + 8] + line1[xx*4 + 12] + line1[xx*4 + 16] +
line2[xx*4 + 0] + line2[xx*4 + 4] + line2[xx*4 + 8] + line2[xx*4 + 12] + line2[xx*4 + 16] +
line3[xx*4 + 0] + line3[xx*4 + 4] + line3[xx*4 + 8] + line3[xx*4 + 12] + line3[xx*4 + 16] +
line4[xx*4 + 0] + line4[xx*4 + 4] + line4[xx*4 + 8] + line4[xx*4 + 12] + line4[xx*4 + 16];
ss3 = line0[xx*4 + 3] + line0[xx*4 + 7] + line0[xx*4 + 11] + line0[xx*4 + 15] + line0[xx*4 + 19] +
line1[xx*4 + 3] + line1[xx*4 + 7] + line1[xx*4 + 11] + line1[xx*4 + 15] + line1[xx*4 + 19] +
line2[xx*4 + 3] + line2[xx*4 + 7] + line2[xx*4 + 11] + line2[xx*4 + 15] + line2[xx*4 + 19] +
line3[xx*4 + 3] + line3[xx*4 + 7] + line3[xx*4 + 11] + line3[xx*4 + 15] + line3[xx*4 + 19] +
line4[xx*4 + 3] + line4[xx*4 + 7] + line4[xx*4 + 11] + line4[xx*4 + 15] + line4[xx*4 + 19];
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line0[xx * 4 + 8] +
line0[xx * 4 + 12] + line0[xx * 4 + 16] + line1[xx * 4 + 0] +
line1[xx * 4 + 4] + line1[xx * 4 + 8] + line1[xx * 4 + 12] +
line1[xx * 4 + 16] + line2[xx * 4 + 0] + line2[xx * 4 + 4] +
line2[xx * 4 + 8] + line2[xx * 4 + 12] + line2[xx * 4 + 16] +
line3[xx * 4 + 0] + line3[xx * 4 + 4] + line3[xx * 4 + 8] +
line3[xx * 4 + 12] + line3[xx * 4 + 16] + line4[xx * 4 + 0] +
line4[xx * 4 + 4] + line4[xx * 4 + 8] + line4[xx * 4 + 12] +
line4[xx * 4 + 16];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line0[xx * 4 + 11] +
line0[xx * 4 + 15] + line0[xx * 4 + 19] + line1[xx * 4 + 3] +
line1[xx * 4 + 7] + line1[xx * 4 + 11] + line1[xx * 4 + 15] +
line1[xx * 4 + 19] + line2[xx * 4 + 3] + line2[xx * 4 + 7] +
line2[xx * 4 + 11] + line2[xx * 4 + 15] + line2[xx * 4 + 19] +
line3[xx * 4 + 3] + line3[xx * 4 + 7] + line3[xx * 4 + 11] +
line3[xx * 4 + 15] + line3[xx * 4 + 19] + line4[xx * 4 + 3] +
line4[xx * 4 + 7] + line4[xx * 4 + 11] + line4[xx * 4 + 15] +
line4[xx * 4 + 19];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, 0,
0, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
0,
0,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else if (imIn->bands == 3) {
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] + line0[xx*4 + 8] + line0[xx*4 + 12] + line0[xx*4 + 16] +
line1[xx*4 + 0] + line1[xx*4 + 4] + line1[xx*4 + 8] + line1[xx*4 + 12] + line1[xx*4 + 16] +
line2[xx*4 + 0] + line2[xx*4 + 4] + line2[xx*4 + 8] + line2[xx*4 + 12] + line2[xx*4 + 16] +
line3[xx*4 + 0] + line3[xx*4 + 4] + line3[xx*4 + 8] + line3[xx*4 + 12] + line3[xx*4 + 16] +
line4[xx*4 + 0] + line4[xx*4 + 4] + line4[xx*4 + 8] + line4[xx*4 + 12] + line4[xx*4 + 16];
ss1 = line0[xx*4 + 1] + line0[xx*4 + 5] + line0[xx*4 + 9] + line0[xx*4 + 13] + line0[xx*4 + 17] +
line1[xx*4 + 1] + line1[xx*4 + 5] + line1[xx*4 + 9] + line1[xx*4 + 13] + line1[xx*4 + 17] +
line2[xx*4 + 1] + line2[xx*4 + 5] + line2[xx*4 + 9] + line2[xx*4 + 13] + line2[xx*4 + 17] +
line3[xx*4 + 1] + line3[xx*4 + 5] + line3[xx*4 + 9] + line3[xx*4 + 13] + line3[xx*4 + 17] +
line4[xx*4 + 1] + line4[xx*4 + 5] + line4[xx*4 + 9] + line4[xx*4 + 13] + line4[xx*4 + 17];
ss2 = line0[xx*4 + 2] + line0[xx*4 + 6] + line0[xx*4 + 10] + line0[xx*4 + 14] + line0[xx*4 + 18] +
line1[xx*4 + 2] + line1[xx*4 + 6] + line1[xx*4 + 10] + line1[xx*4 + 14] + line1[xx*4 + 18] +
line2[xx*4 + 2] + line2[xx*4 + 6] + line2[xx*4 + 10] + line2[xx*4 + 14] + line2[xx*4 + 18] +
line3[xx*4 + 2] + line3[xx*4 + 6] + line3[xx*4 + 10] + line3[xx*4 + 14] + line3[xx*4 + 18] +
line4[xx*4 + 2] + line4[xx*4 + 6] + line4[xx*4 + 10] + line4[xx*4 + 14] + line4[xx*4 + 18];
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line0[xx * 4 + 8] +
line0[xx * 4 + 12] + line0[xx * 4 + 16] + line1[xx * 4 + 0] +
line1[xx * 4 + 4] + line1[xx * 4 + 8] + line1[xx * 4 + 12] +
line1[xx * 4 + 16] + line2[xx * 4 + 0] + line2[xx * 4 + 4] +
line2[xx * 4 + 8] + line2[xx * 4 + 12] + line2[xx * 4 + 16] +
line3[xx * 4 + 0] + line3[xx * 4 + 4] + line3[xx * 4 + 8] +
line3[xx * 4 + 12] + line3[xx * 4 + 16] + line4[xx * 4 + 0] +
line4[xx * 4 + 4] + line4[xx * 4 + 8] + line4[xx * 4 + 12] +
line4[xx * 4 + 16];
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5] + line0[xx * 4 + 9] +
line0[xx * 4 + 13] + line0[xx * 4 + 17] + line1[xx * 4 + 1] +
line1[xx * 4 + 5] + line1[xx * 4 + 9] + line1[xx * 4 + 13] +
line1[xx * 4 + 17] + line2[xx * 4 + 1] + line2[xx * 4 + 5] +
line2[xx * 4 + 9] + line2[xx * 4 + 13] + line2[xx * 4 + 17] +
line3[xx * 4 + 1] + line3[xx * 4 + 5] + line3[xx * 4 + 9] +
line3[xx * 4 + 13] + line3[xx * 4 + 17] + line4[xx * 4 + 1] +
line4[xx * 4 + 5] + line4[xx * 4 + 9] + line4[xx * 4 + 13] +
line4[xx * 4 + 17];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line0[xx * 4 + 10] +
line0[xx * 4 + 14] + line0[xx * 4 + 18] + line1[xx * 4 + 2] +
line1[xx * 4 + 6] + line1[xx * 4 + 10] + line1[xx * 4 + 14] +
line1[xx * 4 + 18] + line2[xx * 4 + 2] + line2[xx * 4 + 6] +
line2[xx * 4 + 10] + line2[xx * 4 + 14] + line2[xx * 4 + 18] +
line3[xx * 4 + 2] + line3[xx * 4 + 6] + line3[xx * 4 + 10] +
line3[xx * 4 + 14] + line3[xx * 4 + 18] + line4[xx * 4 + 2] +
line4[xx * 4 + 6] + line4[xx * 4 + 10] + line4[xx * 4 + 14] +
line4[xx * 4 + 18];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, 0);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
0);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
} else { // bands == 4
for (x = 0; x < box[2] / xscale; x++) {
int xx = box[0] + x * xscale;
UINT32 v;
ss0 = line0[xx*4 + 0] + line0[xx*4 + 4] + line0[xx*4 + 8] + line0[xx*4 + 12] + line0[xx*4 + 16] +
line1[xx*4 + 0] + line1[xx*4 + 4] + line1[xx*4 + 8] + line1[xx*4 + 12] + line1[xx*4 + 16] +
line2[xx*4 + 0] + line2[xx*4 + 4] + line2[xx*4 + 8] + line2[xx*4 + 12] + line2[xx*4 + 16] +
line3[xx*4 + 0] + line3[xx*4 + 4] + line3[xx*4 + 8] + line3[xx*4 + 12] + line3[xx*4 + 16] +
line4[xx*4 + 0] + line4[xx*4 + 4] + line4[xx*4 + 8] + line4[xx*4 + 12] + line4[xx*4 + 16];
ss1 = line0[xx*4 + 1] + line0[xx*4 + 5] + line0[xx*4 + 9] + line0[xx*4 + 13] + line0[xx*4 + 17] +
line1[xx*4 + 1] + line1[xx*4 + 5] + line1[xx*4 + 9] + line1[xx*4 + 13] + line1[xx*4 + 17] +
line2[xx*4 + 1] + line2[xx*4 + 5] + line2[xx*4 + 9] + line2[xx*4 + 13] + line2[xx*4 + 17] +
line3[xx*4 + 1] + line3[xx*4 + 5] + line3[xx*4 + 9] + line3[xx*4 + 13] + line3[xx*4 + 17] +
line4[xx*4 + 1] + line4[xx*4 + 5] + line4[xx*4 + 9] + line4[xx*4 + 13] + line4[xx*4 + 17];
ss2 = line0[xx*4 + 2] + line0[xx*4 + 6] + line0[xx*4 + 10] + line0[xx*4 + 14] + line0[xx*4 + 18] +
line1[xx*4 + 2] + line1[xx*4 + 6] + line1[xx*4 + 10] + line1[xx*4 + 14] + line1[xx*4 + 18] +
line2[xx*4 + 2] + line2[xx*4 + 6] + line2[xx*4 + 10] + line2[xx*4 + 14] + line2[xx*4 + 18] +
line3[xx*4 + 2] + line3[xx*4 + 6] + line3[xx*4 + 10] + line3[xx*4 + 14] + line3[xx*4 + 18] +
line4[xx*4 + 2] + line4[xx*4 + 6] + line4[xx*4 + 10] + line4[xx*4 + 14] + line4[xx*4 + 18];
ss3 = line0[xx*4 + 3] + line0[xx*4 + 7] + line0[xx*4 + 11] + line0[xx*4 + 15] + line0[xx*4 + 19] +
line1[xx*4 + 3] + line1[xx*4 + 7] + line1[xx*4 + 11] + line1[xx*4 + 15] + line1[xx*4 + 19] +
line2[xx*4 + 3] + line2[xx*4 + 7] + line2[xx*4 + 11] + line2[xx*4 + 15] + line2[xx*4 + 19] +
line3[xx*4 + 3] + line3[xx*4 + 7] + line3[xx*4 + 11] + line3[xx*4 + 15] + line3[xx*4 + 19] +
line4[xx*4 + 3] + line4[xx*4 + 7] + line4[xx*4 + 11] + line4[xx*4 + 15] + line4[xx*4 + 19];
ss0 = line0[xx * 4 + 0] + line0[xx * 4 + 4] + line0[xx * 4 + 8] +
line0[xx * 4 + 12] + line0[xx * 4 + 16] + line1[xx * 4 + 0] +
line1[xx * 4 + 4] + line1[xx * 4 + 8] + line1[xx * 4 + 12] +
line1[xx * 4 + 16] + line2[xx * 4 + 0] + line2[xx * 4 + 4] +
line2[xx * 4 + 8] + line2[xx * 4 + 12] + line2[xx * 4 + 16] +
line3[xx * 4 + 0] + line3[xx * 4 + 4] + line3[xx * 4 + 8] +
line3[xx * 4 + 12] + line3[xx * 4 + 16] + line4[xx * 4 + 0] +
line4[xx * 4 + 4] + line4[xx * 4 + 8] + line4[xx * 4 + 12] +
line4[xx * 4 + 16];
ss1 = line0[xx * 4 + 1] + line0[xx * 4 + 5] + line0[xx * 4 + 9] +
line0[xx * 4 + 13] + line0[xx * 4 + 17] + line1[xx * 4 + 1] +
line1[xx * 4 + 5] + line1[xx * 4 + 9] + line1[xx * 4 + 13] +
line1[xx * 4 + 17] + line2[xx * 4 + 1] + line2[xx * 4 + 5] +
line2[xx * 4 + 9] + line2[xx * 4 + 13] + line2[xx * 4 + 17] +
line3[xx * 4 + 1] + line3[xx * 4 + 5] + line3[xx * 4 + 9] +
line3[xx * 4 + 13] + line3[xx * 4 + 17] + line4[xx * 4 + 1] +
line4[xx * 4 + 5] + line4[xx * 4 + 9] + line4[xx * 4 + 13] +
line4[xx * 4 + 17];
ss2 = line0[xx * 4 + 2] + line0[xx * 4 + 6] + line0[xx * 4 + 10] +
line0[xx * 4 + 14] + line0[xx * 4 + 18] + line1[xx * 4 + 2] +
line1[xx * 4 + 6] + line1[xx * 4 + 10] + line1[xx * 4 + 14] +
line1[xx * 4 + 18] + line2[xx * 4 + 2] + line2[xx * 4 + 6] +
line2[xx * 4 + 10] + line2[xx * 4 + 14] + line2[xx * 4 + 18] +
line3[xx * 4 + 2] + line3[xx * 4 + 6] + line3[xx * 4 + 10] +
line3[xx * 4 + 14] + line3[xx * 4 + 18] + line4[xx * 4 + 2] +
line4[xx * 4 + 6] + line4[xx * 4 + 10] + line4[xx * 4 + 14] +
line4[xx * 4 + 18];
ss3 = line0[xx * 4 + 3] + line0[xx * 4 + 7] + line0[xx * 4 + 11] +
line0[xx * 4 + 15] + line0[xx * 4 + 19] + line1[xx * 4 + 3] +
line1[xx * 4 + 7] + line1[xx * 4 + 11] + line1[xx * 4 + 15] +
line1[xx * 4 + 19] + line2[xx * 4 + 3] + line2[xx * 4 + 7] +
line2[xx * 4 + 11] + line2[xx * 4 + 15] + line2[xx * 4 + 19] +
line3[xx * 4 + 3] + line3[xx * 4 + 7] + line3[xx * 4 + 11] +
line3[xx * 4 + 15] + line3[xx * 4 + 19] + line4[xx * 4 + 3] +
line4[xx * 4 + 7] + line4[xx * 4 + 11] + line4[xx * 4 + 15] +
line4[xx * 4 + 19];
v = MAKE_UINT32(
((ss0 + amend) * multiplier) >> 24, ((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24, ((ss3 + amend) * multiplier) >> 24);
((ss0 + amend) * multiplier) >> 24,
((ss1 + amend) * multiplier) >> 24,
((ss2 + amend) * multiplier) >> 24,
((ss3 + amend) * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -1056,10 +1100,8 @@ ImagingReduce5x5(Imaging imOut, Imaging imIn, int box[4])
}
}
void
ImagingReduceCorners(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale)
{
ImagingReduceCorners(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale) {
/* Fill the last row and the last column for any xscale and yscale.
*/
int x, y, xx, yy;
@ -1136,8 +1178,10 @@ ImagingReduceCorners(Imaging imOut, Imaging imIn, int box[4], int xscale, int ys
}
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
(ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -1160,8 +1204,10 @@ ImagingReduceCorners(Imaging imOut, Imaging imIn, int box[4], int xscale, int ys
}
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
(ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
@ -1183,17 +1229,18 @@ ImagingReduceCorners(Imaging imOut, Imaging imIn, int box[4], int xscale, int ys
}
}
v = MAKE_UINT32(
(ss0 * multiplier) >> 24, (ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24, (ss3 * multiplier) >> 24);
(ss0 * multiplier) >> 24,
(ss1 * multiplier) >> 24,
(ss2 * multiplier) >> 24,
(ss3 * multiplier) >> 24);
memcpy(imOut->image[y] + x * sizeof(v), &v, sizeof(v));
}
}
}
void
ImagingReduceNxN_32bpc(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale)
{
ImagingReduceNxN_32bpc(
Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale) {
/* The most general implementation for any xscale and yscale
*/
int x, y, xx, yy;
@ -1210,8 +1257,8 @@ ImagingReduceNxN_32bpc(Imaging imOut, Imaging imIn, int box[4], int xscale, int
INT32 *line0 = (INT32 *)imIn->image32[yy];
INT32 *line1 = (INT32 *)imIn->image32[yy + 1];
for (xx = xx_from; xx < xx_from + xscale - 1; xx += 2) {
ss += line0[xx + 0] + line0[xx + 1] +
line1[xx + 0] + line1[xx + 1];
ss += line0[xx + 0] + line0[xx + 1] + line1[xx + 0] +
line1[xx + 1];
}
if (xscale & 0x01) {
ss += line0[xx + 0] + line1[xx + 0];
@ -1241,8 +1288,8 @@ ImagingReduceNxN_32bpc(Imaging imOut, Imaging imIn, int box[4], int xscale, int
FLOAT32 *line0 = (FLOAT32 *)imIn->image32[yy];
FLOAT32 *line1 = (FLOAT32 *)imIn->image32[yy + 1];
for (xx = xx_from; xx < xx_from + xscale - 1; xx += 2) {
ss += line0[xx + 0] + line0[xx + 1] +
line1[xx + 0] + line1[xx + 1];
ss += line0[xx + 0] + line0[xx + 1] + line1[xx + 0] +
line1[xx + 1];
}
if (xscale & 0x01) {
ss += line0[xx + 0] + line1[xx + 0];
@ -1264,10 +1311,9 @@ ImagingReduceNxN_32bpc(Imaging imOut, Imaging imIn, int box[4], int xscale, int
}
}
void
ImagingReduceCorners_32bpc(Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale)
{
ImagingReduceCorners_32bpc(
Imaging imOut, Imaging imIn, int box[4], int xscale, int yscale) {
/* Fill the last row and the last column for any xscale and yscale.
*/
int x, y, xx, yy;
@ -1367,10 +1413,8 @@ ImagingReduceCorners_32bpc(Imaging imOut, Imaging imIn, int box[4], int xscale,
}
}
Imaging
ImagingReduce(Imaging imIn, int xscale, int yscale, int box[4])
{
ImagingReduce(Imaging imIn, int xscale, int yscale, int box[4]) {
ImagingSectionCookie cookie;
Imaging imOut = NULL;
@ -1382,9 +1426,8 @@ ImagingReduce(Imaging imIn, int xscale, int yscale, int box[4])
return (Imaging)ImagingError_ModeError();
}
imOut = ImagingNewDirty(imIn->mode,
(box[2] + xscale - 1) / xscale,
(box[3] + yscale - 1) / yscale);
imOut = ImagingNewDirty(
imIn->mode, (box[2] + xscale - 1) / xscale, (box[3] + yscale - 1) / yscale);
if (!imOut) {
return NULL;
}

312
src/libImaging/Resample.c
View File

@ -2,25 +2,23 @@
#include <math.h>
#define ROUND_UP(f) ((int)((f) >= 0.0 ? (f) + 0.5F : (f)-0.5F))
struct filter {
double (*filter)(double x);
double support;
};
static inline double box_filter(double x)
{
static inline double
box_filter(double x) {
if (x > -0.5 && x <= 0.5) {
return 1.0;
}
return 0.0;
}
static inline double bilinear_filter(double x)
{
static inline double
bilinear_filter(double x) {
if (x < 0.0) {
x = -x;
}
@ -30,8 +28,8 @@ static inline double bilinear_filter(double x)
return 0.0;
}
static inline double hamming_filter(double x)
{
static inline double
hamming_filter(double x) {
if (x < 0.0) {
x = -x;
}
@ -45,9 +43,10 @@ static inline double hamming_filter(double x)
return sin(x) / x * (0.54f + 0.46f * cos(x));
}
static inline double bicubic_filter(double x)
{
/* https://en.wikipedia.org/wiki/Bicubic_interpolation#Bicubic_convolution_algorithm */
static inline double
bicubic_filter(double x) {
/* https://en.wikipedia.org/wiki/Bicubic_interpolation#Bicubic_convolution_algorithm
*/
#define a -0.5
if (x < 0.0) {
x = -x;
@ -62,8 +61,8 @@ static inline double bicubic_filter(double x)
#undef a
}
static inline double sinc_filter(double x)
{
static inline double
sinc_filter(double x) {
if (x == 0.0) {
return 1.0;
}
@ -71,8 +70,8 @@ static inline double sinc_filter(double x)
return sin(x) / x;
}
static inline double lanczos_filter(double x)
{
static inline double
lanczos_filter(double x) {
/* truncated sinc */
if (-3.0 <= x && x < 3.0) {
return sinc_filter(x) * sinc_filter(x / 3);
@ -86,109 +85,108 @@ static struct filter HAMMING = { hamming_filter, 1.0 };
static struct filter BICUBIC = {bicubic_filter, 2.0};
static struct filter LANCZOS = {lanczos_filter, 3.0};
/* 8 bits for result. Filter can have negative areas.
In one cases the sum of the coefficients will be negative,
in the other it will be more than 1.0. That is why we need
two extra bits for overflow and int type. */
#define PRECISION_BITS (32 - 8 - 2)
/* Handles values form -640 to 639. */
UINT8 _clip8_lookups[1280] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226,
227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255,
};
UINT8 *clip8_lookups = &_clip8_lookups[640];
static inline UINT8 clip8(int in)
{
static inline UINT8
clip8(int in) {
return clip8_lookups[in >> PRECISION_BITS];
}
int
precompute_coeffs(int inSize, float in0, float in1, int outSize,
struct filter *filterp, int **boundsp, double **kkp) {
precompute_coeffs(
int inSize,
float in0,
float in1,
int outSize,
struct filter *filterp,
int **boundsp,
double **kkp) {
double support, scale, filterscale;
double center, ww, ss;
int xx, x, ksize, xmin, xmax;
@ -267,10 +265,8 @@ precompute_coeffs(int inSize, float in0, float in1, int outSize,
return ksize;
}
void
normalize_coeffs_8bpc(int outSize, int ksize, double *prekk)
{
normalize_coeffs_8bpc(int outSize, int ksize, double *prekk) {
int x;
INT32 *kk;
@ -286,12 +282,9 @@ normalize_coeffs_8bpc(int outSize, int ksize, double *prekk)
}
}
void
ImagingResampleHorizontal_8bpc(Imaging imOut, Imaging imIn, int offset,
int ksize, int *bounds, double *prekk)
{
ImagingResampleHorizontal_8bpc(
Imaging imOut, Imaging imIn, int offset, int ksize, int *bounds, double *prekk) {
ImagingSectionCookie cookie;
int ss0, ss1, ss2, ss3;
int xx, yy, x, xmin, xmax;
@ -325,8 +318,10 @@ ImagingResampleHorizontal_8bpc(Imaging imOut, Imaging imIn, int offset,
k = &kk[xx * ksize];
ss0 = ss3 = 1 << (PRECISION_BITS - 1);
for (x = 0; x < xmax; x++) {
ss0 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 0]) * k[x];
ss3 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 3]) * k[x];
ss0 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 0]) *
k[x];
ss3 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 3]) *
k[x];
}
v = MAKE_UINT32(clip8(ss0), 0, 0, clip8(ss3));
memcpy(imOut->image[yy] + xx * sizeof(v), &v, sizeof(v));
@ -341,9 +336,12 @@ ImagingResampleHorizontal_8bpc(Imaging imOut, Imaging imIn, int offset,
k = &kk[xx * ksize];
ss0 = ss1 = ss2 = 1 << (PRECISION_BITS - 1);
for (x = 0; x < xmax; x++) {
ss0 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 0]) * k[x];
ss1 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 1]) * k[x];
ss2 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 2]) * k[x];
ss0 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 0]) *
k[x];
ss1 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 1]) *
k[x];
ss2 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 2]) *
k[x];
}
v = MAKE_UINT32(clip8(ss0), clip8(ss1), clip8(ss2), 0);
memcpy(imOut->image[yy] + xx * sizeof(v), &v, sizeof(v));
@ -358,10 +356,14 @@ ImagingResampleHorizontal_8bpc(Imaging imOut, Imaging imIn, int offset,
k = &kk[xx * ksize];
ss0 = ss1 = ss2 = ss3 = 1 << (PRECISION_BITS - 1);
for (x = 0; x < xmax; x++) {
ss0 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 0]) * k[x];
ss1 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 1]) * k[x];
ss2 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 2]) * k[x];
ss3 += ((UINT8) imIn->image[yy + offset][(x + xmin)*4 + 3]) * k[x];
ss0 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 0]) *
k[x];
ss1 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 1]) *
k[x];
ss2 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 2]) *
k[x];
ss3 += ((UINT8)imIn->image[yy + offset][(x + xmin) * 4 + 3]) *
k[x];
}
v = MAKE_UINT32(clip8(ss0), clip8(ss1), clip8(ss2), clip8(ss3));
memcpy(imOut->image[yy] + xx * sizeof(v), &v, sizeof(v));
@ -372,11 +374,9 @@ ImagingResampleHorizontal_8bpc(Imaging imOut, Imaging imIn, int offset,
ImagingSectionLeave(&cookie);
}
void
ImagingResampleVertical_8bpc(Imaging imOut, Imaging imIn, int offset,
int ksize, int *bounds, double *prekk)
{
ImagingResampleVertical_8bpc(
Imaging imOut, Imaging imIn, int offset, int ksize, int *bounds, double *prekk) {
ImagingSectionCookie cookie;
int ss0, ss1, ss2, ss3;
int xx, yy, y, ymin, ymax;
@ -457,11 +457,9 @@ ImagingResampleVertical_8bpc(Imaging imOut, Imaging imIn, int offset,
ImagingSectionLeave(&cookie);
}
void
ImagingResampleHorizontal_32bpc(Imaging imOut, Imaging imIn, int offset,
int ksize, int *bounds, double *kk)
{
ImagingResampleHorizontal_32bpc(
Imaging imOut, Imaging imIn, int offset, int ksize, int *bounds, double *kk) {
ImagingSectionCookie cookie;
double ss;
int xx, yy, x, xmin, xmax;
@ -502,11 +500,9 @@ ImagingResampleHorizontal_32bpc(Imaging imOut, Imaging imIn, int offset,
ImagingSectionLeave(&cookie);
}
void
ImagingResampleVertical_32bpc(Imaging imOut, Imaging imIn, int offset,
int ksize, int *bounds, double *kk)
{
ImagingResampleVertical_32bpc(
Imaging imOut, Imaging imIn, int offset, int ksize, int *bounds, double *kk) {
ImagingSectionCookie cookie;
double ss;
int xx, yy, y, ymin, ymax;
@ -547,21 +543,21 @@ ImagingResampleVertical_32bpc(Imaging imOut, Imaging imIn, int offset,
ImagingSectionLeave(&cookie);
}
typedef void (*ResampleFunction)(Imaging imOut, Imaging imIn, int offset,
int ksize, int *bounds, double *kk);
typedef void (*ResampleFunction)(
Imaging imOut, Imaging imIn, int offset, int ksize, int *bounds, double *kk);
Imaging
ImagingResampleInner(Imaging imIn, int xsize, int ysize,
struct filter *filterp, float box[4],
ImagingResampleInner(
Imaging imIn,
int xsize,
int ysize,
struct filter *filterp,
float box[4],
ResampleFunction ResampleHorizontal,
ResampleFunction ResampleVertical);
Imaging
ImagingResample(Imaging imIn, int xsize, int ysize, int filter, float box[4])
{
ImagingResample(Imaging imIn, int xsize, int ysize, int filter, float box[4]) {
struct filter *filterp;
ResampleFunction ResampleHorizontal;
ResampleFunction ResampleVertical;
@ -609,22 +605,22 @@ ImagingResample(Imaging imIn, int xsize, int ysize, int filter, float box[4])
filterp = &LANCZOS;
break;
default:
return (Imaging) ImagingError_ValueError(
"unsupported resampling filter"
);
return (Imaging)ImagingError_ValueError("unsupported resampling filter");
}
return ImagingResampleInner(imIn, xsize, ysize, filterp, box,
ResampleHorizontal, ResampleVertical);
return ImagingResampleInner(
imIn, xsize, ysize, filterp, box, ResampleHorizontal, ResampleVertical);
}
Imaging
ImagingResampleInner(Imaging imIn, int xsize, int ysize,
struct filter *filterp, float box[4],
ImagingResampleInner(
Imaging imIn,
int xsize,
int ysize,
struct filter *filterp,
float box[4],
ResampleFunction ResampleHorizontal,
ResampleFunction ResampleVertical)
{
ResampleFunction ResampleVertical) {
Imaging imTemp = NULL;
Imaging imOut = NULL;
@ -637,14 +633,14 @@ ImagingResampleInner(Imaging imIn, int xsize, int ysize,
need_horizontal = xsize != imIn->xsize || box[0] || box[2] != xsize;
need_vertical = ysize != imIn->ysize || box[1] || box[3] != ysize;
ksize_horiz = precompute_coeffs(imIn->xsize, box[0], box[2], xsize,
filterp, &bounds_horiz, &kk_horiz);
ksize_horiz = precompute_coeffs(
imIn->xsize, box[0], box[2], xsize, filterp, &bounds_horiz, &kk_horiz);
if (!ksize_horiz) {
return NULL;
}
ksize_vert = precompute_coeffs(imIn->ysize, box[1], box[3], ysize,
filterp, &bounds_vert, &kk_vert);
ksize_vert = precompute_coeffs(
imIn->ysize, box[1], box[3], ysize, filterp, &bounds_vert, &kk_vert);
if (!ksize_vert) {
free(bounds_horiz);
free(kk_horiz);
@ -656,7 +652,6 @@ ImagingResampleInner(Imaging imIn, int xsize, int ysize,
// Last used row in the source image
ybox_last = bounds_vert[ysize * 2 - 2] + bounds_vert[ysize * 2 - 1];
/* two-pass resize, horizontal pass */
if (need_horizontal) {
// Shift bounds for vertical pass
@ -666,8 +661,8 @@ ImagingResampleInner(Imaging imIn, int xsize, int ysize,
imTemp = ImagingNewDirty(imIn->mode, xsize, ybox_last - ybox_first);
if (imTemp) {
ResampleHorizontal(imTemp, imIn, ybox_first,
ksize_horiz, bounds_horiz, kk_horiz);
ResampleHorizontal(
imTemp, imIn, ybox_first, ksize_horiz, bounds_horiz, kk_horiz);
}
free(bounds_horiz);
free(kk_horiz);
@ -688,8 +683,7 @@ ImagingResampleInner(Imaging imIn, int xsize, int ysize,
imOut = ImagingNewDirty(imIn->mode, imIn->xsize, ysize);
if (imOut) {
/* imIn can be the original image or horizontally resampled one */
ResampleVertical(imOut, imIn, 0,
ksize_vert, bounds_vert, kk_vert);
ResampleVertical(imOut, imIn, 0, ksize_vert, bounds_vert, kk_vert);
}
/* it's safe to call ImagingDelete with empty value
if previous step was not performed. */

1
src/libImaging/Sgi.h
View File

@ -1,7 +1,6 @@
/* Sgi.h */
typedef struct {
/* CONFIGURATION */
/* Number of bytes per channel per pixel */

69
src/libImaging/SgiRleDecode.c
View File

@ -20,18 +20,17 @@
#define RLE_COPY_FLAG 0x80
#define RLE_MAX_RUN 0x7f
static void read4B(UINT32* dest, UINT8* buf)
{
static void
read4B(UINT32 *dest, UINT8 *buf) {
*dest = (UINT32)((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]);
}
static int expandrow(UINT8* dest, UINT8* src, int n, int z, int xsize)
{
static int
expandrow(UINT8 *dest, UINT8 *src, int n, int z, int xsize) {
UINT8 pixel, count;
int x = 0;
for (;n > 0; n--)
{
for (; n > 0; n--) {
pixel = *src++;
if (n == 1 && pixel != 0) {
return n;
@ -50,27 +49,24 @@ static int expandrow(UINT8* dest, UINT8* src, int n, int z, int xsize)
dest += z;
}
}
else {
} else {
pixel = *src++;
while (count--) {
*dest = pixel;
dest += z;
}
}
}
return 0;
}
static int expandrow2(UINT8* dest, const UINT8* src, int n, int z, int xsize)
{
static int
expandrow2(UINT8 *dest, const UINT8 *src, int n, int z, int xsize) {
UINT8 pixel, count;
int x = 0;
for (;n > 0; n--)
{
for (; n > 0; n--) {
pixel = src[1];
src += 2;
if (n == 1 && pixel != 0) {
@ -90,8 +86,7 @@ static int expandrow2(UINT8* dest, const UINT8* src, int n, int z, int xsize)
src += 2;
dest += z * 2;
}
}
else {
} else {
while (count--) {
memcpy(dest, src, 2);
dest += z * 2;
@ -102,19 +97,15 @@ static int expandrow2(UINT8* dest, const UINT8* src, int n, int z, int xsize)
return 0;
}
int
ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
UINT8* buf, Py_ssize_t bytes)
{
ImagingSgiRleDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
UINT8 *ptr;
SGISTATE *c;
int err = 0;
int status;
/* size check */
if (im->xsize > INT_MAX / im->bands ||
im->ysize > INT_MAX / im->bands) {
if (im->xsize > INT_MAX / im->bands || im->ysize > INT_MAX / im->bands) {
state->errcode = IMAGING_CODEC_MEMORY;
return -1;
}
@ -143,7 +134,6 @@ ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
_imaging_seek_pyFd(state->fd, SGI_HEADER_SIZE, SEEK_SET);
_imaging_read_pyFd(state->fd, (char *)ptr, c->bufsize);
/* decoder initialization */
state->count = 0;
state->y = 0;
@ -160,28 +150,27 @@ ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
state->buffer = calloc(im->xsize * im->bands, sizeof(UINT8) * 2);
c->starttab = calloc(c->tablen, sizeof(UINT32));
c->lengthtab = calloc(c->tablen, sizeof(UINT32));
if (!state->buffer ||
!c->starttab ||
!c->lengthtab) {
if (!state->buffer || !c->starttab || !c->lengthtab) {
err = IMAGING_CODEC_MEMORY;
goto sgi_finish_decode;
}
/* populate offsets table */
for (c->tabindex = 0, c->bufindex = 0; c->tabindex < c->tablen; c->tabindex++, c->bufindex+=4) {
for (c->tabindex = 0, c->bufindex = 0; c->tabindex < c->tablen;
c->tabindex++, c->bufindex += 4) {
read4B(&c->starttab[c->tabindex], &ptr[c->bufindex]);
}
/* populate lengths table */
for (c->tabindex = 0, c->bufindex = c->tablen * sizeof(UINT32); c->tabindex < c->tablen; c->tabindex++, c->bufindex+=4) {
for (c->tabindex = 0, c->bufindex = c->tablen * sizeof(UINT32);
c->tabindex < c->tablen;
c->tabindex++, c->bufindex += 4) {
read4B(&c->lengthtab[c->tabindex], &ptr[c->bufindex]);
}
state->count += c->tablen * sizeof(UINT32) * 2;
/* read compressed rows */
for (c->rowno = 0; c->rowno < im->ysize; c->rowno++, state->y += state->ystep)
{
for (c->channo = 0; c->channo < im->bands; c->channo++)
{
for (c->rowno = 0; c->rowno < im->ysize; c->rowno++, state->y += state->ystep) {
for (c->channo = 0; c->channo < im->bands; c->channo++) {
c->rleoffset = c->starttab[c->rowno + c->channo * im->ysize];
c->rlelength = c->lengthtab[c->rowno + c->channo * im->ysize];
c->rleoffset -= SGI_HEADER_SIZE;
@ -193,10 +182,19 @@ ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
/* row decompression */
if (c->bpc == 1) {
status = expandrow(&state->buffer[c->channo], &ptr[c->rleoffset], c->rlelength, im->bands, im->xsize);
}
else {
status = expandrow2(&state->buffer[c->channo * 2], &ptr[c->rleoffset], c->rlelength, im->bands, im->xsize);
status = expandrow(
&state->buffer[c->channo],
&ptr[c->rleoffset],
c->rlelength,
im->bands,
im->xsize);
} else {
status = expandrow2(
&state->buffer[c->channo * 2],
&ptr[c->rleoffset],
c->rlelength,
im->bands,
im->xsize);
}
if (status == -1) {
state->errcode = IMAGING_CODEC_OVERRUN;
@ -210,7 +208,6 @@ ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
/* store decompressed data in image */
state->shuffle((UINT8 *)im->image[state->y], state->buffer, im->xsize);
}
c->bufsize++;

79
src/libImaging/Storage.c
View File

@ -34,11 +34,9 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#include <string.h>
int ImagingNewCount = 0;
/* --------------------------------------------------------------------
@ -46,8 +44,7 @@ int ImagingNewCount = 0;
*/
Imaging
ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size)
{
ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size) {
Imaging im;
/* linesize overflow check, roughly the current largest space req'd */
@ -115,8 +112,9 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size)
im->linesize = xsize * 4;
im->type = IMAGING_TYPE_INT32;
} else if (strcmp(mode, "I;16") == 0 || strcmp(mode, "I;16L") == 0 \
|| strcmp(mode, "I;16B") == 0 || strcmp(mode, "I;16N") == 0) {
} else if (
strcmp(mode, "I;16") == 0 || strcmp(mode, "I;16L") == 0 ||
strcmp(mode, "I;16B") == 0 || strcmp(mode, "I;16N") == 0) {
/* EXPERIMENTAL */
/* 16-bit raw integer images */
im->bands = 1;
@ -221,7 +219,9 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size)
/* Initialize alias pointers to pixel data. */
switch (im->pixelsize) {
case 1: case 2: case 3:
case 1:
case 2:
case 3:
im->image8 = (UINT8 **)im->image;
break;
case 4:
@ -235,15 +235,13 @@ ImagingNewPrologueSubtype(const char *mode, int xsize, int ysize, int size)
}
Imaging
ImagingNewPrologue(const char *mode, int xsize, int ysize)
{
ImagingNewPrologue(const char *mode, int xsize, int ysize) {
return ImagingNewPrologueSubtype(
mode, xsize, ysize, sizeof(struct ImagingMemoryInstance));
}
void
ImagingDelete(Imaging im)
{
ImagingDelete(Imaging im) {
if (!im) {
return;
}
@ -263,7 +261,6 @@ ImagingDelete(Imaging im)
free(im);
}
/* Array Storage Type */
/* ------------------ */
/* Allocate image as an array of line buffers. */
@ -276,12 +273,15 @@ struct ImagingMemoryArena ImagingDefaultArena = {
0, // blocks_max
0, // blocks_cached
NULL, // blocks_pool
0, 0, 0, 0, 0 // Stats
0,
0,
0,
0,
0 // Stats
};
int
ImagingMemorySetBlocksMax(ImagingMemoryArena arena, int blocks_max)
{
ImagingMemorySetBlocksMax(ImagingMemoryArena arena, int blocks_max) {
void *p;
/* Free already cached blocks */
ImagingMemoryClearCache(arena, blocks_max);
@ -308,8 +308,7 @@ ImagingMemorySetBlocksMax(ImagingMemoryArena arena, int blocks_max)
}
void
ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size)
{
ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size) {
while (arena->blocks_cached > new_size) {
arena->blocks_cached -= 1;
free(arena->blocks_pool[arena->blocks_cached].ptr);
@ -318,8 +317,7 @@ ImagingMemoryClearCache(ImagingMemoryArena arena, int new_size)
}
ImagingMemoryBlock
memory_get_block(ImagingMemoryArena arena, int requested_size, int dirty)
{
memory_get_block(ImagingMemoryArena arena, int requested_size, int dirty) {
ImagingMemoryBlock block = {NULL, 0};
if (arena->blocks_cached > 0) {
@ -356,8 +354,7 @@ memory_get_block(ImagingMemoryArena arena, int requested_size, int dirty)
}
void
memory_return_block(ImagingMemoryArena arena, ImagingMemoryBlock block)
{
memory_return_block(ImagingMemoryArena arena, ImagingMemoryBlock block) {
if (arena->blocks_cached < arena->blocks_max) {
// Reduce block size
if (block.size > arena->block_size) {
@ -372,10 +369,8 @@ memory_return_block(ImagingMemoryArena arena, ImagingMemoryBlock block)
}
}
static void
ImagingDestroyArray(Imaging im)
{
ImagingDestroyArray(Imaging im) {
int y = 0;
if (im->blocks) {
@ -388,8 +383,7 @@ ImagingDestroyArray(Imaging im)
}
Imaging
ImagingAllocateArray(Imaging im, int dirty, int block_size)
{
ImagingAllocateArray(Imaging im, int dirty, int block_size) {
int y, line_in_block, current_block;
ImagingMemoryArena arena = &ImagingDefaultArena;
ImagingMemoryBlock block = {NULL, 0};
@ -454,27 +448,23 @@ ImagingAllocateArray(Imaging im, int dirty, int block_size)
return im;
}
/* Block Storage Type */
/* ------------------ */
/* Allocate image as a single block. */
static void
ImagingDestroyBlock(Imaging im)
{
ImagingDestroyBlock(Imaging im) {
if (im->block) {
free(im->block);
}
}
Imaging
ImagingAllocateBlock(Imaging im)
{
ImagingAllocateBlock(Imaging im) {
Py_ssize_t y, i;
/* overflow check for malloc */
if (im->linesize &&
im->ysize > INT_MAX / im->linesize) {
if (im->linesize && im->ysize > INT_MAX / im->linesize) {
return (Imaging)ImagingError_MemoryError();
}
@ -507,8 +497,7 @@ ImagingAllocateBlock(Imaging im)
*/
Imaging
ImagingNewInternal(const char* mode, int xsize, int ysize, int dirty)
{
ImagingNewInternal(const char *mode, int xsize, int ysize, int dirty) {
Imaging im;
if (xsize < 0 || ysize < 0) {
@ -536,20 +525,17 @@ ImagingNewInternal(const char* mode, int xsize, int ysize, int dirty)
}
Imaging
ImagingNew(const char* mode, int xsize, int ysize)
{
ImagingNew(const char *mode, int xsize, int ysize) {
return ImagingNewInternal(mode, xsize, ysize, 0);
}
Imaging
ImagingNewDirty(const char* mode, int xsize, int ysize)
{
ImagingNewDirty(const char *mode, int xsize, int ysize) {
return ImagingNewInternal(mode, xsize, ysize, 1);
}
Imaging
ImagingNewBlock(const char* mode, int xsize, int ysize)
{
ImagingNewBlock(const char *mode, int xsize, int ysize) {
Imaging im;
if (xsize < 0 || ysize < 0) {
@ -570,15 +556,13 @@ ImagingNewBlock(const char* mode, int xsize, int ysize)
}
Imaging
ImagingNew2Dirty(const char* mode, Imaging imOut, Imaging imIn)
{
ImagingNew2Dirty(const char *mode, Imaging imOut, Imaging imIn) {
/* allocate or validate output image */
if (imOut) {
/* make sure images match */
if (strcmp(imOut->mode, mode) != 0
|| imOut->xsize != imIn->xsize
|| imOut->ysize != imIn->ysize) {
if (strcmp(imOut->mode, mode) != 0 || imOut->xsize != imIn->xsize ||
imOut->ysize != imIn->ysize) {
return ImagingError_Mismatch();
}
} else {
@ -593,8 +577,7 @@ ImagingNew2Dirty(const char* mode, Imaging imOut, Imaging imIn)
}
void
ImagingCopyPalette(Imaging destination, Imaging source)
{
ImagingCopyPalette(Imaging destination, Imaging source) {
if (source->palette) {
if (destination->palette) {
ImagingPaletteDelete(destination->palette);

20
src/libImaging/SunRleDecode.c
View File

@ -15,13 +15,10 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingSunRleDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingSunRleDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
int n;
UINT8 *ptr;
UINT8 extra_data = 0;
@ -30,22 +27,18 @@ ImagingSunRleDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t
ptr = buf;
for (;;) {
if (bytes < 1) {
return ptr - buf;
}
if (ptr[0] == 0x80) {
if (bytes < 2) {
break;
}
n = ptr[1];
if (n == 0) {
/* Literal 0x80 (2 bytes) */
n = 1;
@ -55,7 +48,6 @@ ImagingSunRleDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t
bytes -= 2;
} else {
/* Run (3 bytes) */
if (bytes < 3) {
break;
@ -94,11 +86,9 @@ ImagingSunRleDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t
ptr += 3;
bytes -= 3;
}
} else {
/* Literal byte */
n = 1;
@ -106,17 +96,17 @@ ImagingSunRleDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t
ptr += 1;
bytes -= 1;
}
for (;;) {
state->x += n;
if (state->x >= state->bytes) {
/* Got a full line, unpack it */
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->buffer,
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->buffer,
state->xsize);
state->x = 0;

21
src/libImaging/TgaRleDecode.c
View File

@ -14,21 +14,16 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
UINT8* buf, Py_ssize_t bytes)
{
ImagingTgaRleDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
int n, depth;
UINT8 *ptr;
ptr = buf;
if (state->state == 0) {
/* check image orientation */
if (state->ystep < 0) {
state->y = state->ysize - 1;
@ -38,19 +33,16 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
}
state->state = 1;
}
depth = state->count;
for (;;) {
if (bytes < 1) {
return ptr - buf;
}
if (ptr[0] & 0x80) {
/* Run (1 + pixelsize bytes) */
if (bytes < 1 + depth) {
@ -77,7 +69,6 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
bytes -= 1 + depth;
} else {
/* Literal (1+n+1 bytes block) */
n = depth * (ptr[0] + 1);
@ -94,16 +85,16 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
ptr += 1 + n;
bytes -= 1 + n;
}
state->x += n;
if (state->x >= state->bytes) {
/* Got a full line, unpack it */
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->buffer,
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->buffer,
state->xsize);
state->x = 0;
@ -114,9 +105,7 @@ ImagingTgaRleDecode(Imaging im, ImagingCodecState state,
/* End of file (errcode = 0) */
return -1;
}
}
}
return ptr - buf;

17
src/libImaging/TgaRleEncode.c
View File

@ -4,17 +4,14 @@
#include <assert.h>
#include <string.h>
static int comparePixels(const UINT8* buf, int x, int bytesPerPixel)
{
static int
comparePixels(const UINT8 *buf, int x, int bytesPerPixel) {
buf += x * bytesPerPixel;
return memcmp(buf, buf + bytesPerPixel, bytesPerPixel) == 0;
}
int
ImagingTgaRleEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingTgaRleEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
UINT8 *dst;
int bytesPerPixel;
@ -64,8 +61,8 @@ ImagingTgaRleEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
if (state->x == 0) {
state->shuffle(
state->buffer,
(UINT8*)im->image[state->y + state->yoff]
+ state->xoff * im->pixelsize,
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->xsize);
}
@ -149,9 +146,7 @@ ImagingTgaRleEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
memcpy(
dst,
state->buffer + (state->x * bytesPerPixel - state->count),
flushCount);
dst, state->buffer + (state->x * bytesPerPixel - state->count), flushCount);
dst += flushCount;
bytes -= flushCount;

350
src/libImaging/TiffDecode.c
View File

@ -23,7 +23,8 @@
/* Convert C file descriptor to WinApi HFILE if LibTiff was compiled with tif_win32.c
*
* This cast is safe, as the top 32-bits of HFILE are guaranteed to be zero,
* see https://docs.microsoft.com/en-us/windows/win32/winprog64/interprocess-communication
* see
* https://docs.microsoft.com/en-us/windows/win32/winprog64/interprocess-communication
*/
#ifndef USE_WIN32_FILEIO
#define fd_to_tiff_fd(fd) (fd)
@ -31,16 +32,23 @@
#define fd_to_tiff_fd(fd) ((int)_get_osfhandle(fd))
#endif
void dump_state(const TIFFSTATE *state){
TRACE(("State: Location %u size %d eof %d data: %p ifd: %d\n", (uint)state->loc,
(int)state->size, (uint)state->eof, state->data, state->ifd));
void
dump_state(const TIFFSTATE *state) {
TRACE(
("State: Location %u size %d eof %d data: %p ifd: %d\n",
(uint)state->loc,
(int)state->size,
(uint)state->eof,
state->data,
state->ifd));
}
/*
procs for TIFFOpenClient
*/
tsize_t _tiffReadProc(thandle_t hdata, tdata_t buf, tsize_t size) {
tsize_t
_tiffReadProc(thandle_t hdata, tdata_t buf, tsize_t size) {
TIFFSTATE *state = (TIFFSTATE *)hdata;
tsize_t to_read;
@ -57,7 +65,8 @@ tsize_t _tiffReadProc(thandle_t hdata, tdata_t buf, tsize_t size) {
return to_read;
}
tsize_t _tiffWriteProc(thandle_t hdata, tdata_t buf, tsize_t size) {
tsize_t
_tiffWriteProc(thandle_t hdata, tdata_t buf, tsize_t size) {
TIFFSTATE *state = (TIFFSTATE *)hdata;
tsize_t to_write;
@ -97,7 +106,8 @@ tsize_t _tiffWriteProc(thandle_t hdata, tdata_t buf, tsize_t size) {
return to_write;
}
toff_t _tiffSeekProc(thandle_t hdata, toff_t off, int whence) {
toff_t
_tiffSeekProc(thandle_t hdata, toff_t off, int whence) {
TIFFSTATE *state = (TIFFSTATE *)hdata;
TRACE(("_tiffSeekProc: off: %u whence: %d \n", (uint)off, whence));
@ -117,7 +127,8 @@ toff_t _tiffSeekProc(thandle_t hdata, toff_t off, int whence) {
return state->loc;
}
int _tiffCloseProc(thandle_t hdata) {
int
_tiffCloseProc(thandle_t hdata) {
TIFFSTATE *state = (TIFFSTATE *)hdata;
TRACE(("_tiffCloseProc \n"));
@ -126,8 +137,8 @@ int _tiffCloseProc(thandle_t hdata) {
return 0;
}
toff_t _tiffSizeProc(thandle_t hdata) {
toff_t
_tiffSizeProc(thandle_t hdata) {
TIFFSTATE *state = (TIFFSTATE *)hdata;
TRACE(("_tiffSizeProc \n"));
@ -136,7 +147,8 @@ toff_t _tiffSizeProc(thandle_t hdata) {
return (toff_t)state->size;
}
int _tiffMapProc(thandle_t hdata, tdata_t* pbase, toff_t* psize) {
int
_tiffMapProc(thandle_t hdata, tdata_t *pbase, toff_t *psize) {
TIFFSTATE *state = (TIFFSTATE *)hdata;
TRACE(("_tiffMapProc input size: %u, data: %p\n", (uint)*psize, *pbase));
@ -148,25 +160,41 @@ int _tiffMapProc(thandle_t hdata, tdata_t* pbase, toff_t* psize) {
return (1);
}
int _tiffNullMapProc(thandle_t hdata, tdata_t* pbase, toff_t* psize) {
(void) hdata; (void) pbase; (void) psize;
int
_tiffNullMapProc(thandle_t hdata, tdata_t *pbase, toff_t *psize) {
(void)hdata;
(void)pbase;
(void)psize;
return (0);
}
void _tiffUnmapProc(thandle_t hdata, tdata_t base, toff_t size) {
void
_tiffUnmapProc(thandle_t hdata, tdata_t base, toff_t size) {
TRACE(("_tiffUnMapProc\n"));
(void) hdata; (void) base; (void) size;
(void)hdata;
(void)base;
(void)size;
}
int ImagingLibTiffInit(ImagingCodecState state, int fp, uint32 offset) {
int
ImagingLibTiffInit(ImagingCodecState state, int fp, uint32 offset) {
TIFFSTATE *clientstate = (TIFFSTATE *)state->context;
TRACE(("initing libtiff\n"));
TRACE(("filepointer: %d \n", fp));
TRACE(("State: count %d, state %d, x %d, y %d, ystep %d\n", state->count, state->state,
state->x, state->y, state->ystep));
TRACE(("State: xsize %d, ysize %d, xoff %d, yoff %d \n", state->xsize, state->ysize,
state->xoff, state->yoff));
TRACE(
("State: count %d, state %d, x %d, y %d, ystep %d\n",
state->count,
state->state,
state->x,
state->y,
state->ystep));
TRACE(
("State: xsize %d, ysize %d, xoff %d, yoff %d \n",
state->xsize,
state->ysize,
state->xoff,
state->yoff));
TRACE(("State: bits %d, bytes %d \n", state->bits, state->bytes));
TRACE(("State: context %p \n", state->context));
@ -180,8 +208,8 @@ int ImagingLibTiffInit(ImagingCodecState state, int fp, uint32 offset) {
return 1;
}
int _decodeStripYCbCr(Imaging im, ImagingCodecState state, TIFF *tiff) {
int
_decodeStripYCbCr(Imaging im, ImagingCodecState state, TIFF *tiff) {
// To avoid dealing with YCbCr subsampling, let libtiff handle it
// Use a TIFFRGBAImage wrapping the tiff image, and let libtiff handle
// all of the conversion. Metadata read from the TIFFRGBAImage could
@ -211,8 +239,12 @@ int _decodeStripYCbCr(Imaging im, ImagingCodecState state, TIFF *tiff) {
img.col_offset = 0;
if (state->xsize != img.width || state->ysize != img.height) {
TRACE(("Inconsistent Image Error: %d =? %d, %d =? %d",
state->xsize, img.width, state->ysize, img.height));
TRACE(
("Inconsistent Image Error: %d =? %d, %d =? %d",
state->xsize,
img.width,
state->ysize,
img.height));
state->errcode = IMAGING_CODEC_BROKEN;
goto decodeycbcr_err;
}
@ -250,7 +282,8 @@ int _decodeStripYCbCr(Imaging im, ImagingCodecState state, TIFF *tiff) {
img.row_offset = state->y;
rows_to_read = min(rows_per_strip, img.height - state->y);
if (TIFFRGBAImageGet(&img, (UINT32 *)state->buffer, img.width, rows_to_read) == -1) {
if (TIFFRGBAImageGet(&img, (UINT32 *)state->buffer, img.width, rows_to_read) ==
-1) {
TRACE(("Decode Error, y: %d\n", state->y));
state->errcode = IMAGING_CODEC_BROKEN;
goto decodeycbcr_err;
@ -259,13 +292,17 @@ int _decodeStripYCbCr(Imaging im, ImagingCodecState state, TIFF *tiff) {
TRACE(("Decoded strip for row %d \n", state->y));
// iterate over each row in the strip and stuff data into image
for (strip_row = 0; strip_row < min((INT32) rows_per_strip, state->ysize - state->y); strip_row++) {
for (strip_row = 0;
strip_row < min((INT32)rows_per_strip, state->ysize - state->y);
strip_row++) {
TRACE(("Writing data into line %d ; \n", state->y + strip_row));
// UINT8 * bbb = state->buffer + strip_row * (state->bytes / rows_per_strip);
// TRACE(("chars: %x %x %x %x\n", ((UINT8 *)bbb)[0], ((UINT8 *)bbb)[1], ((UINT8 *)bbb)[2], ((UINT8 *)bbb)[3]));
// UINT8 * bbb = state->buffer + strip_row * (state->bytes /
// rows_per_strip); TRACE(("chars: %x %x %x %x\n", ((UINT8 *)bbb)[0],
// ((UINT8 *)bbb)[1], ((UINT8 *)bbb)[2], ((UINT8 *)bbb)[3]));
state->shuffle((UINT8*) im->image[state->y + state->yoff + strip_row] +
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff + strip_row] +
state->xoff * im->pixelsize,
state->buffer + strip_row * row_byte_size,
state->xsize);
@ -280,7 +317,8 @@ int _decodeStripYCbCr(Imaging im, ImagingCodecState state, TIFF *tiff) {
return 0;
}
int _decodeStrip(Imaging im, ImagingCodecState state, TIFF *tiff) {
int
_decodeStrip(Imaging im, ImagingCodecState state, TIFF *tiff) {
INT32 strip_row;
UINT8 *new_data;
UINT32 rows_per_strip, row_byte_size;
@ -307,7 +345,8 @@ int _decodeStrip(Imaging im, ImagingCodecState state, TIFF *tiff) {
if (TIFFStripSize(tiff) > state->bytes) {
// If the strip size as expected by LibTiff isn't what we're expecting, abort.
// man: TIFFStripSize returns the equivalent size for a strip of data as it would be returned in a
// man: TIFFStripSize returns the equivalent size for a strip of data as it
// would be returned in a
// call to TIFFReadEncodedStrip ...
state->errcode = IMAGING_CODEC_MEMORY;
@ -325,7 +364,11 @@ int _decodeStrip(Imaging im, ImagingCodecState state, TIFF *tiff) {
state->buffer = new_data;
for (; state->y < state->ysize; state->y += rows_per_strip) {
if (TIFFReadEncodedStrip(tiff, TIFFComputeStrip(tiff, state->y, 0), (tdata_t)state->buffer, -1) == -1) {
if (TIFFReadEncodedStrip(
tiff,
TIFFComputeStrip(tiff, state->y, 0),
(tdata_t)state->buffer,
-1) == -1) {
TRACE(("Decode Error, strip %d\n", TIFFComputeStrip(tiff, state->y, 0)));
state->errcode = IMAGING_CODEC_BROKEN;
return -1;
@ -334,13 +377,17 @@ int _decodeStrip(Imaging im, ImagingCodecState state, TIFF *tiff) {
TRACE(("Decoded strip for row %d \n", state->y));
// iterate over each row in the strip and stuff data into image
for (strip_row = 0; strip_row < min((INT32) rows_per_strip, state->ysize - state->y); strip_row++) {
for (strip_row = 0;
strip_row < min((INT32)rows_per_strip, state->ysize - state->y);
strip_row++) {
TRACE(("Writing data into line %d ; \n", state->y + strip_row));
// UINT8 * bbb = state->buffer + strip_row * (state->bytes / rows_per_strip);
// TRACE(("chars: %x %x %x %x\n", ((UINT8 *)bbb)[0], ((UINT8 *)bbb)[1], ((UINT8 *)bbb)[2], ((UINT8 *)bbb)[3]));
// UINT8 * bbb = state->buffer + strip_row * (state->bytes /
// rows_per_strip); TRACE(("chars: %x %x %x %x\n", ((UINT8 *)bbb)[0],
// ((UINT8 *)bbb)[1], ((UINT8 *)bbb)[2], ((UINT8 *)bbb)[3]));
state->shuffle((UINT8*) im->image[state->y + state->yoff + strip_row] +
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff + strip_row] +
state->xoff * im->pixelsize,
state->buffer + strip_row * row_byte_size,
state->xsize);
@ -349,7 +396,9 @@ int _decodeStrip(Imaging im, ImagingCodecState state, TIFF *tiff) {
return 0;
}
int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_ssize_t bytes) {
int
ImagingLibTiffDecode(
Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes) {
TIFFSTATE *clientstate = (TIFFSTATE *)state->context;
char *filename = "tempfile.tif";
char *mode = "r";
@ -361,19 +410,47 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
/* it all ends up in state->buffer, which is a uint8* from Imaging.h */
TRACE(("in decoder: bytes %d\n", bytes));
TRACE(("State: count %d, state %d, x %d, y %d, ystep %d\n", state->count, state->state,
state->x, state->y, state->ystep));
TRACE(("State: xsize %d, ysize %d, xoff %d, yoff %d \n", state->xsize, state->ysize,
state->xoff, state->yoff));
TRACE(
("State: count %d, state %d, x %d, y %d, ystep %d\n",
state->count,
state->state,
state->x,
state->y,
state->ystep));
TRACE(
("State: xsize %d, ysize %d, xoff %d, yoff %d \n",
state->xsize,
state->ysize,
state->xoff,
state->yoff));
TRACE(("State: bits %d, bytes %d \n", state->bits, state->bytes));
TRACE(("Buffer: %p: %c%c%c%c\n", buffer, (char)buffer[0], (char)buffer[1],(char)buffer[2], (char)buffer[3]));
TRACE(("State->Buffer: %c%c%c%c\n", (char)state->buffer[0], (char)state->buffer[1],(char)state->buffer[2], (char)state->buffer[3]));
TRACE(("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
im->mode, im->type, im->bands, im->xsize, im->ysize));
TRACE(("Image: image8 %p, image32 %p, image %p, block %p \n",
im->image8, im->image32, im->image, im->block));
TRACE(("Image: pixelsize: %d, linesize %d \n",
im->pixelsize, im->linesize));
TRACE(
("Buffer: %p: %c%c%c%c\n",
buffer,
(char)buffer[0],
(char)buffer[1],
(char)buffer[2],
(char)buffer[3]));
TRACE(
("State->Buffer: %c%c%c%c\n",
(char)state->buffer[0],
(char)state->buffer[1],
(char)state->buffer[2],
(char)state->buffer[3]));
TRACE(
("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
im->mode,
im->type,
im->bands,
im->xsize,
im->ysize));
TRACE(
("Image: image8 %p, image32 %p, image %p, block %p \n",
im->image8,
im->image32,
im->image,
im->block));
TRACE(("Image: pixelsize: %d, linesize %d \n", im->pixelsize, im->linesize));
dump_state(clientstate);
clientstate->size = bytes;
@ -392,11 +469,17 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
tiff = TIFFFdOpen(fd_to_tiff_fd(clientstate->fp), filename, mode);
} else {
TRACE(("Opening from string\n"));
tiff = TIFFClientOpen(filename, mode,
tiff = TIFFClientOpen(
filename,
mode,
(thandle_t)clientstate,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc);
_tiffReadProc,
_tiffWriteProc,
_tiffSeekProc,
_tiffCloseProc,
_tiffSizeProc,
_tiffMapProc,
_tiffUnmapProc);
}
if (!tiff) {
@ -416,13 +499,13 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
}
}
TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
isYCbCr = photometric == PHOTOMETRIC_YCBCR;
if (TIFFIsTiled(tiff)) {
INT32 x, y, tile_y;
UINT32 tile_width, tile_length, current_tile_length, current_line, current_tile_width, row_byte_size;
UINT32 tile_width, tile_length, current_tile_length, current_line,
current_tile_width, row_byte_size;
UINT8 *new_data;
TIFFGetField(tiff, TIFFTAG_TILEWIDTH, &tile_width);
@ -434,7 +517,6 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
goto decode_err;
}
if (isYCbCr) {
row_byte_size = tile_width * 4;
/* sanity check, we use this value in shuffle below */
@ -443,7 +525,8 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
goto decode_err;
}
} else {
// We could use TIFFTileSize, but for YCbCr data it returns subsampled data size
// We could use TIFFTileSize, but for YCbCr data it returns subsampled data
// size
row_byte_size = (tile_width * state->bits + 7) / 8;
}
@ -456,7 +539,8 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
state->bytes = row_byte_size * tile_length;
if (TIFFTileSize(tiff) > state->bytes) {
// If the strip size as expected by LibTiff isn't what we're expecting, abort.
// If the strip size as expected by LibTiff isn't what we're expecting,
// abort.
state->errcode = IMAGING_CODEC_MEMORY;
goto decode_err;
}
@ -496,10 +580,15 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
current_tile_length = min((INT32)tile_length, state->ysize - y);
// iterate over each line in the tile and stuff data into image
for (tile_y = 0; tile_y < current_tile_length; tile_y++) {
TRACE(("Writing tile data at %dx%d using tile_width: %d; \n", tile_y + y, x, current_tile_width));
TRACE(
("Writing tile data at %dx%d using tile_width: %d; \n",
tile_y + y,
x,
current_tile_width));
// UINT8 * bbb = state->buffer + tile_y * row_byte_size;
// TRACE(("chars: %x%x%x%x\n", ((UINT8 *)bbb)[0], ((UINT8 *)bbb)[1], ((UINT8 *)bbb)[2], ((UINT8 *)bbb)[3]));
// TRACE(("chars: %x%x%x%x\n", ((UINT8 *)bbb)[0], ((UINT8 *)bbb)[1],
// ((UINT8 *)bbb)[2], ((UINT8 *)bbb)[3]));
/*
* For some reason the TIFFReadRGBATile() function
* chooses the lower left corner as the origin.
@ -513,18 +602,17 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
current_line = tile_y;
}
state->shuffle((UINT8*) im->image[tile_y + y] + x * im->pixelsize,
state->shuffle(
(UINT8 *)im->image[tile_y + y] + x * im->pixelsize,
state->buffer + current_line * row_byte_size,
current_tile_width
);
current_tile_width);
}
}
}
} else {
if (!isYCbCr) {
_decodeStrip(im, state, tiff);
}
else {
} else {
_decodeStripYCbCr(im, state, tiff);
}
}
@ -537,7 +625,8 @@ int ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, Py_
return -1;
}
int ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp) {
int
ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp) {
// Open the FD or the pointer as a tiff file, for writing.
// We may have to do some monkeying around to make this really work.
// If we have a fp, then we're good.
@ -551,10 +640,19 @@ int ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp) {
TRACE(("initing libtiff\n"));
TRACE(("Filename %s, filepointer: %d \n", filename, fp));
TRACE(("State: count %d, state %d, x %d, y %d, ystep %d\n", state->count, state->state,
state->x, state->y, state->ystep));
TRACE(("State: xsize %d, ysize %d, xoff %d, yoff %d \n", state->xsize, state->ysize,
state->xoff, state->yoff));
TRACE(
("State: count %d, state %d, x %d, y %d, ystep %d\n",
state->count,
state->state,
state->x,
state->y,
state->ystep));
TRACE(
("State: xsize %d, ysize %d, xoff %d, yoff %d \n",
state->xsize,
state->ysize,
state->xoff,
state->yoff));
TRACE(("State: bits %d, bytes %d \n", state->bits, state->bytes));
TRACE(("State: context %p \n", state->context));
@ -571,7 +669,8 @@ int ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp) {
TRACE(("Opening using fd: %d for writing \n", clientstate->fp));
clientstate->tiff = TIFFFdOpen(fd_to_tiff_fd(clientstate->fp), filename, mode);
} else {
// malloc a buffer to write the tif, we're going to need to realloc or something if we need bigger.
// malloc a buffer to write the tif, we're going to need to realloc or something
// if we need bigger.
TRACE(("Opening a buffer for writing \n"));
/* malloc check ok, small constant allocation */
clientstate->data = malloc(bufsize);
@ -583,12 +682,17 @@ int ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp) {
return 0;
}
clientstate->tiff = TIFFClientOpen(filename, mode,
clientstate->tiff = TIFFClientOpen(
filename,
mode,
(thandle_t)clientstate,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffNullMapProc, _tiffUnmapProc); /*force no mmap*/
_tiffReadProc,
_tiffWriteProc,
_tiffSeekProc,
_tiffCloseProc,
_tiffSizeProc,
_tiffNullMapProc,
_tiffUnmapProc); /*force no mmap*/
}
if (!clientstate->tiff) {
@ -597,10 +701,11 @@ int ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp) {
}
return 1;
}
int ImagingLibTiffMergeFieldInfo(ImagingCodecState state, TIFFDataType field_type, int key, int is_var_length){
int
ImagingLibTiffMergeFieldInfo(
ImagingCodecState state, TIFFDataType field_type, int key, int is_var_length) {
// Refer to libtiff docs (http://www.simplesystems.org/libtiff/addingtags.html)
TIFFSTATE *clientstate = (TIFFSTATE *)state->context;
uint32 n;
@ -615,8 +720,14 @@ int ImagingLibTiffMergeFieldInfo(ImagingCodecState state, TIFFDataType field_typ
int passcount = 0;
TIFFFieldInfo info[] = {
{ key, readcount, writecount, field_type, FIELD_CUSTOM, 1, passcount, "CustomField" }
};
{key,
readcount,
writecount,
field_type,
FIELD_CUSTOM,
1,
passcount,
"CustomField"}};
if (is_var_length) {
info[0].field_writecount = -1;
@ -629,7 +740,8 @@ int ImagingLibTiffMergeFieldInfo(ImagingCodecState state, TIFFDataType field_typ
n = sizeof(info) / sizeof(info[0]);
// Test for libtiff 4.0 or later, excluding libtiff 3.9.6 and 3.9.7
#if TIFFLIB_VERSION >= 20111221 && TIFFLIB_VERSION != 20120218 && TIFFLIB_VERSION != 20120922
#if TIFFLIB_VERSION >= 20111221 && TIFFLIB_VERSION != 20120218 && \
TIFFLIB_VERSION != 20120922
status = TIFFMergeFieldInfo(clientstate->tiff, info, n);
#else
TIFFMergeFieldInfo(clientstate->tiff, info, n);
@ -637,7 +749,8 @@ int ImagingLibTiffMergeFieldInfo(ImagingCodecState state, TIFFDataType field_typ
return status;
}
int ImagingLibTiffSetField(ImagingCodecState state, ttag_t tag, ...){
int
ImagingLibTiffSetField(ImagingCodecState state, ttag_t tag, ...) {
// after tif_dir.c->TIFFSetField.
TIFFSTATE *clientstate = (TIFFSTATE *)state->context;
va_list ap;
@ -649,8 +762,8 @@ int ImagingLibTiffSetField(ImagingCodecState state, ttag_t tag, ...){
return status;
}
int ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8* buffer, int bytes) {
int
ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes) {
/* One shot encoder. Encode everything to the tiff in the clientstate.
If we're running off of a FD, then run once, we're good, everything
ends up in the file, we close and we're done.
@ -664,31 +777,61 @@ int ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8* buffer, int
TIFF *tiff = clientstate->tiff;
TRACE(("in encoder: bytes %d\n", bytes));
TRACE(("State: count %d, state %d, x %d, y %d, ystep %d\n", state->count, state->state,
state->x, state->y, state->ystep));
TRACE(("State: xsize %d, ysize %d, xoff %d, yoff %d \n", state->xsize, state->ysize,
state->xoff, state->yoff));
TRACE(
("State: count %d, state %d, x %d, y %d, ystep %d\n",
state->count,
state->state,
state->x,
state->y,
state->ystep));
TRACE(
("State: xsize %d, ysize %d, xoff %d, yoff %d \n",
state->xsize,
state->ysize,
state->xoff,
state->yoff));
TRACE(("State: bits %d, bytes %d \n", state->bits, state->bytes));
TRACE(("Buffer: %p: %c%c%c%c\n", buffer, (char)buffer[0], (char)buffer[1],(char)buffer[2], (char)buffer[3]));
TRACE(("State->Buffer: %c%c%c%c\n", (char)state->buffer[0], (char)state->buffer[1],(char)state->buffer[2], (char)state->buffer[3]));
TRACE(("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
im->mode, im->type, im->bands, im->xsize, im->ysize));
TRACE(("Image: image8 %p, image32 %p, image %p, block %p \n",
im->image8, im->image32, im->image, im->block));
TRACE(("Image: pixelsize: %d, linesize %d \n",
im->pixelsize, im->linesize));
TRACE(
("Buffer: %p: %c%c%c%c\n",
buffer,
(char)buffer[0],
(char)buffer[1],
(char)buffer[2],
(char)buffer[3]));
TRACE(
("State->Buffer: %c%c%c%c\n",
(char)state->buffer[0],
(char)state->buffer[1],
(char)state->buffer[2],
(char)state->buffer[3]));
TRACE(
("Image: mode %s, type %d, bands: %d, xsize %d, ysize %d \n",
im->mode,
im->type,
im->bands,
im->xsize,
im->ysize));
TRACE(
("Image: image8 %p, image32 %p, image %p, block %p \n",
im->image8,
im->image32,
im->image,
im->block));
TRACE(("Image: pixelsize: %d, linesize %d \n", im->pixelsize, im->linesize));
dump_state(clientstate);
if (state->state == 0) {
TRACE(("Encoding line bt line"));
while (state->y < state->ysize) {
state->shuffle(state->buffer,
state->shuffle(
state->buffer,
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->xsize);
if (TIFFWriteScanline(tiff, (tdata_t)(state->buffer), (uint32)state->y, 0) == -1) {
if (TIFFWriteScanline(
tiff, (tdata_t)(state->buffer), (uint32)state->y, 0) == -1) {
TRACE(("Encode Error, row %d\n", state->y));
state->errcode = IMAGING_CODEC_BROKEN;
TIFFClose(tiff);
@ -724,7 +867,13 @@ int ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8* buffer, int
if (state->state == 1 && !clientstate->fp) {
int read = (int)_tiffReadProc(clientstate, (tdata_t)buffer, (tsize_t)bytes);
TRACE(("Buffer: %p: %c%c%c%c\n", buffer, (char)buffer[0], (char)buffer[1],(char)buffer[2], (char)buffer[3]));
TRACE(
("Buffer: %p: %c%c%c%c\n",
buffer,
(char)buffer[0],
(char)buffer[1],
(char)buffer[2],
(char)buffer[3]));
if (clientstate->loc == clientstate->eof) {
TRACE(("Hit EOF, calling an end, freeing data"));
state->errcode = IMAGING_CODEC_END;
@ -738,8 +887,7 @@ int ImagingLibTiffEncode(Imaging im, ImagingCodecState state, UINT8* buffer, int
}
const char *
ImagingTiffVersion(void)
{
ImagingTiffVersion(void) {
return TIFFGetVersion();
}

16
src/libImaging/TiffDecode.h
View File

@ -41,13 +41,15 @@ typedef struct {
int flrealloc; /* may we realloc */
} TIFFSTATE;
extern int ImagingLibTiffInit(ImagingCodecState state, int fp, uint32 offset);
extern int ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp);
extern int ImagingLibTiffMergeFieldInfo(ImagingCodecState state, TIFFDataType field_type, int key, int is_var_length);
extern int ImagingLibTiffSetField(ImagingCodecState state, ttag_t tag, ...);
extern int
ImagingLibTiffInit(ImagingCodecState state, int fp, uint32 offset);
extern int
ImagingLibTiffEncodeInit(ImagingCodecState state, char *filename, int fp);
extern int
ImagingLibTiffMergeFieldInfo(
ImagingCodecState state, TIFFDataType field_type, int key, int is_var_length);
extern int
ImagingLibTiffSetField(ImagingCodecState state, ttag_t tag, ...);
/*
Trace debugging

722
src/libImaging/Unpack.c
View File

File diff suppressed because it is too large Load Diff

191
src/libImaging/UnpackYCC.c
View File

@ -13,115 +13,116 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
/* Tables generated by pcdtables.py, based on transforms taken from
the "Colour Space Conversions FAQ" by Roberts/Ford. */
static INT16 L[] = { 0, 1, 3, 4, 5, 7, 8, 10, 11, 12, 14, 15, 16, 18,
19, 20, 22, 23, 24, 26, 27, 29, 30, 31, 33, 34, 35, 37, 38, 39, 41,
42, 43, 45, 46, 48, 49, 50, 52, 53, 54, 56, 57, 58, 60, 61, 62, 64,
65, 67, 68, 69, 71, 72, 73, 75, 76, 77, 79, 80, 82, 83, 84, 86, 87,
88, 90, 91, 92, 94, 95, 96, 98, 99, 101, 102, 103, 105, 106, 107, 109,
110, 111, 113, 114, 115, 117, 118, 120, 121, 122, 124, 125, 126, 128,
129, 130, 132, 133, 134, 136, 137, 139, 140, 141, 143, 144, 145, 147,
148, 149, 151, 152, 153, 155, 156, 158, 159, 160, 162, 163, 164, 166,
167, 168, 170, 171, 173, 174, 175, 177, 178, 179, 181, 182, 183, 185,
186, 187, 189, 190, 192, 193, 194, 196, 197, 198, 200, 201, 202, 204,
205, 206, 208, 209, 211, 212, 213, 215, 216, 217, 219, 220, 221, 223,
224, 225, 227, 228, 230, 231, 232, 234, 235, 236, 238, 239, 240, 242,
243, 245, 246, 247, 249, 250, 251, 253, 254, 255, 257, 258, 259, 261,
262, 264, 265, 266, 268, 269, 270, 272, 273, 274, 276, 277, 278, 280,
281, 283, 284, 285, 287, 288, 289, 291, 292, 293, 295, 296, 297, 299,
300, 302, 303, 304, 306, 307, 308, 310, 311, 312, 314, 315, 317, 318,
319, 321, 322, 323, 325, 326, 327, 329, 330, 331, 333, 334, 336, 337,
338, 340, 341, 342, 344, 345, 346 };
static INT16 L[] = {
0, 1, 3, 4, 5, 7, 8, 10, 11, 12, 14, 15, 16, 18, 19, 20,
22, 23, 24, 26, 27, 29, 30, 31, 33, 34, 35, 37, 38, 39, 41, 42,
43, 45, 46, 48, 49, 50, 52, 53, 54, 56, 57, 58, 60, 61, 62, 64,
65, 67, 68, 69, 71, 72, 73, 75, 76, 77, 79, 80, 82, 83, 84, 86,
87, 88, 90, 91, 92, 94, 95, 96, 98, 99, 101, 102, 103, 105, 106, 107,
109, 110, 111, 113, 114, 115, 117, 118, 120, 121, 122, 124, 125, 126, 128, 129,
130, 132, 133, 134, 136, 137, 139, 140, 141, 143, 144, 145, 147, 148, 149, 151,
152, 153, 155, 156, 158, 159, 160, 162, 163, 164, 166, 167, 168, 170, 171, 173,
174, 175, 177, 178, 179, 181, 182, 183, 185, 186, 187, 189, 190, 192, 193, 194,
196, 197, 198, 200, 201, 202, 204, 205, 206, 208, 209, 211, 212, 213, 215, 216,
217, 219, 220, 221, 223, 224, 225, 227, 228, 230, 231, 232, 234, 235, 236, 238,
239, 240, 242, 243, 245, 246, 247, 249, 250, 251, 253, 254, 255, 257, 258, 259,
261, 262, 264, 265, 266, 268, 269, 270, 272, 273, 274, 276, 277, 278, 280, 281,
283, 284, 285, 287, 288, 289, 291, 292, 293, 295, 296, 297, 299, 300, 302, 303,
304, 306, 307, 308, 310, 311, 312, 314, 315, 317, 318, 319, 321, 322, 323, 325,
326, 327, 329, 330, 331, 333, 334, 336, 337, 338, 340, 341, 342, 344, 345, 346};
static INT16 CB[] = { -345, -343, -341, -338, -336, -334, -332, -329,
-327, -325, -323, -321, -318, -316, -314, -312, -310, -307, -305,
-303, -301, -298, -296, -294, -292, -290, -287, -285, -283, -281,
-278, -276, -274, -272, -270, -267, -265, -263, -261, -258, -256,
-254, -252, -250, -247, -245, -243, -241, -239, -236, -234, -232,
-230, -227, -225, -223, -221, -219, -216, -214, -212, -210, -207,
-205, -203, -201, -199, -196, -194, -192, -190, -188, -185, -183,
-181, -179, -176, -174, -172, -170, -168, -165, -163, -161, -159,
-156, -154, -152, -150, -148, -145, -143, -141, -139, -137, -134,
-132, -130, -128, -125, -123, -121, -119, -117, -114, -112, -110,
-108, -105, -103, -101, -99, -97, -94, -92, -90, -88, -85, -83, -81,
-79, -77, -74, -72, -70, -68, -66, -63, -61, -59, -57, -54, -52, -50,
-48, -46, -43, -41, -39, -37, -34, -32, -30, -28, -26, -23, -21, -19,
-17, -15, -12, -10, -8, -6, -3, -1, 0, 2, 4, 7, 9, 11, 13, 16, 18, 20,
22, 24, 27, 29, 31, 33, 35, 38, 40, 42, 44, 47, 49, 51, 53, 55, 58,
60, 62, 64, 67, 69, 71, 73, 75, 78, 80, 82, 84, 86, 89, 91, 93, 95,
98, 100, 102, 104, 106, 109, 111, 113, 115, 118, 120, 122, 124, 126,
129, 131, 133, 135, 138, 140, 142, 144, 146, 149, 151, 153, 155, 157,
160, 162, 164, 166, 169, 171, 173, 175, 177, 180, 182, 184, 186, 189,
191, 193, 195, 197, 200, 202, 204, 206, 208, 211, 213, 215, 217, 220 };
static INT16 CB[] = {
-345, -343, -341, -338, -336, -334, -332, -329, -327, -325, -323, -321, -318, -316,
-314, -312, -310, -307, -305, -303, -301, -298, -296, -294, -292, -290, -287, -285,
-283, -281, -278, -276, -274, -272, -270, -267, -265, -263, -261, -258, -256, -254,
-252, -250, -247, -245, -243, -241, -239, -236, -234, -232, -230, -227, -225, -223,
-221, -219, -216, -214, -212, -210, -207, -205, -203, -201, -199, -196, -194, -192,
-190, -188, -185, -183, -181, -179, -176, -174, -172, -170, -168, -165, -163, -161,
-159, -156, -154, -152, -150, -148, -145, -143, -141, -139, -137, -134, -132, -130,
-128, -125, -123, -121, -119, -117, -114, -112, -110, -108, -105, -103, -101, -99,
-97, -94, -92, -90, -88, -85, -83, -81, -79, -77, -74, -72, -70, -68,
-66, -63, -61, -59, -57, -54, -52, -50, -48, -46, -43, -41, -39, -37,
-34, -32, -30, -28, -26, -23, -21, -19, -17, -15, -12, -10, -8, -6,
-3, -1, 0, 2, 4, 7, 9, 11, 13, 16, 18, 20, 22, 24,
27, 29, 31, 33, 35, 38, 40, 42, 44, 47, 49, 51, 53, 55,
58, 60, 62, 64, 67, 69, 71, 73, 75, 78, 80, 82, 84, 86,
89, 91, 93, 95, 98, 100, 102, 104, 106, 109, 111, 113, 115, 118,
120, 122, 124, 126, 129, 131, 133, 135, 138, 140, 142, 144, 146, 149,
151, 153, 155, 157, 160, 162, 164, 166, 169, 171, 173, 175, 177, 180,
182, 184, 186, 189, 191, 193, 195, 197, 200, 202, 204, 206, 208, 211,
213, 215, 217, 220};
static INT16 GB[] = { 67, 67, 66, 66, 65, 65, 65, 64, 64, 63, 63, 62,
62, 62, 61, 61, 60, 60, 59, 59, 59, 58, 58, 57, 57, 56, 56, 56, 55,
55, 54, 54, 53, 53, 52, 52, 52, 51, 51, 50, 50, 49, 49, 49, 48, 48,
47, 47, 46, 46, 46, 45, 45, 44, 44, 43, 43, 43, 42, 42, 41, 41, 40,
40, 40, 39, 39, 38, 38, 37, 37, 37, 36, 36, 35, 35, 34, 34, 34, 33,
33, 32, 32, 31, 31, 31, 30, 30, 29, 29, 28, 28, 28, 27, 27, 26, 26,
25, 25, 25, 24, 24, 23, 23, 22, 22, 22, 21, 21, 20, 20, 19, 19, 19,
18, 18, 17, 17, 16, 16, 15, 15, 15, 14, 14, 13, 13, 12, 12, 12, 11,
11, 10, 10, 9, 9, 9, 8, 8, 7, 7, 6, 6, 6, 5, 5, 4, 4, 3, 3, 3, 2, 2,
1, 1, 0, 0, 0, 0, 0, -1, -1, -2, -2, -2, -3, -3, -4, -4, -5, -5, -5,
-6, -6, -7, -7, -8, -8, -8, -9, -9, -10, -10, -11, -11, -11, -12, -12,
-13, -13, -14, -14, -14, -15, -15, -16, -16, -17, -17, -18, -18, -18,
-19, -19, -20, -20, -21, -21, -21, -22, -22, -23, -23, -24, -24, -24,
-25, -25, -26, -26, -27, -27, -27, -28, -28, -29, -29, -30, -30, -30,
-31, -31, -32, -32, -33, -33, -33, -34, -34, -35, -35, -36, -36, -36,
-37, -37, -38, -38, -39, -39, -39, -40, -40, -41, -41, -42 };
static INT16 GB[] = {
67, 67, 66, 66, 65, 65, 65, 64, 64, 63, 63, 62, 62, 62, 61, 61,
60, 60, 59, 59, 59, 58, 58, 57, 57, 56, 56, 56, 55, 55, 54, 54,
53, 53, 52, 52, 52, 51, 51, 50, 50, 49, 49, 49, 48, 48, 47, 47,
46, 46, 46, 45, 45, 44, 44, 43, 43, 43, 42, 42, 41, 41, 40, 40,
40, 39, 39, 38, 38, 37, 37, 37, 36, 36, 35, 35, 34, 34, 34, 33,
33, 32, 32, 31, 31, 31, 30, 30, 29, 29, 28, 28, 28, 27, 27, 26,
26, 25, 25, 25, 24, 24, 23, 23, 22, 22, 22, 21, 21, 20, 20, 19,
19, 19, 18, 18, 17, 17, 16, 16, 15, 15, 15, 14, 14, 13, 13, 12,
12, 12, 11, 11, 10, 10, 9, 9, 9, 8, 8, 7, 7, 6, 6, 6,
5, 5, 4, 4, 3, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0,
-1, -1, -2, -2, -2, -3, -3, -4, -4, -5, -5, -5, -6, -6, -7, -7,
-8, -8, -8, -9, -9, -10, -10, -11, -11, -11, -12, -12, -13, -13, -14, -14,
-14, -15, -15, -16, -16, -17, -17, -18, -18, -18, -19, -19, -20, -20, -21, -21,
-21, -22, -22, -23, -23, -24, -24, -24, -25, -25, -26, -26, -27, -27, -27, -28,
-28, -29, -29, -30, -30, -30, -31, -31, -32, -32, -33, -33, -33, -34, -34, -35,
-35, -36, -36, -36, -37, -37, -38, -38, -39, -39, -39, -40, -40, -41, -41, -42};
static INT16 CR[] = { -249, -247, -245, -243, -241, -239, -238, -236,
-234, -232, -230, -229, -227, -225, -223, -221, -219, -218, -216,
-214, -212, -210, -208, -207, -205, -203, -201, -199, -198, -196,
-194, -192, -190, -188, -187, -185, -183, -181, -179, -178, -176,
-174, -172, -170, -168, -167, -165, -163, -161, -159, -157, -156,
-154, -152, -150, -148, -147, -145, -143, -141, -139, -137, -136,
-134, -132, -130, -128, -127, -125, -123, -121, -119, -117, -116,
-114, -112, -110, -108, -106, -105, -103, -101, -99, -97, -96, -94,
-92, -90, -88, -86, -85, -83, -81, -79, -77, -76, -74, -72, -70, -68,
-66, -65, -63, -61, -59, -57, -55, -54, -52, -50, -48, -46, -45, -43,
-41, -39, -37, -35, -34, -32, -30, -28, -26, -25, -23, -21, -19, -17,
-15, -14, -12, -10, -8, -6, -4, -3, -1, 0, 2, 4, 5, 7, 9, 11, 13, 15,
16, 18, 20, 22, 24, 26, 27, 29, 31, 33, 35, 36, 38, 40, 42, 44, 46,
47, 49, 51, 53, 55, 56, 58, 60, 62, 64, 66, 67, 69, 71, 73, 75, 77,
78, 80, 82, 84, 86, 87, 89, 91, 93, 95, 97, 98, 100, 102, 104, 106,
static INT16 CR[] = {
-249, -247, -245, -243, -241, -239, -238, -236, -234, -232, -230, -229, -227, -225,
-223, -221, -219, -218, -216, -214, -212, -210, -208, -207, -205, -203, -201, -199,
-198, -196, -194, -192, -190, -188, -187, -185, -183, -181, -179, -178, -176, -174,
-172, -170, -168, -167, -165, -163, -161, -159, -157, -156, -154, -152, -150, -148,
-147, -145, -143, -141, -139, -137, -136, -134, -132, -130, -128, -127, -125, -123,
-121, -119, -117, -116, -114, -112, -110, -108, -106, -105, -103, -101, -99, -97,
-96, -94, -92, -90, -88, -86, -85, -83, -81, -79, -77, -76, -74, -72,
-70, -68, -66, -65, -63, -61, -59, -57, -55, -54, -52, -50, -48, -46,
-45, -43, -41, -39, -37, -35, -34, -32, -30, -28, -26, -25, -23, -21,
-19, -17, -15, -14, -12, -10, -8, -6, -4, -3, -1, 0, 2, 4,
5, 7, 9, 11, 13, 15, 16, 18, 20, 22, 24, 26, 27, 29,
31, 33, 35, 36, 38, 40, 42, 44, 46, 47, 49, 51, 53, 55,
56, 58, 60, 62, 64, 66, 67, 69, 71, 73, 75, 77, 78, 80,
82, 84, 86, 87, 89, 91, 93, 95, 97, 98, 100, 102, 104, 106,
107, 109, 111, 113, 115, 117, 118, 120, 122, 124, 126, 128, 129, 131,
133, 135, 137, 138, 140, 142, 144, 146, 148, 149, 151, 153, 155, 157,
158, 160, 162, 164, 166, 168, 169, 171, 173, 175, 177, 179, 180, 182,
184, 186, 188, 189, 191, 193, 195, 197, 199, 200, 202, 204, 206, 208,
209, 211, 213, 215};
static INT16 GR[] = { 127, 126, 125, 124, 123, 122, 121, 121, 120, 119,
118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 108, 107, 106,
105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 95, 94, 93, 92, 91,
90, 89, 88, 87, 86, 85, 84, 83, 83, 82, 81, 80, 79, 78, 77, 76, 75,
74, 73, 72, 71, 70, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59,
58, 57, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 45, 44,
43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 32, 31, 30, 29, 28,
27, 26, 25, 24, 23, 22, 21, 20, 19, 19, 18, 17, 16, 15, 14, 13, 12,
11, 10, 9, 8, 7, 6, 6, 5, 4, 3, 2, 1, 0, 0, -1, -2, -3, -4, -5, -5,
-6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -18, -19,
-20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30, -31, -31, -32,
-33, -34, -35, -36, -37, -38, -39, -40, -41, -42, -43, -44, -44, -45,
-46, -47, -48, -49, -50, -51, -52, -53, -54, -55, -56, -56, -57, -58,
-59, -60, -61, -62, -63, -64, -65, -66, -67, -68, -69, -69, -70, -71,
-72, -73, -74, -75, -76, -77, -78, -79, -80, -81, -82, -82, -83, -84,
-85, -86, -87, -88, -89, -90, -91, -92, -93, -94, -94, -95, -96, -97,
-98, -99, -100, -101, -102, -103, -104, -105, -106, -107, -107, -108 };
static INT16 GR[] = {
127, 126, 125, 124, 123, 122, 121, 121, 120, 119, 118, 117, 116, 115, 114,
113, 112, 111, 110, 109, 108, 108, 107, 106, 105, 104, 103, 102, 101, 100,
99, 98, 97, 96, 95, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86,
85, 84, 83, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72,
71, 70, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58,
57, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 45,
44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 32, 31,
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 19, 18, 17,
16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 6, 5, 4, 3,
2, 1, 0, 0, -1, -2, -3, -4, -5, -5, -6, -7, -8, -9, -10,
-11, -12, -13, -14, -15, -16, -17, -18, -18, -19, -20, -21, -22, -23, -24,
-25, -26, -27, -28, -29, -30, -31, -31, -32, -33, -34, -35, -36, -37, -38,
-39, -40, -41, -42, -43, -44, -44, -45, -46, -47, -48, -49, -50, -51, -52,
-53, -54, -55, -56, -56, -57, -58, -59, -60, -61, -62, -63, -64, -65, -66,
-67, -68, -69, -69, -70, -71, -72, -73, -74, -75, -76, -77, -78, -79, -80,
-81, -82, -82, -83, -84, -85, -86, -87, -88, -89, -90, -91, -92, -93, -94,
-94, -95, -96, -97, -98, -99, -100, -101, -102, -103, -104, -105, -106, -107, -107,
-108};
#define R 0
#define G 1
#define B 2
#define A 3
#define YCC2RGB(rgb, y, cb, cr) {\
#define YCC2RGB(rgb, y, cb, cr) \
{ \
int l = L[y]; \
int r = l + CR[cr]; \
int g = l + GR[cr] + GB[cb]; \
@ -132,20 +133,19 @@ static INT16 GR[] = { 127, 126, 125, 124, 123, 122, 121, 121, 120, 119,
}
void
ImagingUnpackYCC(UINT8* out, const UINT8* in, int pixels)
{
ImagingUnpackYCC(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* PhotoYCC triplets */
for (i = 0; i < pixels; i++) {
YCC2RGB(out, in[0], in[1], in[2]);
out[A] = 255;
out += 4; in += 3;
out += 4;
in += 3;
}
}
void
ImagingUnpackYCCA(UINT8* out, const UINT8* in, int pixels)
{
ImagingUnpackYCCA(UINT8 *out, const UINT8 *in, int pixels) {
int i;
/* PhotoYCC triplets plus premultiplied alpha */
for (i = 0; i < pixels; i++) {
@ -157,6 +157,7 @@ ImagingUnpackYCCA(UINT8* out, const UINT8* in, int pixels)
/* Convert non-multiplied data to RGB */
YCC2RGB(out, rgb[0], rgb[1], rgb[2]);
out[A] = in[3];
out += 4; in += 4;
out += 4;
in += 4;
}
}

35
src/libImaging/UnsharpMask.c
View File

@ -8,12 +8,10 @@
#include "Imaging.h"
typedef UINT8 pixel[4];
static inline UINT8 clip8(int in)
{
static inline UINT8
clip8(int in) {
if (in >= 255) {
return 255;
}
@ -23,11 +21,9 @@ static inline UINT8 clip8(int in)
return (UINT8)in;
}
Imaging
ImagingUnsharpMask(Imaging imOut, Imaging imIn, float radius, int percent,
int threshold)
{
ImagingUnsharpMask(
Imaging imOut, Imaging imIn, float radius, int percent, int threshold) {
ImagingSectionCookie cookie;
Imaging result;
@ -53,8 +49,7 @@ ImagingUnsharpMask(Imaging imOut, Imaging imIn, float radius, int percent,
ImagingSectionEnter(&cookie);
for (y = 0; y < imIn->ysize; y++) {
if (imIn->image8)
{
if (imIn->image8) {
lineIn8 = imIn->image8[y];
lineOut8 = imOut->image8[y];
for (x = 0; x < imIn->xsize; x++) {
@ -74,20 +69,24 @@ ImagingUnsharpMask(Imaging imOut, Imaging imIn, float radius, int percent,
for (x = 0; x < imIn->xsize; x++) {
/* compare in/out pixels, apply sharpening */
diff = lineIn[x][0] - lineOut[x][0];
lineOut[x][0] = abs(diff) > threshold ?
clip8(lineIn[x][0] + diff * percent / 100) : lineIn[x][0];
lineOut[x][0] = abs(diff) > threshold
? clip8(lineIn[x][0] + diff * percent / 100)
: lineIn[x][0];
diff = lineIn[x][1] - lineOut[x][1];
lineOut[x][1] = abs(diff) > threshold ?
clip8(lineIn[x][1] + diff * percent / 100) : lineIn[x][1];
lineOut[x][1] = abs(diff) > threshold
? clip8(lineIn[x][1] + diff * percent / 100)
: lineIn[x][1];
diff = lineIn[x][2] - lineOut[x][2];
lineOut[x][2] = abs(diff) > threshold ?
clip8(lineIn[x][2] + diff * percent / 100) : lineIn[x][2];
lineOut[x][2] = abs(diff) > threshold
? clip8(lineIn[x][2] + diff * percent / 100)
: lineIn[x][2];
diff = lineIn[x][3] - lineOut[x][3];
lineOut[x][3] = abs(diff) > threshold ?
clip8(lineIn[x][3] + diff * percent / 100) : lineIn[x][3];
lineOut[x][3] = abs(diff) > threshold
? clip8(lineIn[x][3] + diff * percent / 100)
: lineIn[x][3];
}
}
}

21
src/libImaging/XbmDecode.c
View File

@ -13,16 +13,16 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#define HEX(v) ((v >= '0' && v <= '9') ? v - '0' :\
(v >= 'a' && v <= 'f') ? v - 'a' + 10 :\
(v >= 'A' && v <= 'F') ? v - 'A' + 10 : 0)
#define HEX(v) \
((v >= '0' && v <= '9') ? v - '0' \
: (v >= 'a' && v <= 'f') ? v - 'a' + 10 \
: (v >= 'A' && v <= 'F') ? v - 'A' + 10 \
: 0)
int
ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
enum { BYTE = 1, SKIP };
UINT8 *ptr;
@ -34,9 +34,7 @@ ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
ptr = buf;
for (;;) {
if (state->state == SKIP) {
/* Skip forward until next 'x' */
while (bytes > 0) {
@ -52,7 +50,6 @@ ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
}
state->state = BYTE;
}
if (bytes < 3) {
@ -62,10 +59,8 @@ ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
state->buffer[state->x] = (HEX(ptr[1]) << 4) + HEX(ptr[2]);
if (++state->x >= state->bytes) {
/* Got a full line, unpack it */
state->shuffle((UINT8*) im->image[state->y], state->buffer,
state->xsize);
state->shuffle((UINT8 *)im->image[state->y], state->buffer, state->xsize);
state->x = 0;
@ -79,7 +74,5 @@ ImagingXbmDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
bytes -= 3;
state->state = SKIP;
}
}

21
src/libImaging/XbmEncode.c
View File

@ -13,25 +13,20 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
int
ImagingXbmEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingXbmEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
const char *hex = "0123456789abcdef";
UINT8 *ptr = buf;
int i, n;
if (!state->state) {
/* 8 pixels are stored in no more than 6 bytes */
state->bytes = 6 * (state->xsize + 7) / 8;
state->state = 1;
}
if (bytes < state->bytes) {
@ -42,16 +37,14 @@ ImagingXbmEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
ptr = buf;
while (bytes >= state->bytes) {
state->shuffle(state->buffer,
(UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->xsize);
state->shuffle(
state->buffer,
(UINT8 *)im->image[state->y + state->yoff] + state->xoff * im->pixelsize,
state->xsize);
if (state->y < state->ysize - 1) {
/* any line but the last */
for (n = 0; n < state->xsize; n += 8) {
i = state->buffer[n / 8];
*ptr++ = '0';
@ -66,16 +59,13 @@ ImagingXbmEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
bytes--;
state->count = 0;
}
}
state->y++;
} else {
/* last line */
for (n = 0; n < state->xsize; n += 8) {
i = state->buffer[n / 8];
*ptr++ = '0';
@ -95,7 +85,6 @@ ImagingXbmEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
bytes -= 5;
}
state->errcode = IMAGING_CODEC_END;

4
src/libImaging/ZipCodecs.h
View File

@ -7,19 +7,15 @@
* Copyright (c) Fredrik Lundh 1996.
*/
#include "zlib.h"
/* modes */
#define ZIP_PNG 0 /* continuous, filtered image data */
#define ZIP_PNG_PALETTE 1 /* non-continuous data, disable filtering */
#define ZIP_TIFF_PREDICTOR 2 /* TIFF, with predictor */
#define ZIP_TIFF 3 /* TIFF, without predictor */
typedef struct {
/* CONFIGURATION */
/* Codec mode */

47
src/libImaging/ZipDecode.c
View File

@ -15,7 +15,6 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#ifdef HAVE_LIBZ
@ -30,8 +29,8 @@ static const int ROW_INCREMENT[] = { 8, 8, 8, 4, 4, 2, 2 };
/* Get the length in bytes of a scanline in the pass specified,
* for interlaced images */
static int get_row_len(ImagingCodecState state, int pass)
{
static int
get_row_len(ImagingCodecState state, int pass) {
int row_len = (state->xsize + OFFSET[pass]) / COL_INCREMENT[pass];
return ((row_len * state->bits) + 7) / 8;
}
@ -41,8 +40,7 @@ static int get_row_len(ImagingCodecState state, int pass)
/* -------------------------------------------------------------------- */
int
ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t bytes)
{
ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8 *buf, Py_ssize_t bytes) {
ZIPSTATE *context = (ZIPSTATE *)state->context;
int err;
int n;
@ -51,7 +49,6 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
int row_len;
if (!state->state) {
/* Initialization */
if (context->mode == ZIP_PNG || context->mode == ZIP_PNG_PALETTE) {
context->prefix = 1; /* PNG */
@ -98,7 +95,6 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
/* Ready to decode */
state->state = 1;
}
if (context->interlaced) {
@ -113,10 +109,8 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
/* Decompress what we've got this far */
while (context->z_stream.avail_in > 0) {
context->z_stream.next_out = state->buffer + context->last_output;
context->z_stream.avail_out =
row_len + context->prefix - context->last_output;
context->z_stream.avail_out = row_len + context->prefix - context->last_output;
err = inflate(&context->z_stream, Z_NO_FLUSH);
@ -193,9 +187,9 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
pc = abs(a + b - 2 * c);
/* pick predictor with the shortest distance */
state->buffer[i] +=
(pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
state->buffer[i] += (pa <= pb && pa <= pc) ? a
: (pb <= pc) ? b
: c;
}
break;
default:
@ -220,20 +214,22 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
if (state->bits >= 8) {
/* Stuff pixels in their correct location, one by one */
for (i = 0; i < row_len; i += ((state->bits + 7) / 8)) {
state->shuffle((UINT8*) im->image[state->y] +
col * im->pixelsize,
state->buffer + context->prefix + i, 1);
state->shuffle(
(UINT8 *)im->image[state->y] + col * im->pixelsize,
state->buffer + context->prefix + i,
1);
col += COL_INCREMENT[context->pass];
}
} else {
/* Handle case with more than a pixel in each byte */
int row_bits = ((state->xsize + OFFSET[context->pass])
/ COL_INCREMENT[context->pass]) * state->bits;
int row_bits = ((state->xsize + OFFSET[context->pass]) /
COL_INCREMENT[context->pass]) *
state->bits;
for (i = 0; i < row_bits; i += state->bits) {
UINT8 byte = *(state->buffer + context->prefix + (i / 8));
byte <<= (i % 8);
state->shuffle((UINT8*) im->image[state->y] +
col * im->pixelsize, &byte, 1);
state->shuffle(
(UINT8 *)im->image[state->y] + col * im->pixelsize, &byte, 1);
col += COL_INCREMENT[context->pass];
}
}
@ -253,7 +249,8 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
memset(state->buffer, 0, state->bytes + 1);
}
} else {
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->shuffle(
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->buffer + context->prefix,
state->xsize);
@ -264,7 +261,6 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
context->last_output = 0;
if (state->y >= state->ysize || err == Z_STREAM_END) {
/* The image and the data should end simultaneously */
/* if (state->y < state->ysize || err != Z_STREAM_END)
state->errcode = IMAGING_CODEC_BROKEN; */
@ -273,22 +269,19 @@ ImagingZipDecode(Imaging im, ImagingCodecState state, UINT8* buf, Py_ssize_t byt
context->previous = NULL;
inflateEnd(&context->z_stream);
return -1; /* end of file (errcode=0) */
}
/* Swap buffer pointers */
ptr = state->buffer;
state->buffer = context->previous;
context->previous = ptr;
}
return bytes; /* consumed all of it */
}
int ImagingZipDecodeCleanup(ImagingCodecState state){
int
ImagingZipDecodeCleanup(ImagingCodecState state) {
/* called to free the decompression engine when the decode terminates
due to a corrupt or truncated image
*/

56
src/libImaging/ZipEncode.c
View File

@ -14,7 +14,6 @@
* See the README file for information on usage and redistribution.
*/
#include "Imaging.h"
#ifdef HAVE_LIBZ
@ -22,8 +21,7 @@
#include "ZipCodecs.h"
int
ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8 *buf, int bytes) {
ZIPSTATE *context = (ZIPSTATE *)state->context;
int err;
int compress_level, compress_type;
@ -32,7 +30,6 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
ImagingSectionCookie cookie;
if (!state->state) {
/* Initialization */
/* Valid modes are ZIP_PNG, ZIP_PNG_PALETTE, and ZIP_TIFF */
@ -53,8 +50,8 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
context->up = (UINT8 *)malloc(state->bytes + 1);
context->average = (UINT8 *)malloc(state->bytes + 1);
context->paeth = (UINT8 *)malloc(state->bytes + 1);
if (!state->buffer || !context->previous || !context->prior ||
!context->up || !context->average || !context->paeth) {
if (!state->buffer || !context->previous || !context->prior || !context->up ||
!context->average || !context->paeth) {
free(context->paeth);
free(context->average);
free(context->up);
@ -81,23 +78,25 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
context->z_stream.next_in = 0;
context->z_stream.avail_in = 0;
compress_level = (context->optimize) ? Z_BEST_COMPRESSION
: context->compress_level;
compress_level =
(context->optimize) ? Z_BEST_COMPRESSION : context->compress_level;
if (context->compress_type == -1) {
compress_type = (context->mode == ZIP_PNG) ? Z_FILTERED
: Z_DEFAULT_STRATEGY;
compress_type =
(context->mode == ZIP_PNG) ? Z_FILTERED : Z_DEFAULT_STRATEGY;
} else {
compress_type = context->compress_type;
}
err = deflateInit2(&context->z_stream,
err = deflateInit2(
&context->z_stream,
/* compression level */
compress_level,
/* compression method */
Z_DEFLATED,
/* compression memory resources */
15, 9,
15,
9,
/* compression strategy (image data are filtered)*/
compress_type);
if (err < 0) {
@ -106,7 +105,9 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
if (context->dictionary && context->dictionary_size > 0) {
err = deflateSetDictionary(&context->z_stream, (unsigned char *)context->dictionary,
err = deflateSetDictionary(
&context->z_stream,
(unsigned char *)context->dictionary,
context->dictionary_size);
if (err < 0) {
state->errcode = IMAGING_CODEC_CONFIG;
@ -116,7 +117,6 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
/* Ready to decode */
state->state = 1;
}
/* Setup the destination buffer */
@ -147,23 +147,20 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
ImagingSectionEnter(&cookie);
for (;;) {
switch (state->state) {
case 1:
/* Compress image data */
while (context->z_stream.avail_out > 0) {
if (state->y >= state->ysize) {
/* End of image; now flush compressor buffers */
state->state = 2;
break;
}
/* Stuff image data into the compressor */
state->shuffle(state->buffer+1,
state->shuffle(
state->buffer + 1,
(UINT8 *)im->image[state->y + state->yoff] +
state->xoff * im->pixelsize,
state->xsize);
@ -173,7 +170,6 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
context->output = state->buffer;
if (context->mode == ZIP_PNG) {
/* Filter the image data. For each line, select
the filter that gives the least total distance
from zero for the filtered data (taken from
@ -228,7 +224,8 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
s += (v < 128) ? v : 256 - v;
}
for (; i <= state->bytes; i++) {
UINT8 v = state->buffer[i] -
UINT8 v =
state->buffer[i] -
(state->buffer[i - bpp] + context->previous[i]) / 2;
context->average[i] = v;
s += (v < 128) ? v : 256 - v;
@ -262,9 +259,9 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
pc = abs(a + b - 2 * c);
/* pick predictor with the shortest distance */
v = state->buffer[i] -
((pa <= pb && pa <= pc) ? a :
(pb <= pc) ? b : c);
v = state->buffer[i] - ((pa <= pb && pa <= pc) ? a
: (pb <= pc) ? b
: c);
context->paeth[i] = v;
s += (v < 128) ? v : 256 - v;
}
@ -304,7 +301,6 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
ptr = state->buffer;
state->buffer = context->previous;
context->previous = ptr;
}
if (context->z_stream.avail_out == 0) {
@ -316,11 +312,9 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
/* End of image data; flush compressor buffers */
while (context->z_stream.avail_out > 0) {
err = deflate(&context->z_stream, Z_FINISH);
if (err == Z_STREAM_END) {
free(context->paeth);
free(context->average);
free(context->up);
@ -337,13 +331,10 @@ ImagingZipEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
if (context->z_stream.avail_out == 0) {
break; /* Buffer full */
}
}
}
ImagingSectionLeave(&cookie);
return bytes - context->z_stream.avail_out;
}
/* Should never ever arrive here... */
@ -368,11 +359,8 @@ ImagingZipEncodeCleanup(ImagingCodecState state) {
return -1;
}
const char *
ImagingZipVersion(void)
{
ImagingZipVersion(void) {
return zlibVersion();
}

17
src/libImaging/codec_fd.c
View File

@ -1,10 +1,8 @@
#include "Python.h"
#include "Imaging.h"
Py_ssize_t
_imaging_read_pyFd(PyObject *fd, char* dest, Py_ssize_t bytes)
{
_imaging_read_pyFd(PyObject *fd, char *dest, Py_ssize_t bytes) {
/* dest should be a buffer bytes long, returns length of read
-1 on error */
@ -32,13 +30,10 @@ _imaging_read_pyFd(PyObject *fd, char* dest, Py_ssize_t bytes)
err:
Py_DECREF(result);
return -1;
}
Py_ssize_t
_imaging_write_pyFd(PyObject *fd, char* src, Py_ssize_t bytes)
{
_imaging_write_pyFd(PyObject *fd, char *src, Py_ssize_t bytes) {
PyObject *result;
PyObject *byteObj;
@ -49,24 +44,20 @@ _imaging_write_pyFd(PyObject *fd, char* src, Py_ssize_t bytes)
Py_DECREF(result);
return bytes;
}
int
_imaging_seek_pyFd(PyObject *fd, Py_ssize_t offset, int whence)
{
_imaging_seek_pyFd(PyObject *fd, Py_ssize_t offset, int whence) {
PyObject *result;
result = PyObject_CallMethod(fd, "seek", "ni", offset, whence);
Py_DECREF(result);
return 0;
}
Py_ssize_t
_imaging_tell_pyFd(PyObject *fd)
{
_imaging_tell_pyFd(PyObject *fd) {
PyObject *result;
Py_ssize_t location;

48
src/libImaging/raqm.h
View File

@ -63,8 +63,7 @@ typedef struct _raqm raqm_t;
*
* Since: 0.1
*/
typedef enum
{
typedef enum {
RAQM_DIRECTION_DEFAULT,
RAQM_DIRECTION_RTL,
RAQM_DIRECTION_LTR,
@ -106,7 +105,6 @@ typedef struct raqm_glyph_t_01 {
uint32_t cluster;
} raqm_glyph_t_01;
raqm_t *
raqm_create(void);
@ -117,62 +115,40 @@ void
raqm_destroy(raqm_t *rq);
bool
raqm_set_text (raqm_t *rq,
const uint32_t *text,
size_t len);
raqm_set_text(raqm_t *rq, const uint32_t *text, size_t len);
bool
raqm_set_text_utf8 (raqm_t *rq,
const char *text,
size_t len);
raqm_set_text_utf8(raqm_t *rq, const char *text, size_t len);
bool
raqm_set_par_direction (raqm_t *rq,
raqm_direction_t dir);
raqm_set_par_direction(raqm_t *rq, raqm_direction_t dir);
bool
raqm_set_language (raqm_t *rq,
const char *lang,
size_t start,
size_t len);
raqm_set_language(raqm_t *rq, const char *lang, size_t start, size_t len);
bool
raqm_add_font_feature (raqm_t *rq,
const char *feature,
int len);
raqm_add_font_feature(raqm_t *rq, const char *feature, int len);
bool
raqm_set_freetype_face (raqm_t *rq,
FT_Face face);
raqm_set_freetype_face(raqm_t *rq, FT_Face face);
bool
raqm_set_freetype_face_range (raqm_t *rq,
FT_Face face,
size_t start,
size_t len);
raqm_set_freetype_face_range(raqm_t *rq, FT_Face face, size_t start, size_t len);
bool
raqm_set_freetype_load_flags (raqm_t *rq,
int flags);
raqm_set_freetype_load_flags(raqm_t *rq, int flags);
bool
raqm_layout(raqm_t *rq);
raqm_glyph_t *
raqm_get_glyphs (raqm_t *rq,
size_t *length);
raqm_get_glyphs(raqm_t *rq, size_t *length);
bool
raqm_index_to_position (raqm_t *rq,
size_t *index,
int *x,
int *y);
raqm_index_to_position(raqm_t *rq, size_t *index, int *x, int *y);
bool
raqm_position_to_index (raqm_t *rq,
int x,
int y,
size_t *index);
raqm_position_to_index(raqm_t *rq, int x, int y, size_t *index);
#ifdef __cplusplus
}

76
src/map.c
View File

@ -23,15 +23,16 @@
#include "libImaging/Imaging.h"
/* compatibility wrappers (defined in _imaging.c) */
extern int PyImaging_CheckBuffer(PyObject* buffer);
extern int PyImaging_GetBuffer(PyObject* buffer, Py_buffer *view);
extern int
PyImaging_CheckBuffer(PyObject *buffer);
extern int
PyImaging_GetBuffer(PyObject *buffer, Py_buffer *view);
/* -------------------------------------------------------------------- */
/* Standard mapper */
typedef struct {
PyObject_HEAD
char* base;
PyObject_HEAD char *base;
int size;
int offset;
#ifdef _WIN32
@ -43,8 +44,7 @@ typedef struct {
static PyTypeObject ImagingMapperType;
ImagingMapperObject *
PyImaging_MapperNew(const char* filename, int readonly)
{
PyImaging_MapperNew(const char *filename, int readonly) {
ImagingMapperObject *mapper;
if (PyType_Ready(&ImagingMapperType) < 0) {
@ -68,7 +68,8 @@ PyImaging_MapperNew(const char* filename, int readonly)
filename,
GENERIC_READ,
FILE_SHARE_READ,
NULL, OPEN_EXISTING,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (mapper->hFile == (HANDLE)-1) {
@ -77,10 +78,7 @@ PyImaging_MapperNew(const char* filename, int readonly)
return NULL;
}
mapper->hMap = CreateFileMapping(
mapper->hFile, NULL,
PAGE_READONLY,
0, 0, NULL);
mapper->hMap = CreateFileMapping(mapper->hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (mapper->hMap == (HANDLE)-1) {
CloseHandle(mapper->hFile);
PyErr_SetString(PyExc_OSError, "cannot map file");
@ -88,10 +86,7 @@ PyImaging_MapperNew(const char* filename, int readonly)
return NULL;
}
mapper->base = (char*) MapViewOfFile(
mapper->hMap,
FILE_MAP_READ,
0, 0, 0);
mapper->base = (char *)MapViewOfFile(mapper->hMap, FILE_MAP_READ, 0, 0, 0);
mapper->size = GetFileSize(mapper->hFile, 0);
#endif
@ -100,8 +95,7 @@ PyImaging_MapperNew(const char* filename, int readonly)
}
static void
mapping_dealloc(ImagingMapperObject* mapper)
{
mapping_dealloc(ImagingMapperObject *mapper) {
#ifdef _WIN32
if (mapper->base != 0) {
UnmapViewOfFile(mapper->base);
@ -122,8 +116,7 @@ mapping_dealloc(ImagingMapperObject* mapper)
/* standard file operations */
static PyObject *
mapping_read(ImagingMapperObject* mapper, PyObject* args)
{
mapping_read(ImagingMapperObject *mapper, PyObject *args) {
PyObject *buf;
int size = -1;
@ -153,8 +146,7 @@ mapping_read(ImagingMapperObject* mapper, PyObject* args)
}
static PyObject *
mapping_seek(ImagingMapperObject* mapper, PyObject* args)
{
mapping_seek(ImagingMapperObject *mapper, PyObject *args) {
int offset;
int whence = 0;
if (!PyArg_ParseTuple(args, "i|i", &offset, &whence)) {
@ -183,17 +175,16 @@ mapping_seek(ImagingMapperObject* mapper, PyObject* args)
/* -------------------------------------------------------------------- */
/* map entire image */
extern PyObject*PyImagingNew(Imaging im);
extern PyObject *
PyImagingNew(Imaging im);
static void
ImagingDestroyMap(Imaging im)
{
ImagingDestroyMap(Imaging im) {
return; /* nothing to do! */
}
static PyObject *
mapping_readimage(ImagingMapperObject* mapper, PyObject* args)
{
mapping_readimage(ImagingMapperObject *mapper, PyObject *args) {
int y, size;
Imaging im;
@ -202,8 +193,8 @@ mapping_readimage(ImagingMapperObject* mapper, PyObject* args)
int ysize;
int stride;
int orientation;
if (!PyArg_ParseTuple(args, "s(ii)ii", &mode, &xsize, &ysize,
&stride, &orientation)) {
if (!PyArg_ParseTuple(
args, "s(ii)ii", &mode, &xsize, &ysize, &stride, &orientation)) {
return NULL;
}
@ -258,8 +249,7 @@ static struct PyMethodDef methods[] = {
};
static PyTypeObject ImagingMapperType = {
PyVarObject_HEAD_INIT(NULL, 0)
"ImagingMapper", /*tp_name*/
PyVarObject_HEAD_INIT(NULL, 0) "ImagingMapper", /*tp_name*/
sizeof(ImagingMapperObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
@ -292,8 +282,7 @@ static PyTypeObject ImagingMapperType = {
};
PyObject *
PyImaging_Mapper(PyObject* self, PyObject* args)
{
PyImaging_Mapper(PyObject *self, PyObject *args) {
char *filename;
if (!PyArg_ParseTuple(args, "s", &filename)) {
return NULL;
@ -312,8 +301,7 @@ typedef struct ImagingBufferInstance {
} ImagingBufferInstance;
static void
mapping_destroy_buffer(Imaging im)
{
mapping_destroy_buffer(Imaging im) {
ImagingBufferInstance *buffer = (ImagingBufferInstance *)im;
PyBuffer_Release(&buffer->view);
@ -321,8 +309,7 @@ mapping_destroy_buffer(Imaging im)
}
PyObject *
PyImaging_MapBuffer(PyObject* self, PyObject* args)
{
PyImaging_MapBuffer(PyObject *self, PyObject *args) {
Py_ssize_t y, size;
Imaging im;
@ -335,8 +322,17 @@ PyImaging_MapBuffer(PyObject* self, PyObject* args)
int stride;
int ystep;
if (!PyArg_ParseTuple(args, "O(ii)sn(sii)", &target, &xsize, &ysize,
&codec, &offset, &mode, &stride, &ystep)) {
if (!PyArg_ParseTuple(
args,
"O(ii)sn(sii)",
&target,
&xsize,
&ysize,
&codec,
&offset,
&mode,
&stride,
&ystep)) {
return NULL;
}
@ -383,8 +379,7 @@ PyImaging_MapBuffer(PyObject* self, PyObject* args)
return NULL;
}
im = ImagingNewPrologueSubtype(
mode, xsize, ysize, sizeof(ImagingBufferInstance));
im = ImagingNewPrologueSubtype(mode, xsize, ysize, sizeof(ImagingBufferInstance));
if (!im) {
PyBuffer_Release(&view);
return NULL;
@ -409,4 +404,3 @@ PyImaging_MapBuffer(PyObject* self, PyObject* args)
return PyImagingNew(im);
}

36
src/outline.c
View File

@ -21,13 +21,11 @@
#include "libImaging/Imaging.h"
/* -------------------------------------------------------------------- */
/* Class */
typedef struct {
PyObject_HEAD
ImagingOutline outline;
PyObject_HEAD ImagingOutline outline;
} OutlineObject;
static PyTypeObject OutlineType;
@ -35,8 +33,7 @@ static PyTypeObject OutlineType;
#define PyOutline_Check(op) (Py_TYPE(op) == &OutlineType)
static OutlineObject *
_outline_new(void)
{
_outline_new(void) {
OutlineObject *self;
if (PyType_Ready(&OutlineType) < 0) {
@ -54,15 +51,13 @@ _outline_new(void)
}
static void
_outline_dealloc(OutlineObject* self)
{
_outline_dealloc(OutlineObject *self) {
ImagingOutlineDelete(self->outline);
PyObject_Del(self);
}
ImagingOutline
PyOutline_AsOutline(PyObject* outline)
{
PyOutline_AsOutline(PyObject *outline) {
if (PyOutline_Check(outline)) {
return ((OutlineObject *)outline)->outline;
}
@ -70,13 +65,11 @@ PyOutline_AsOutline(PyObject* outline)
return NULL;
}
/* -------------------------------------------------------------------- */
/* Factories */
PyObject *
PyOutline_Create(PyObject* self, PyObject* args)
{
PyOutline_Create(PyObject *self, PyObject *args) {
if (!PyArg_ParseTuple(args, ":outline")) {
return NULL;
}
@ -84,13 +77,11 @@ PyOutline_Create(PyObject* self, PyObject* args)
return (PyObject *)_outline_new();
}
/* -------------------------------------------------------------------- */
/* Methods */
static PyObject *
_outline_move(OutlineObject* self, PyObject* args)
{
_outline_move(OutlineObject *self, PyObject *args) {
float x0, y0;
if (!PyArg_ParseTuple(args, "ff", &x0, &y0)) {
return NULL;
@ -103,8 +94,7 @@ _outline_move(OutlineObject* self, PyObject* args)
}
static PyObject *
_outline_line(OutlineObject* self, PyObject* args)
{
_outline_line(OutlineObject *self, PyObject *args) {
float x1, y1;
if (!PyArg_ParseTuple(args, "ff", &x1, &y1)) {
return NULL;
@ -117,8 +107,7 @@ _outline_line(OutlineObject* self, PyObject* args)
}
static PyObject *
_outline_curve(OutlineObject* self, PyObject* args)
{
_outline_curve(OutlineObject *self, PyObject *args) {
float x1, y1, x2, y2, x3, y3;
if (!PyArg_ParseTuple(args, "ffffff", &x1, &y1, &x2, &y2, &x3, &y3)) {
return NULL;
@ -131,8 +120,7 @@ _outline_curve(OutlineObject* self, PyObject* args)
}
static PyObject *
_outline_close(OutlineObject* self, PyObject* args)
{
_outline_close(OutlineObject *self, PyObject *args) {
if (!PyArg_ParseTuple(args, ":close")) {
return NULL;
}
@ -144,8 +132,7 @@ _outline_close(OutlineObject* self, PyObject* args)
}
static PyObject *
_outline_transform(OutlineObject* self, PyObject* args)
{
_outline_transform(OutlineObject *self, PyObject *args) {
double a[6];
if (!PyArg_ParseTuple(args, "(dddddd)", a + 0, a + 1, a + 2, a + 3, a + 4, a + 5)) {
return NULL;
@ -167,8 +154,7 @@ static struct PyMethodDef _outline_methods[] = {
};
static PyTypeObject OutlineType = {
PyVarObject_HEAD_INIT(NULL, 0)
"Outline", /*tp_name*/
PyVarObject_HEAD_INIT(NULL, 0) "Outline", /*tp_name*/
sizeof(OutlineObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */

102
src/path.c
View File

@ -25,23 +25,23 @@
* See the README file for information on usage and redistribution.
*/
#include "Python.h"
#include "libImaging/Imaging.h"
#include <math.h>
/* compatibility wrappers (defined in _imaging.c) */
extern int PyImaging_CheckBuffer(PyObject* buffer);
extern int PyImaging_GetBuffer(PyObject* buffer, Py_buffer *view);
extern int
PyImaging_CheckBuffer(PyObject *buffer);
extern int
PyImaging_GetBuffer(PyObject *buffer, Py_buffer *view);
/* -------------------------------------------------------------------- */
/* Class */
/* -------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
Py_ssize_t count;
PyObject_HEAD Py_ssize_t count;
double *xy;
int index; /* temporary use, e.g. in decimate */
} PyPathObject;
@ -49,8 +49,7 @@ typedef struct {
static PyTypeObject PyPathType;
static double *
alloc_array(Py_ssize_t count)
{
alloc_array(Py_ssize_t count) {
double *xy;
if (count < 0) {
return ImagingError_MemoryError();
@ -66,8 +65,7 @@ alloc_array(Py_ssize_t count)
}
static PyPathObject *
path_new(Py_ssize_t count, double* xy, int duplicate)
{
path_new(Py_ssize_t count, double *xy, int duplicate) {
PyPathObject *path;
if (duplicate) {
@ -98,8 +96,7 @@ path_new(Py_ssize_t count, double* xy, int duplicate)
}
static void
path_dealloc(PyPathObject* path)
{
path_dealloc(PyPathObject *path) {
free(path->xy);
PyObject_Del(path);
}
@ -111,8 +108,7 @@ path_dealloc(PyPathObject* path)
#define PyPath_Check(op) (Py_TYPE(op) == &PyPathType)
Py_ssize_t
PyPath_Flatten(PyObject* data, double **pxy)
{
PyPath_Flatten(PyObject *data, double **pxy) {
Py_ssize_t i, j, n;
double *xy;
@ -209,8 +205,7 @@ PyPath_Flatten(PyObject* data, double **pxy)
PyObject *op = PySequence_GetItem(data, i);
if (!op) {
/* treat IndexError as end of sequence */
if (PyErr_Occurred() &&
PyErr_ExceptionMatches(PyExc_IndexError)) {
if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_IndexError)) {
PyErr_Clear();
break;
} else {
@ -246,20 +241,17 @@ PyPath_Flatten(PyObject* data, double **pxy)
return j / 2;
}
/* -------------------------------------------------------------------- */
/* Factories */
/* -------------------------------------------------------------------- */
PyObject *
PyPath_Create(PyObject* self, PyObject* args)
{
PyPath_Create(PyObject *self, PyObject *args) {
PyObject *data;
Py_ssize_t count;
double *xy;
if (PyArg_ParseTuple(args, "n:Path", &count)) {
/* number of vertices */
xy = alloc_array(count);
if (!xy) {
@ -267,7 +259,6 @@ PyPath_Create(PyObject* self, PyObject* args)
}
} else {
/* sequence or other path */
PyErr_Clear();
if (!PyArg_ParseTuple(args, "O", &data)) {
@ -283,14 +274,12 @@ PyPath_Create(PyObject* self, PyObject* args)
return (PyObject *)path_new(count, xy, 0);
}
/* -------------------------------------------------------------------- */
/* Methods */
/* -------------------------------------------------------------------- */
static PyObject *
path_compact(PyPathObject* self, PyObject* args)
{
path_compact(PyPathObject *self, PyObject *args) {
/* Simple-minded method to shorten path. A point is removed if
the city block distance to the previous point is less than the
given distance */
@ -307,7 +296,8 @@ path_compact(PyPathObject* self, PyObject* args)
/* remove bogus vertices */
for (i = j = 1; i < self->count; i++) {
if (fabs(xy[j+j-2]-xy[i+i]) + fabs(xy[j+j-1]-xy[i+i+1]) >= cityblock) {
if (fabs(xy[j + j - 2] - xy[i + i]) + fabs(xy[j + j - 1] - xy[i + i + 1]) >=
cityblock) {
xy[j + j] = xy[i + i];
xy[j + j + 1] = xy[i + i + 1];
j++;
@ -325,8 +315,7 @@ path_compact(PyPathObject* self, PyObject* args)
}
static PyObject *
path_getbbox(PyPathObject* self, PyObject* args)
{
path_getbbox(PyPathObject *self, PyObject *args) {
/* Find bounding box */
Py_ssize_t i;
double *xy;
@ -360,8 +349,7 @@ path_getbbox(PyPathObject* self, PyObject* args)
}
static PyObject *
path_getitem(PyPathObject* self, Py_ssize_t i)
{
path_getitem(PyPathObject *self, Py_ssize_t i) {
if (i < 0) {
i = self->count + i;
}
@ -374,8 +362,7 @@ path_getitem(PyPathObject* self, Py_ssize_t i)
}
static PyObject *
path_getslice(PyPathObject* self, Py_ssize_t ilow, Py_ssize_t ihigh)
{
path_getslice(PyPathObject *self, Py_ssize_t ilow, Py_ssize_t ihigh) {
/* adjust arguments */
if (ilow < 0) {
ilow = 0;
@ -395,14 +382,12 @@ path_getslice(PyPathObject* self, Py_ssize_t ilow, Py_ssize_t ihigh)
}
static Py_ssize_t
path_len(PyPathObject* self)
{
path_len(PyPathObject *self) {
return self->count;
}
static PyObject *
path_map(PyPathObject* self, PyObject* args)
{
path_map(PyPathObject *self, PyObject *args) {
/* Map coordinate set through function */
Py_ssize_t i;
double *xy;
@ -433,19 +418,16 @@ path_map(PyPathObject* self, PyObject* args)
}
static int
path_setitem(PyPathObject* self, Py_ssize_t i, PyObject* op)
{
path_setitem(PyPathObject *self, Py_ssize_t i, PyObject *op) {
double *xy;
if (i < 0 || i >= self->count) {
PyErr_SetString(PyExc_IndexError,
"path assignment index out of range");
PyErr_SetString(PyExc_IndexError, "path assignment index out of range");
return -1;
}
if (op == NULL) {
PyErr_SetString(PyExc_TypeError,
"cannot delete from path");
PyErr_SetString(PyExc_TypeError, "cannot delete from path");
return -1;
}
@ -459,8 +441,7 @@ path_setitem(PyPathObject* self, Py_ssize_t i, PyObject* op)
}
static PyObject *
path_tolist(PyPathObject* self, PyObject* args)
{
path_tolist(PyPathObject *self, PyObject *args) {
PyObject *list;
Py_ssize_t i;
@ -499,8 +480,7 @@ error:
}
static PyObject *
path_transform(PyPathObject* self, PyObject* args)
{
path_transform(PyPathObject *self, PyObject *args) {
/* Apply affine transform to coordinate set */
Py_ssize_t i;
double *xy;
@ -508,9 +488,8 @@ path_transform(PyPathObject* self, PyObject* args)
double wrap = 0.0;
if (!PyArg_ParseTuple(args, "(dddddd)|d:transform",
&a, &b, &c, &d, &e, &f,
&wrap)) {
if (!PyArg_ParseTuple(
args, "(dddddd)|d:transform", &a, &b, &c, &d, &e, &f, &wrap)) {
return NULL;
}
@ -554,15 +533,11 @@ static struct PyMethodDef methods[] = {
};
static PyObject *
path_getattr_id(PyPathObject* self, void* closure)
{
path_getattr_id(PyPathObject *self, void *closure) {
return Py_BuildValue("n", (Py_ssize_t)self->xy);
}
static struct PyGetSetDef getsetters[] = {
{ "id", (getter) path_getattr_id },
{ NULL }
};
static struct PyGetSetDef getsetters[] = {{"id", (getter)path_getattr_id}, {NULL}};
static PyObject *
path_subscript(PyPathObject *self, PyObject *item) {
@ -585,17 +560,15 @@ path_subscript(PyPathObject* self, PyObject* item) {
if (slicelength <= 0) {
double *xy = alloc_array(0);
return (PyObject *)path_new(0, xy, 0);
}
else if (step == 1) {
} else if (step == 1) {
return path_getslice(self, start, stop);
}
else {
} else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError,
} else {
PyErr_Format(
PyExc_TypeError,
"Path indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
@ -613,14 +586,10 @@ static PySequenceMethods path_as_sequence = {
};
static PyMappingMethods path_as_mapping = {
(lenfunc)path_len,
(binaryfunc)path_subscript,
NULL
};
(lenfunc)path_len, (binaryfunc)path_subscript, NULL};
static PyTypeObject PyPathType = {
PyVarObject_HEAD_INIT(NULL, 0)
"Path", /*tp_name*/
PyVarObject_HEAD_INIT(NULL, 0) "Path", /*tp_name*/
sizeof(PyPathObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
@ -651,4 +620,3 @@ static PyTypeObject PyPathType = {
0, /*tp_members*/
getsetters, /*tp_getset*/
};