old
/
legacy-imlib2_loaders
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update headers, adapt to imlib2 changes, switch to stdint types

This commit is contained in:
Kim Woelders 2022-04-03 06:29:23 +02:00
parent 4dee30ae6a
commit c41a2a2e4e
8 changed files with 253 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/modules/loaders/common.h
View File

@ -44,15 +44,15 @@
#define PIXEL_B(argb) (((argb) ) & 0xff) #define PIXEL_B(argb) (((argb) ) & 0xff)
#ifndef WORDS_BIGENDIAN #ifndef WORDS_BIGENDIAN
#define A_VAL(p) ((DATA8 *)(p))[3] #define A_VAL(p) ((uint8_t *)(p))[3]
#define R_VAL(p) ((DATA8 *)(p))[2] #define R_VAL(p) ((uint8_t *)(p))[2]
#define G_VAL(p) ((DATA8 *)(p))[1] #define G_VAL(p) ((uint8_t *)(p))[1]
#define B_VAL(p) ((DATA8 *)(p))[0] #define B_VAL(p) ((uint8_t *)(p))[0]
#else #else
#define A_VAL(p) ((DATA8 *)(p))[0] #define A_VAL(p) ((uint8_t *)(p))[0]
#define R_VAL(p) ((DATA8 *)(p))[1] #define R_VAL(p) ((uint8_t *)(p))[1]
#define G_VAL(p) ((DATA8 *)(p))[2] #define G_VAL(p) ((uint8_t *)(p))[2]
#define B_VAL(p) ((DATA8 *)(p))[3] #define B_VAL(p) ((uint8_t *)(p))[3]
#endif #endif
#define CLIP(x, y, w, h, xx, yy, ww, hh) \ #define CLIP(x, y, w, h, xx, yy, ww, hh) \

13
src/modules/loaders/image.h
View File

@ -43,7 +43,7 @@ typedef struct _ImlibImageTag {
struct _ImlibImage { struct _ImlibImage {
char *file; char *file;
int w, h; int w, h;
DATA32 *data; uint32_t *data;
ImlibImageFlags flags; ImlibImageFlags flags;
time_t moddate; time_t moddate;
ImlibBorder border; ImlibBorder border;
@ -85,7 +85,7 @@ void __imlib_LoaderSetFormats(ImlibLoader * l,
const char *const *fmt, const char *const *fmt,
unsigned int num); unsigned int num);
ImlibImage *__imlib_CreateImage(int w, int h, DATA32 * data); ImlibImage *__imlib_CreateImage(int w, int h, uint32_t * data);
ImlibImage *__imlib_LoadImage(const char *file, ImlibLoadArgs * ila); ImlibImage *__imlib_LoadImage(const char *file, ImlibLoadArgs * ila);
int __imlib_LoadEmbedded(ImlibLoader * l, ImlibImage * im, int __imlib_LoadEmbedded(ImlibLoader * l, ImlibImage * im,
const char *file, int load_data); const char *file, int load_data);
@ -93,12 +93,11 @@ int __imlib_LoadImageData(ImlibImage * im);
void __imlib_DirtyImage(ImlibImage * im); void __imlib_DirtyImage(ImlibImage * im);
void __imlib_FreeImage(ImlibImage * im); void __imlib_FreeImage(ImlibImage * im);
void __imlib_SaveImage(ImlibImage * im, const char *file, void __imlib_SaveImage(ImlibImage * im, const char *file,
ImlibProgressFunction progress, ImlibLoadArgs * ila);
char progress_granularity, int *er);
DATA32 *__imlib_AllocateData(ImlibImage * im); uint32_t *__imlib_AllocateData(ImlibImage * im);
void __imlib_FreeData(ImlibImage * im); void __imlib_FreeData(ImlibImage * im);
void __imlib_ReplaceData(ImlibImage * im, DATA32 * new_data); void __imlib_ReplaceData(ImlibImage * im, uint32_t * new_data);
void __imlib_LoadProgressSetPass(ImlibImage * im, void __imlib_LoadProgressSetPass(ImlibImage * im,
int pass, int n_pass); int pass, int n_pass);
@ -136,7 +135,7 @@ int __imlib_CurrentCacheSize(void);
#define LOAD_BADFRAME -4 /* Requested frame not found */ #define LOAD_BADFRAME -4 /* Requested frame not found */
/* 32767 is the maximum pixmap dimension and ensures that /* 32767 is the maximum pixmap dimension and ensures that
* (w * h * sizeof(DATA32)) won't exceed ULONG_MAX */ * (w * h * sizeof(uint32_t)) won't exceed ULONG_MAX */
#define X_MAX_DIM 32767 #define X_MAX_DIM 32767
/* NB! The image dimensions are sometimes used in (dim << 16) like expressions /* NB! The image dimensions are sometimes used in (dim << 16) like expressions
* so great care must be taken if ever it is attempted to change this * so great care must be taken if ever it is attempted to change this

26
src/modules/loaders/loader_ani.c
View File

@ -41,18 +41,18 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
typedef struct _MsChunk { typedef struct _MsChunk {
struct _MsChunk *next; struct _MsChunk *next;
DATA32 chunk_id; uint32_t chunk_id;
DATA32 chunk_size; /* Size of this chunk, starting from */ uint32_t chunk_size; /* Size of this chunk, starting from */
DATA8 data; /* the following byte. Thus chunk_size = full size - 8 */ uint8_t data; /* the following byte. Thus chunk_size = full size - 8 */
} MsChunk; } MsChunk;
typedef struct _MsAni { typedef struct _MsAni {
FILE *fp; FILE *fp;
DATA32 cp; uint32_t cp;
DATA32 riff_id; /* "RIFF" */ uint32_t riff_id; /* "RIFF" */
DATA32 data_size; uint32_t data_size;
DATA32 chunk_id; /* "ACON" */ uint32_t chunk_id; /* "ACON" */
MsChunk *chunks; MsChunk *chunks;
} MsAni; } MsAni;
@ -60,7 +60,7 @@ typedef struct _MsAni {
static void ani_cleanup(MsAni * ani); static void ani_cleanup(MsAni * ani);
static int static int
ani_read_int8(FILE * fp, DATA8 * data, int count) ani_read_int8(FILE * fp, uint8_t * data, int count)
{ {
int total; int total;
int bytes; int bytes;
@ -79,14 +79,14 @@ ani_read_int8(FILE * fp, DATA8 * data, int count)
} }
static int static int
ani_read_int32(FILE * fp, DATA32 * data, int count) ani_read_int32(FILE * fp, uint32_t * data, int count)
{ {
int i, total; int i, total;
total = count; total = count;
if (count > 0) if (count > 0)
{ {
ani_read_int8(fp, (DATA8 *) data, count * 4); ani_read_int8(fp, (uint8_t *) data, count * 4);
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
data[i] = SWAP_LE_32(data[i]); data[i] = SWAP_LE_32(data[i]);
} }
@ -141,7 +141,7 @@ ani_cleanup(MsAni * ani)
static MsChunk * static MsChunk *
ani_load_chunk(MsAni * ani) ani_load_chunk(MsAni * ani)
{ {
DATA32 chunk_id, chunk_size, dummy; uint32_t chunk_id, chunk_size, dummy;
MsChunk *chunk; MsChunk *chunk;
if (ani->cp >= ani->data_size + 8) if (ani->cp >= ani->data_size + 8)
@ -163,11 +163,11 @@ ani_load_chunk(MsAni * ani)
if (chunk_size % 2) if (chunk_size % 2)
chunk_size += (2 - (chunk_size % 2)); chunk_size += (2 - (chunk_size % 2));
chunk = calloc(1, sizeof(MsChunk *) + 2 * sizeof(DATA32) + chunk_size); chunk = calloc(1, sizeof(MsChunk *) + 2 * sizeof(uint32_t) + chunk_size);
if (!chunk) if (!chunk)
{ {
D("Warning, failed to allocate ANI chunk of size %ld\n", D("Warning, failed to allocate ANI chunk of size %ld\n",
sizeof(MsChunk *) + 2 * sizeof(DATA32) + chunk_size); sizeof(MsChunk *) + 2 * sizeof(uint32_t) + chunk_size);
return NULL; return NULL;
} }

56
src/modules/loaders/loader_eet.c
View File

@ -57,8 +57,8 @@ load(ImlibImage * im, ImlibProgressFunction progress,
int w, h, alpha, compression, size; int w, h, alpha, compression, size;
Eet_File *ef; Eet_File *ef;
char file[4096], key[4096]; char file[4096], key[4096];
DATA32 *ret; uint32_t *ret;
DATA32 *body; uint32_t *body;
if (!im->key) if (!im->key)
return 0; return 0;
@ -78,7 +78,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
} }
/* header */ /* header */
{ {
DATA32 header[8]; uint32_t header[8];
if (size < 32) if (size < 32)
{ {
@ -123,7 +123,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
} }
if (((!im->data) && (im->loader)) || (immediate_load) || (progress)) if (((!im->data) && (im->loader)) || (immediate_load) || (progress))
{ {
DATA32 *ptr; uint32_t *ptr;
int y, pl = 0; int y, pl = 0;
char pper = 0; char pper = 0;
@ -136,7 +136,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
char per; char per;
int l; int l;
ptr = im->data = malloc(w * h * sizeof(DATA32)); ptr = im->data = malloc(w * h * sizeof(uint32_t));
if (!im->data) if (!im->data)
{ {
free(ret); free(ret);
@ -149,12 +149,12 @@ load(ImlibImage * im, ImlibProgressFunction progress,
{ {
int x; int x;
memcpy(ptr, &(body[y * w]), im->w * sizeof(DATA32)); memcpy(ptr, &(body[y * w]), im->w * sizeof(uint32_t));
for (x = 0; x < im->w; x++) for (x = 0; x < im->w; x++)
SWAP32(ptr[x]); SWAP32(ptr[x]);
} }
#else #else
memcpy(ptr, &(body[y * w]), im->w * sizeof(DATA32)); memcpy(ptr, &(body[y * w]), im->w * sizeof(uint32_t));
#endif #endif
ptr += im->w; ptr += im->w;
@ -176,7 +176,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
} }
else else
{ {
ptr = im->data = malloc(w * h * sizeof(DATA32)); ptr = im->data = malloc(w * h * sizeof(uint32_t));
if (!im->data) if (!im->data)
{ {
free(ret); free(ret);
@ -187,12 +187,12 @@ load(ImlibImage * im, ImlibProgressFunction progress,
{ {
int x; int x;
memcpy(ptr, body, im->w * im->h * sizeof(DATA32)); memcpy(ptr, body, im->w * im->h * sizeof(uint32_t));
for (x = 0; x < (im->w * im->h); x++) for (x = 0; x < (im->w * im->h); x++)
SWAP32(ptr[x]); SWAP32(ptr[x]);
} }
#else #else
memcpy(ptr, body, im->w * im->h * sizeof(DATA32)); memcpy(ptr, body, im->w * im->h * sizeof(uint32_t));
#endif #endif
} }
} }
@ -200,8 +200,8 @@ load(ImlibImage * im, ImlibProgressFunction progress,
{ {
uLongf dlen; uLongf dlen;
dlen = w * h * sizeof(DATA32); dlen = w * h * sizeof(uint32_t);
im->data = malloc(w * h * sizeof(DATA32)); im->data = malloc(w * h * sizeof(uint32_t));
if (!im->data) if (!im->data)
{ {
free(ret); free(ret);
@ -232,11 +232,11 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
{ {
int alpha = 0; int alpha = 0;
char file[4096], key[4096], *tmp; char file[4096], key[4096], *tmp;
DATA32 *header; uint32_t *header;
DATA32 *buf; uint32_t *buf;
Eet_File *ef; Eet_File *ef;
int compression = 0, size = 0; int compression = 0, size = 0;
DATA32 *ret; uint32_t *ret;
/* no image data? abort */ /* no image data? abort */
if (!im->data) if (!im->data)
@ -267,7 +267,7 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
return 0; return 0;
/* account for space for compression */ /* account for space for compression */
buf = malloc((((im->w * im->h * 101) / 100) + 3 + 8) * sizeof(DATA32)); buf = malloc((((im->w * im->h * 101) / 100) + 3 + 8) * sizeof(uint32_t));
header = buf; header = buf;
header[0] = 0xac1dfeed; header[0] = 0xac1dfeed;
header[1] = im->w; header[1] = im->w;
@ -291,31 +291,32 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
} }
if (compression > 0) if (compression > 0)
{ {
DATA32 *compressed; uint32_t *compressed;
int retr; int retr;
uLongf buflen; uLongf buflen;
compressed = &(buf[8]); compressed = &(buf[8]);
buflen = ((im->w * im->h * sizeof(DATA32) * 101) / 100) + 12; buflen = ((im->w * im->h * sizeof(uint32_t) * 101) / 100) + 12;
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
{ {
int i; int i;
DATA32 *buf2; uint32_t *buf2;
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
SWAP32(header[i]); SWAP32(header[i]);
buf2 = malloc((((im->w * im->h * 101) / 100) + 3) * sizeof(DATA32)); buf2 =
malloc((((im->w * im->h * 101) / 100) + 3) * sizeof(uint32_t));
if (buf2) if (buf2)
{ {
int y; int y;
memcpy(buf2, im->data, im->w * im->h * sizeof(DATA32)); memcpy(buf2, im->data, im->w * im->h * sizeof(uint32_t));
for (y = 0; y < (im->w * im->h) + 8; y++) for (y = 0; y < (im->w * im->h) + 8; y++)
SWAP32(buf2[y]); SWAP32(buf2[y]);
retr = compress2((Bytef *) compressed, &buflen, retr = compress2((Bytef *) compressed, &buflen,
(Bytef *) buf2, (Bytef *) buf2,
(uLong) (im->w * im->h * sizeof(DATA32)), (uLong) (im->w * im->h * sizeof(uint32_t)),
compression); compression);
free(buf2); free(buf2);
} }
@ -325,21 +326,22 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
#else #else
retr = compress2((Bytef *) compressed, &buflen, retr = compress2((Bytef *) compressed, &buflen,
(Bytef *) im->data, (Bytef *) im->data,
(uLong) (im->w * im->h * sizeof(DATA32)), compression); (uLong) (im->w * im->h * sizeof(uint32_t)),
compression);
#endif #endif
if (retr != Z_OK) if (retr != Z_OK)
compressed = 0; compressed = 0;
else else
{ {
if (buflen >= (im->w * im->h * sizeof(DATA32))) if (buflen >= (im->w * im->h * sizeof(uint32_t)))
compressed = 0; compressed = 0;
else else
size = (8 * sizeof(DATA32)) + buflen; size = (8 * sizeof(uint32_t)) + buflen;
} }
} }
else else
{ {
memcpy(&(buf[8]), im->data, im->w * im->h * sizeof(DATA32)); memcpy(&(buf[8]), im->data, im->w * im->h * sizeof(uint32_t));
header[4] = compression; header[4] = compression;
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
{ {
@ -349,7 +351,7 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
SWAP32(buf[y]); SWAP32(buf[y]);
} }
#endif #endif
size = ((im->w * im->h) + 8) * sizeof(DATA32); size = ((im->w * im->h) + 8) * sizeof(uint32_t);
} }
ret = buf; ret = buf;
eet_write(ef, key, ret, size, 0); eet_write(ef, key, ret, size, 0);

154
src/modules/loaders/loader_xcf.c
View File

@ -34,7 +34,7 @@
size, likely with smaller ones on the right and bottom edges. size, likely with smaller ones on the right and bottom edges.
The position of the tiles on the image is left->right, row by row. The The position of the tiles on the image is left->right, row by row. The
actual DATA8* data is contained in a "level" which is contained in a actual uint8_t* data is contained in a "level" which is contained in a
"hierarchy". I've not really understood the purpose of the hierarchy, as "hierarchy". I've not really understood the purpose of the hierarchy, as
it seems to always contain only one level anyway. it seems to always contain only one level anyway.
@ -189,11 +189,11 @@ struct _Layer {
int num_cols; int num_cols;
/* After the tiles are read in, they're serialized int an array /* After the tiles are read in, they're serialized int an array
* of DATA8's, that will always contain 4 bpp data. Not optimal, * of uint8_t's, that will always contain 4 bpp data. Not optimal,
* I know, but makes life easier * I know, but makes life easier
*/ */
DATA32 *data; uint32_t *data;
/* Layers are stored as a linked list. */ /* Layers are stored as a linked list. */
struct _Layer *next; struct _Layer *next;
@ -212,7 +212,7 @@ struct _Tile {
* This is to handle edge tiles of a drawable. * This is to handle edge tiles of a drawable.
*/ */
DATA8 *data; uint8_t *data;
}; };
/* This struct simply contains everything that didn't fit elsewhere, /* This struct simply contains everything that didn't fit elsewhere,
@ -227,10 +227,10 @@ struct _GimpImage {
int width, height; /* width and height attributes */ int width, height; /* width and height attributes */
GimpImageBaseType base_type; /* base gimp_image type */ GimpImageBaseType base_type; /* base gimp_image type */
DATA32 floating_sel_offset; uint32_t floating_sel_offset;
DATA8 *cmap; /* colormap--for indexed */ uint8_t *cmap; /* colormap--for indexed */
DATA32 num_cols; /* number of colors in map */ uint32_t num_cols; /* number of colors in map */
/* If a layer number was passed to the loader, it goes here: */ /* If a layer number was passed to the loader, it goes here: */
int single_layer_index; int single_layer_index;
@ -238,7 +238,7 @@ struct _GimpImage {
/* Tadaa -- the final image data. Layers get pasted /* Tadaa -- the final image data. Layers get pasted
* onto this one, bottom-up. * onto this one, bottom-up.
*/ */
DATA32 *data; uint32_t *data;
Layer *layers; Layer *layers;
Layer *last_layer; Layer *last_layer;
@ -283,7 +283,7 @@ init_tile(Tile * tile, int width, int height, int bpp)
tile->bpp = bpp; tile->bpp = bpp;
tile->ewidth = width; tile->ewidth = width;
tile->eheight = height; tile->eheight = height;
tile->data = malloc(sizeof(DATA8) * width * height * bpp); tile->data = malloc(sizeof(uint8_t) * width * height * bpp);
if (!tile->data) if (!tile->data)
{ {
D("Couldn't allocate tile.\n"); D("Couldn't allocate tile.\n");
@ -401,14 +401,14 @@ static void
set_layer_opacity(Layer * layer) set_layer_opacity(Layer * layer)
{ {
int i; int i;
DATA8 *ptr; uint8_t *ptr;
if (!layer) if (!layer)
return; return;
if (layer->opacity != 255) if (layer->opacity != 255)
{ {
for (i = 0, ptr = (DATA8 *) layer->data; for (i = 0, ptr = (uint8_t *) layer->data;
i < layer->width * layer->height; i++, ptr += 4) i < layer->width * layer->height; i++, ptr += 4)
{ {
*(ptr + 3) = (*(ptr + 3) * layer->opacity) >> 8; *(ptr + 3) = (*(ptr + 3) * layer->opacity) >> 8;
@ -419,8 +419,8 @@ set_layer_opacity(Layer * layer)
static void static void
apply_layer_mask(Layer * layer) apply_layer_mask(Layer * layer)
{ {
DATA8 *ptr1; uint8_t *ptr1;
DATA8 *ptr2; uint8_t *ptr2;
int i, tmp; int i, tmp;
D("Applying layer mask.\n"); D("Applying layer mask.\n");
@ -431,8 +431,8 @@ apply_layer_mask(Layer * layer)
if (!layer->mask) if (!layer->mask)
return; return;
ptr1 = (DATA8 *) layer->data; ptr1 = (uint8_t *) layer->data;
ptr2 = (DATA8 *) layer->mask->data; ptr2 = (uint8_t *) layer->mask->data;
for (i = 0; i < layer->width * layer->height; i++) for (i = 0; i < layer->width * layer->height; i++)
{ {
@ -440,7 +440,7 @@ apply_layer_mask(Layer * layer)
if (tmp > 255) if (tmp > 255)
tmp = 255; tmp = 255;
*(ptr1 + 3) = (DATA8) tmp; *(ptr1 + 3) = (uint8_t) tmp;
ptr1 += 4; ptr1 += 4;
ptr2 += 4; ptr2 += 4;
} }
@ -453,7 +453,7 @@ flatten_image(void)
Layer *lp; Layer *lp;
int layer_index; int layer_index;
image->data = calloc(image->width * image->height, sizeof(DATA32)); image->data = calloc(image->width * image->height, sizeof(uint32_t));
layer_index = 0; layer_index = 0;
while (l) while (l)
@ -607,13 +607,13 @@ xcf_seek_pos(int pos)
} }
static int static int
xcf_read_int8(FILE * fp, DATA8 * data, int count) xcf_read_int8(FILE * fp, uint8_t * data, int count)
{ {
return fread(data, 1, count, fp); return fread(data, 1, count, fp);
} }
static int static int
xcf_read_int32(FILE * fp, DATA32 * data, int count) xcf_read_int32(FILE * fp, uint32_t * data, int count)
{ {
int i, nr; int i, nr;
@ -622,7 +622,7 @@ xcf_read_int32(FILE * fp, DATA32 * data, int count)
return 0; return 0;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
*data = (DATA32) ntohl(*data); *data = (uint32_t) ntohl(*data);
data++; data++;
} }
@ -632,7 +632,7 @@ xcf_read_int32(FILE * fp, DATA32 * data, int count)
static int static int
xcf_read_string(FILE * fp, char **data, int count) xcf_read_string(FILE * fp, char **data, int count)
{ {
DATA32 tmp; uint32_t tmp;
int total; int total;
int i; int i;
@ -642,8 +642,8 @@ xcf_read_string(FILE * fp, char **data, int count)
total += xcf_read_int32(fp, &tmp, 1); total += xcf_read_int32(fp, &tmp, 1);
if (tmp > 0) if (tmp > 0)
{ {
data[i] = malloc(sizeof(DATA8) * tmp); data[i] = malloc(sizeof(uint8_t) * tmp);
total += xcf_read_int8(fp, (DATA8 *) data[i], tmp); total += xcf_read_int8(fp, (uint8_t *) data[i], tmp);
} }
else else
{ {
@ -655,14 +655,14 @@ xcf_read_string(FILE * fp, char **data, int count)
} }
static int static int
xcf_load_prop(PropType * prop_type, DATA32 * prop_size) xcf_load_prop(PropType * prop_type, uint32_t * prop_size)
{ {
int nr; int nr;
nr = xcf_read_int32(image->fp, (DATA32 *) prop_type, 1); nr = xcf_read_int32(image->fp, (uint32_t *) prop_type, 1);
if (nr != 4) if (nr != 4)
return 0; return 0;
nr = xcf_read_int32(image->fp, (DATA32 *) prop_size, 1); nr = xcf_read_int32(image->fp, (uint32_t *) prop_size, 1);
if (nr != 4) if (nr != 4)
return 0; return 0;
@ -675,8 +675,8 @@ static int
xcf_load_image_props(void) xcf_load_image_props(void)
{ {
PropType prop_type; PropType prop_type;
DATA32 prop_size; uint32_t prop_size;
DATA8 compression; uint8_t compression;
while (1) while (1)
{ {
@ -699,7 +699,7 @@ xcf_load_image_props(void)
"did not save indexed colormaps correctly.\n" "did not save indexed colormaps correctly.\n"
"Substituting grayscale map.\n"); "Substituting grayscale map.\n");
image->cp += xcf_read_int32(image->fp, &image->num_cols, 1); image->cp += xcf_read_int32(image->fp, &image->num_cols, 1);
image->cmap = malloc(sizeof(DATA8) * image->num_cols * 3); image->cmap = malloc(sizeof(uint8_t) * image->num_cols * 3);
xcf_seek_pos(image->cp + image->num_cols); xcf_seek_pos(image->cp + image->num_cols);
for (i = 0; i < image->num_cols; i++) for (i = 0; i < image->num_cols; i++)
{ {
@ -712,9 +712,9 @@ xcf_load_image_props(void)
{ {
D("Loading colormap.\n"); D("Loading colormap.\n");
image->cp += xcf_read_int32(image->fp, &image->num_cols, 1); image->cp += xcf_read_int32(image->fp, &image->num_cols, 1);
image->cmap = malloc(sizeof(DATA8) * image->num_cols * 3); image->cmap = malloc(sizeof(uint8_t) * image->num_cols * 3);
image->cp += image->cp +=
xcf_read_int8(image->fp, (DATA8 *) image->cmap, xcf_read_int8(image->fp, (uint8_t *) image->cmap,
image->num_cols * 3); image->num_cols * 3);
} }
break; break;
@ -751,7 +751,7 @@ xcf_load_image_props(void)
while (prop_size > 0) while (prop_size > 0)
{ {
DATA8 buf[16]; uint8_t buf[16];
int amount; int amount;
amount = (16 < prop_size ? 16 : prop_size); amount = (16 < prop_size ? 16 : prop_size);
@ -769,7 +769,7 @@ static int
xcf_load_layer_props(Layer * layer) xcf_load_layer_props(Layer * layer)
{ {
PropType prop_type; PropType prop_type;
DATA32 prop_size; uint32_t prop_size;
while (1) while (1)
{ {
@ -786,30 +786,30 @@ xcf_load_layer_props(Layer * layer)
image->floating_sel = layer; image->floating_sel = layer;
image->cp += image->cp +=
xcf_read_int32(image->fp, xcf_read_int32(image->fp,
(DATA32 *) & image->floating_sel_offset, 1); (uint32_t *) & image->floating_sel_offset, 1);
break; break;
case PROP_OPACITY: case PROP_OPACITY:
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->opacity, 1); xcf_read_int32(image->fp, (uint32_t *) & layer->opacity, 1);
break; break;
case PROP_VISIBLE: case PROP_VISIBLE:
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->visible, 1); xcf_read_int32(image->fp, (uint32_t *) & layer->visible, 1);
break; break;
case PROP_PRESERVE_TRANSPARENCY: case PROP_PRESERVE_TRANSPARENCY:
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->preserve_trans, xcf_read_int32(image->fp, (uint32_t *) & layer->preserve_trans,
1); 1);
break; break;
case PROP_OFFSETS: case PROP_OFFSETS:
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->offset_x, 1); xcf_read_int32(image->fp, (uint32_t *) & layer->offset_x, 1);
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->offset_y, 1); xcf_read_int32(image->fp, (uint32_t *) & layer->offset_y, 1);
break; break;
case PROP_MODE: case PROP_MODE:
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->mode, 1); xcf_read_int32(image->fp, (uint32_t *) & layer->mode, 1);
break; break;
/* I threw out all of the following: --cK */ /* I threw out all of the following: --cK */
@ -826,7 +826,7 @@ xcf_load_layer_props(Layer * layer)
while (prop_size > 0) while (prop_size > 0)
{ {
DATA8 buf[16]; uint8_t buf[16];
int amount; int amount;
amount = (16 < prop_size ? 16 : prop_size); amount = (16 < prop_size ? 16 : prop_size);
@ -842,11 +842,11 @@ xcf_load_layer_props(Layer * layer)
static int static int
read_tiles_into_data(Tile * tiles, int num_cols, int width, read_tiles_into_data(Tile * tiles, int num_cols, int width,
int height, int bpp, DATA32 ** data_p, int use_cmap) int height, int bpp, uint32_t ** data_p, int use_cmap)
{ {
int tile_x, tile_y, x, y, offset_x, offset_y; int tile_x, tile_y, x, y, offset_x, offset_y;
DATA32 *data; uint32_t *data;
DATA8 *ptr2; uint8_t *ptr2;
unsigned char a, r, g, b; unsigned char a, r, g, b;
Tile *t; Tile *t;
int warned = 0; int warned = 0;
@ -858,7 +858,7 @@ read_tiles_into_data(Tile * tiles, int num_cols, int width,
free(*data_p); free(*data_p);
/* Always allocate the data as 4 bytes per pixel */ /* Always allocate the data as 4 bytes per pixel */
data = malloc(sizeof(DATA32) * width * height); data = malloc(sizeof(uint32_t) * width * height);
*data_p = data; *data_p = data;
a = r = g = b = 0xff; a = r = g = b = 0xff;
@ -957,22 +957,22 @@ xcf_load_tile(Tile * tile)
static int static int
xcf_load_tile_rle(Tile * tile, int data_length) xcf_load_tile_rle(Tile * tile, int data_length)
{ {
DATA8 *data; uint8_t *data;
DATA8 val; uint8_t val;
int size; int size;
int count; int count;
int length; int length;
int bpp; int bpp;
int i, j; int i, j;
int nmemb_read_successfully; int nmemb_read_successfully;
DATA8 *xcfdata, *xcfodata, *xcfdatalimit; uint8_t *xcfdata, *xcfodata, *xcfdatalimit;
data = tile->data; data = tile->data;
bpp = tile->bpp; bpp = tile->bpp;
/*printf ("Reading encrypted tile %ix%ix%i, data_length %i\n", tile->ewidth, tile->eheight, tile->bpp, data_length); */ /*printf ("Reading encrypted tile %ix%ix%i, data_length %i\n", tile->ewidth, tile->eheight, tile->bpp, data_length); */
xcfdata = xcfodata = malloc(sizeof(DATA8) * data_length); xcfdata = xcfodata = malloc(sizeof(uint8_t) * data_length);
/* we have to use fread instead of xcf_read_* because we may be /* we have to use fread instead of xcf_read_* because we may be
* reading past the end of the file here */ * reading past the end of the file here */
@ -1081,8 +1081,8 @@ static int
xcf_load_level(Tile ** tiles_p, int hierarchy_width, int hierarchy_height, xcf_load_level(Tile ** tiles_p, int hierarchy_width, int hierarchy_height,
int bpp, int *num_rows, int *num_cols) int bpp, int *num_rows, int *num_cols)
{ {
DATA32 saved_pos; uint32_t saved_pos;
DATA32 offset, offset2; uint32_t offset, offset2;
int ntiles; int ntiles;
int width; int width;
int height; int height;
@ -1092,8 +1092,8 @@ xcf_load_level(Tile ** tiles_p, int hierarchy_width, int hierarchy_height,
Tile *tiles; Tile *tiles;
Tile *current_tile; Tile *current_tile;
image->cp += xcf_read_int32(image->fp, (DATA32 *) & width, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & width, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) & height, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & height, 1);
if ((width != hierarchy_width) || (height != hierarchy_height)) if ((width != hierarchy_width) || (height != hierarchy_height))
return 0; return 0;
@ -1186,15 +1186,15 @@ xcf_load_level(Tile ** tiles_p, int hierarchy_width, int hierarchy_height,
static int static int
xcf_load_hierarchy(Tile ** tiles, int *num_rows, int *num_cols, int *bpp) xcf_load_hierarchy(Tile ** tiles, int *num_rows, int *num_cols, int *bpp)
{ {
DATA32 saved_pos; uint32_t saved_pos;
DATA32 offset; uint32_t offset;
DATA32 junk; uint32_t junk;
int width; int width;
int height; int height;
image->cp += xcf_read_int32(image->fp, (DATA32 *) & width, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & width, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) & height, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & height, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) bpp, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) bpp, 1);
image->cp += xcf_read_int32(image->fp, &offset, 1); /* top level */ image->cp += xcf_read_int32(image->fp, &offset, 1); /* top level */
@ -1234,7 +1234,7 @@ static int
xcf_load_channel_props(Layer * layer) xcf_load_channel_props(Layer * layer)
{ {
PropType prop_type; PropType prop_type;
DATA32 prop_size; uint32_t prop_size;
while (1) while (1)
{ {
@ -1248,11 +1248,11 @@ xcf_load_channel_props(Layer * layer)
return 1; return 1;
case PROP_OPACITY: case PROP_OPACITY:
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->opacity, 1); xcf_read_int32(image->fp, (uint32_t *) & layer->opacity, 1);
break; break;
case PROP_VISIBLE: case PROP_VISIBLE:
image->cp += image->cp +=
xcf_read_int32(image->fp, (DATA32 *) & layer->visible, 1); xcf_read_int32(image->fp, (uint32_t *) & layer->visible, 1);
break; break;
case PROP_ACTIVE_CHANNEL: case PROP_ACTIVE_CHANNEL:
case PROP_SHOW_MASKED: case PROP_SHOW_MASKED:
@ -1266,7 +1266,7 @@ xcf_load_channel_props(Layer * layer)
while (prop_size > 0) while (prop_size > 0)
{ {
DATA8 buf[16]; uint8_t buf[16];
int amount; int amount;
amount = (16 < prop_size ? 16 : prop_size); amount = (16 < prop_size ? 16 : prop_size);
@ -1284,15 +1284,15 @@ static Layer *
xcf_load_channel(void) xcf_load_channel(void)
{ {
Layer *layer; Layer *layer;
DATA32 hierarchy_offset; uint32_t hierarchy_offset;
int err, width, height; int err, width, height;
char *name; char *name;
D("Loading channel ...\n"); D("Loading channel ...\n");
/* read in the layer width, height and name */ /* read in the layer width, height and name */
image->cp += xcf_read_int32(image->fp, (DATA32 *) & width, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & width, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) & height, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & height, 1);
image->cp += xcf_read_string(image->fp, &name, 1); image->cp += xcf_read_string(image->fp, &name, 1);
/* Yeah, still ugly :) */ /* Yeah, still ugly :) */
@ -1337,17 +1337,17 @@ xcf_load_layer(void)
{ {
Layer *layer; Layer *layer;
Layer *layer_mask; Layer *layer_mask;
DATA32 hierarchy_offset; uint32_t hierarchy_offset;
DATA32 layer_mask_offset; uint32_t layer_mask_offset;
int err, width, height, type; int err, width, height, type;
char *name; char *name;
D("Loading one layer ...\n"); D("Loading one layer ...\n");
/* read in the layer width, height and type */ /* read in the layer width, height and type */
image->cp += xcf_read_int32(image->fp, (DATA32 *) & width, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & width, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) & height, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & height, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) & type, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & type, 1);
image->cp += xcf_read_string(image->fp, &name, 1); image->cp += xcf_read_string(image->fp, &name, 1);
/* ugly, I know */ /* ugly, I know */
@ -1417,17 +1417,17 @@ static int
xcf_load_image(void) xcf_load_image(void)
{ {
Layer *layer; Layer *layer;
DATA32 saved_pos; uint32_t saved_pos;
DATA32 offset; uint32_t offset;
int width; int width;
int height; int height;
int image_type; int image_type;
int num_successful_elements = 0; int num_successful_elements = 0;
/* read in the image width, height and type */ /* read in the image width, height and type */
image->cp += xcf_read_int32(image->fp, (DATA32 *) & width, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & width, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) & height, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & height, 1);
image->cp += xcf_read_int32(image->fp, (DATA32 *) & image_type, 1); image->cp += xcf_read_int32(image->fp, (uint32_t *) & image_type, 1);
image->width = width; image->width = width;
image->height = height; image->height = height;
@ -1525,7 +1525,7 @@ xcf_file_init(FILE * fp)
image->cp = 0; image->cp = 0;
memset(id, 0, sizeof(id)); memset(id, 0, sizeof(id));
image->cp += xcf_read_int8(image->fp, (DATA8 *) id, 14); image->cp += xcf_read_int8(image->fp, (uint8_t *) id, 14);
if (strncmp(id, "gimp xcf ", 9) != 0) if (strncmp(id, "gimp xcf ", 9) != 0)
{ {
success = 0; success = 0;

89
src/modules/loaders/loader_xcf.h
View File

@ -2,50 +2,55 @@
#define LOADER_XCF_H #define LOADER_XCF_H
/* Stuff for layer merging: */ /* Stuff for layer merging: */
extern void combine_pixels_normal(const DATA32 * src, int src_w, extern void combine_pixels_normal(const uint32_t * src, int src_w,
int src_h, DATA32 * dest, int dest_w, int src_h, uint32_t * dest,
int dest_h, int dest_x, int dest_y); int dest_w, int dest_h, int dest_x,
extern void combine_pixels_add(const DATA32 * src, int src_w, int src_h, int dest_y);
DATA32 * dest, int dest_w, int dest_h, extern void combine_pixels_add(const uint32_t * src, int src_w,
int dest_x, int dest_y); int src_h, uint32_t * dest, int dest_w,
extern void combine_pixels_sub(const DATA32 * src, int src_w, int src_h, int dest_h, int dest_x, int dest_y);
DATA32 * dest, int dest_w, int dest_h, extern void combine_pixels_sub(const uint32_t * src, int src_w,
int dest_x, int dest_y); int src_h, uint32_t * dest, int dest_w,
extern void combine_pixels_diff(const DATA32 * src, int src_w, int dest_h, int dest_x, int dest_y);
int src_h, DATA32 * dest, int dest_w, extern void combine_pixels_diff(const uint32_t * src, int src_w,
int src_h, uint32_t * dest, int dest_w,
int dest_h, int dest_x, int dest_y); int dest_h, int dest_x, int dest_y);
extern void combine_pixels_darken(const DATA32 * src, int src_w, extern void combine_pixels_darken(const uint32_t * src, int src_w,
int src_h, DATA32 * dest, int dest_w, int src_h, uint32_t * dest,
int dest_h, int dest_x, int dest_y); int dest_w, int dest_h, int dest_x,
extern void combine_pixels_lighten(const DATA32 * src, int src_w, int dest_y);
int src_h, DATA32 * dest, int dest_w, extern void combine_pixels_lighten(const uint32_t * src, int src_w,
int dest_h, int dest_x, int dest_y); int src_h, uint32_t * dest,
extern void combine_pixels_mult(const DATA32 * src, int src_w, int dest_w, int dest_h, int dest_x,
int src_h, DATA32 * dest, int dest_w, int dest_y);
extern void combine_pixels_mult(const uint32_t * src, int src_w,
int src_h, uint32_t * dest, int dest_w,
int dest_h, int dest_x, int dest_y); int dest_h, int dest_x, int dest_y);
extern void combine_pixels_div(const DATA32 * src, int src_w, int src_h, extern void combine_pixels_div(const uint32_t * src, int src_w,
DATA32 * dest, int dest_w, int dest_h, int src_h, uint32_t * dest, int dest_w,
int dest_x, int dest_y); int dest_h, int dest_x, int dest_y);
extern void combine_pixels_screen(const DATA32 * src, int src_w, extern void combine_pixels_screen(const uint32_t * src, int src_w,
int src_h, DATA32 * dest, int dest_w, int src_h, uint32_t * dest,
int dest_h, int dest_x, int dest_y); int dest_w, int dest_h, int dest_x,
extern void combine_pixels_overlay(const DATA32 * src, int src_w, int dest_y);
int src_h, DATA32 * dest, int dest_w, extern void combine_pixels_overlay(const uint32_t * src, int src_w,
int dest_h, int dest_x, int dest_y); int src_h, uint32_t * dest,
extern void combine_pixels_hue(const DATA32 * src, int src_w, int src_h, int dest_w, int dest_h, int dest_x,
DATA32 * dest, int dest_w, int dest_h, int dest_y);
int dest_x, int dest_y); extern void combine_pixels_hue(const uint32_t * src, int src_w,
extern void combine_pixels_sat(const DATA32 * src, int src_w, int src_h, int src_h, uint32_t * dest, int dest_w,
DATA32 * dest, int dest_w, int dest_h, int dest_h, int dest_x, int dest_y);
int dest_x, int dest_y); extern void combine_pixels_sat(const uint32_t * src, int src_w,
extern void combine_pixels_val(const DATA32 * src, int src_w, int src_h, int src_h, uint32_t * dest, int dest_w,
DATA32 * dest, int dest_w, int dest_h, int dest_h, int dest_x, int dest_y);
int dest_x, int dest_y); extern void combine_pixels_val(const uint32_t * src, int src_w,
extern void combine_pixels_col(const DATA32 * src, int src_w, int src_h, int src_h, uint32_t * dest, int dest_w,
DATA32 * dest, int dest_w, int dest_h, int dest_h, int dest_x, int dest_y);
int dest_x, int dest_y); extern void combine_pixels_col(const uint32_t * src, int src_w,
extern void combine_pixels_diss(const DATA32 * src, int src_w, int src_h, uint32_t * dest, int dest_w,
int src_h, DATA32 * dest, int dest_w, int dest_h, int dest_x, int dest_y);
extern void combine_pixels_diss(const uint32_t * src, int src_w,
int src_h, uint32_t * dest, int dest_w,
int dest_h, int dest_x, int dest_y); int dest_h, int dest_x, int dest_y);
#endif /* LOADER_XCF_H */ #endif /* LOADER_XCF_H */

144
src/modules/loaders/loader_xcf_pixelfuncs.c
View File

@ -32,17 +32,17 @@
#ifndef WORDS_BIGENDIAN #ifndef WORDS_BIGENDIAN
#define A_VAL(p) ((DATA8 *)(p))[3] #define A_VAL(p) ((uint8_t *)(p))[3]
#define R_VAL(p) ((DATA8 *)(p))[2] #define R_VAL(p) ((uint8_t *)(p))[2]
#define G_VAL(p) ((DATA8 *)(p))[1] #define G_VAL(p) ((uint8_t *)(p))[1]
#define B_VAL(p) ((DATA8 *)(p))[0] #define B_VAL(p) ((uint8_t *)(p))[0]
#else #else
#define A_VAL(p) ((DATA8 *)(p))[0] #define A_VAL(p) ((uint8_t *)(p))[0]
#define R_VAL(p) ((DATA8 *)(p))[1] #define R_VAL(p) ((uint8_t *)(p))[1]
#define G_VAL(p) ((DATA8 *)(p))[2] #define G_VAL(p) ((uint8_t *)(p))[2]
#define B_VAL(p) ((DATA8 *)(p))[3] #define B_VAL(p) ((uint8_t *)(p))[3]
#endif #endif
@ -70,7 +70,7 @@
#define LINEAR(x,y,w) ((w*y + x)*4) #define LINEAR(x,y,w) ((w*y + x)*4)
static void static void
rgb_to_hls(DATA8 * red, DATA8 * green, DATA8 * blue) rgb_to_hls(uint8_t * red, uint8_t * green, uint8_t * blue)
{ {
int r, g, b; int r, g, b;
double h, l, s; double h, l, s;
@ -128,7 +128,7 @@ rgb_to_hls(DATA8 * red, DATA8 * green, DATA8 * blue)
*blue = s; *blue = s;
} }
static DATA8 static uint8_t
gimp_hls_value(double n1, double n2, double hue) gimp_hls_value(double n1, double n2, double hue)
{ {
double value; double value;
@ -146,11 +146,11 @@ gimp_hls_value(double n1, double n2, double hue)
else else
value = n1; value = n1;
return (DATA8) (value * 255); return (uint8_t) (value * 255);
} }
static void static void
hls_to_rgb(DATA8 * hue, DATA8 * lightness, DATA8 * saturation) hls_to_rgb(uint8_t * hue, uint8_t * lightness, uint8_t * saturation)
{ {
double h, l, s; double h, l, s;
double m1, m2; double m1, m2;
@ -183,7 +183,7 @@ hls_to_rgb(DATA8 * hue, DATA8 * lightness, DATA8 * saturation)
} }
static void static void
rgb_to_hsv(DATA8 * red, DATA8 * green, DATA8 * blue) rgb_to_hsv(uint8_t * red, uint8_t * green, uint8_t * blue)
{ {
int r, g, b; int r, g, b;
double h, s, v; double h, s, v;
@ -239,7 +239,7 @@ rgb_to_hsv(DATA8 * red, DATA8 * green, DATA8 * blue)
} }
static void static void
hsv_to_rgb(DATA8 * hue, DATA8 * saturation, DATA8 * value) hsv_to_rgb(uint8_t * hue, uint8_t * saturation, uint8_t * value)
{ {
double h, s, v; double h, s, v;
double f, p, q, t; double f, p, q, t;
@ -331,12 +331,12 @@ _clip(int *src_tl_x, int *src_tl_y,
} }
void void
combine_pixels_normal(const DATA32 * src_, int src_w, int src_h, combine_pixels_normal(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -389,12 +389,12 @@ combine_pixels_normal(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_add(const DATA32 * src_, int src_w, int src_h, combine_pixels_add(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -424,12 +424,12 @@ combine_pixels_add(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_sub(const DATA32 * src_, int src_w, int src_h, combine_pixels_sub(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -459,12 +459,12 @@ combine_pixels_sub(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_diff(const DATA32 * src_, int src_w, int src_h, combine_pixels_diff(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -494,12 +494,12 @@ combine_pixels_diff(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_darken(const DATA32 * src_, int src_w, int src_h, combine_pixels_darken(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -523,12 +523,12 @@ combine_pixels_darken(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_lighten(const DATA32 * src_, int src_w, int src_h, combine_pixels_lighten(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -552,12 +552,12 @@ combine_pixels_lighten(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_mult(const DATA32 * src_, int src_w, int src_h, combine_pixels_mult(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -585,12 +585,12 @@ combine_pixels_mult(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_div(const DATA32 * src_, int src_w, int src_h, combine_pixels_div(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -617,12 +617,12 @@ combine_pixels_div(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_screen(const DATA32 * src_, int src_w, int src_h, combine_pixels_screen(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -646,12 +646,12 @@ combine_pixels_screen(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_overlay(const DATA32 * src_, int src_w, int src_h, combine_pixels_overlay(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -684,12 +684,12 @@ combine_pixels_overlay(const DATA32 * src_, int src_w, int src_h,
} }
static void static void
combine_pixels_hsv(const DATA32 * src_, int src_w, int src_h, combine_pixels_hsv(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y, int mode) int dest_x, int dest_y, int mode)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -728,8 +728,8 @@ combine_pixels_hsv(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_hue(const DATA32 * src, int src_w, int src_h, combine_pixels_hue(const uint32_t * src, int src_w, int src_h,
DATA32 * dest, int dest_w, int dest_h, uint32_t * dest, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h, combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h,
@ -737,8 +737,8 @@ combine_pixels_hue(const DATA32 * src, int src_w, int src_h,
} }
void void
combine_pixels_sat(const DATA32 * src, int src_w, int src_h, combine_pixels_sat(const uint32_t * src, int src_w, int src_h,
DATA32 * dest, int dest_w, int dest_h, uint32_t * dest, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h, combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h,
@ -746,8 +746,8 @@ combine_pixels_sat(const DATA32 * src, int src_w, int src_h,
} }
void void
combine_pixels_val(const DATA32 * src, int src_w, int src_h, combine_pixels_val(const uint32_t * src, int src_w, int src_h,
DATA32 * dest, int dest_w, int dest_h, uint32_t * dest, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h, combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h,
@ -755,12 +755,12 @@ combine_pixels_val(const DATA32 * src, int src_w, int src_h,
} }
void void
combine_pixels_col(const DATA32 * src_, int src_w, int src_h, combine_pixels_col(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;
@ -786,12 +786,12 @@ combine_pixels_col(const DATA32 * src_, int src_w, int src_h,
} }
void void
combine_pixels_diss(const DATA32 * src_, int src_w, int src_h, combine_pixels_diss(const uint32_t * src_, int src_w, int src_h,
DATA32 * dst_, int dest_w, int dest_h, uint32_t * dst_, int dest_w, int dest_h,
int dest_x, int dest_y) int dest_x, int dest_y)
{ {
const DATA8 *src = (const DATA8 *)src_; const uint8_t *src = (const uint8_t *)src_;
DATA8 *dest = (DATA8 *) dst_; uint8_t *dest = (uint8_t *) dst_;
int x, y, s_idx, d_idx; int x, y, s_idx, d_idx;
int src_tl_x = 0, src_tl_y = 0; int src_tl_x = 0, src_tl_y = 0;
int src_br_x = src_w, src_br_y = src_h; int src_br_x = src_w, src_br_y = src_h;

6
src/modules/loaders/types.h
View File

@ -1,11 +1,7 @@
#ifndef TYPES_H #ifndef TYPES_H
#define TYPES_H 1 #define TYPES_H 1
#define DATABIG unsigned long long #include <stdint.h>
#define DATA64 unsigned long long
#define DATA32 unsigned int
#define DATA16 unsigned short
#define DATA8 unsigned char
typedef struct _ImlibLoader ImlibLoader; typedef struct _ImlibLoader ImlibLoader;