ccandy
/
legacy-imlib2
forked from old/legacy-imlib2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Silence compiler warnings (loaders).

This commit is contained in:
Kim Woelders 2013-07-02 22:47:17 +02:00
parent 0c647a7f24
commit 357852ebb9
13 changed files with 123 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/modules/loaders/loader_argb.c
View File

@ -176,14 +176,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
char *list_formats[] = { "argb", "arg" }; static const char *const list_formats[] = { "argb", "arg" };
int i;
{ l->num_formats = sizeof(list_formats) / sizeof(char *);
int i; l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

67
src/modules/loaders/loader_bmp.c
View File

@ -115,7 +115,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
unsigned char byte = 0, g, b, r; unsigned char byte = 0, g, b, r;
unsigned long i, w, h; unsigned long i, w, h;
unsigned short x, y; unsigned short x, y;
DATA32 *ptr, *data_end; DATA32 *ptr;
unsigned char *buffer_ptr, *buffer, *buffer_end; unsigned char *buffer_ptr, *buffer, *buffer_end;
RGBQUAD rgbQuads[256]; RGBQUAD rgbQuads[256];
unsigned long rmask = 0xff, gmask = 0xff, bmask = 0xff; unsigned long rmask = 0xff, gmask = 0xff, bmask = 0xff;
@ -303,7 +303,6 @@ load(ImlibImage * im, ImlibProgressFunction progress,
buffer_ptr = buffer; buffer_ptr = buffer;
buffer_end = buffer + imgsize; buffer_end = buffer + imgsize;
data_end = im->data + w * h;
ptr = im->data + ((h - 1) * w); ptr = im->data + ((h - 1) * w);
if (bitcount == 1) if (bitcount == 1)
@ -329,16 +328,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -490,16 +489,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -532,16 +531,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -634,16 +633,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -671,16 +670,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -726,16 +725,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -766,16 +765,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -820,16 +819,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress) if (progress)
{ {
char per; char per;
int l; int ll;
per = (char)((100 * y) / im->h); per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) || if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1))) (y == (im->h - 1)))
{ {
l = y - pl; ll = y - pl;
if (!progress if (!progress
(im, per, 0, im->h - y - 1, im->w, (im, per, 0, im->h - y - 1, im->w,
im->h - y + l)) im->h - y + ll))
{ {
free(buffer); free(buffer);
return 2; return 2;
@ -851,7 +850,7 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
{ {
FILE *f; FILE *f;
Imlib_Color pixel_color; Imlib_Color pixel_color;
unsigned long i, j, pad; int i, j, pad;
if (!im->data) if (!im->data)
return 0; return 0;
@ -902,14 +901,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
char *list_formats[] = { "bmp" }; static const char *const list_formats[] = { "bmp" };
int i;
{ l->num_formats = sizeof(list_formats) / sizeof(char *);
int i; l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

6
src/modules/loaders/loader_bz2.c
View File

@ -119,13 +119,9 @@ load(ImlibImage * im, ImlibProgressFunction progress,
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
/* this is the only bit you have to change... */ static const char *const list_formats[] = { "bz2" };
char *list_formats[] = { "bz2" };
int i; int i;
/* don't bother changing any of this - it just reads this in
* and sets the struct values and makes copies
*/
l->num_formats = sizeof(list_formats) / sizeof(char *); l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats = malloc(sizeof(char *) * l->num_formats);

24
src/modules/loaders/loader_gif.c
View File

@ -207,27 +207,15 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
return 1; return 1;
} }
/* fills the ImlibLoader struct with a strign array of format file */
/* extensions this loader can load. eg: */
/* loader->formats = { "jpeg", "jpg"}; */
/* giving permutations is a good idea. case sensitivity is irrelevant */
/* your laoder CAN load more than one format if it likes - like: */
/* loader->formats = { "gif", "png", "jpeg", "jpg"} */
/* if it can load those formats. */
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
/* this is the only bit you have to change... */ static const char *const list_formats[] = { "gif" };
char *list_formats[] = { "gif" }; int i;
/* don't bother changing any of this - it just reads this in and sets */ l->num_formats = sizeof(list_formats) / sizeof(char *);
/* the struct values and makes copies */ l->formats = malloc(sizeof(char *) * l->num_formats);
{
int i;
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

42
src/modules/loaders/loader_id3.c
View File

@ -257,7 +257,7 @@ get_options(lopt * opt, ImlibImage * im)
if (!value) if (!value)
{ {
value = tok; value = tok;
tok = "index"; tok = (char *)"index";
} }
else else
{ {
@ -297,7 +297,7 @@ get_options(lopt * opt, ImlibImage * im)
if (htag && htag->val) if (htag && htag->val)
index = htag->val; index = htag->val;
} }
if (index < 0 || index > id3_tag_get_numframes(ctx->tag) || if (index > id3_tag_get_numframes(ctx->tag) ||
(index == 0 && id3_tag_get_numframes(ctx->tag) < 1)) (index == 0 && id3_tag_get_numframes(ctx->tag) < 1))
{ {
if (index) if (index)
@ -386,7 +386,7 @@ get_loader(lopt * opt, ImlibLoader ** loader)
return 1; return 1;
} }
static char *id3_pic_types[] = { static const char *const id3_pic_types[] = {
/* $00 */ "Other", /* $00 */ "Other",
/* $01 */ "32x32 pixels file icon", /* $01 */ "32x32 pixels file icon",
/* $02 */ "Other file icon", /* $02 */ "Other file icon",
@ -413,7 +413,7 @@ static char *id3_pic_types[] = {
#define NUM_OF_ID3_PIC_TYPES \ #define NUM_OF_ID3_PIC_TYPES \
(sizeof(id3_pic_types) / sizeof(id3_pic_types[0])) (sizeof(id3_pic_types) / sizeof(id3_pic_types[0]))
static char *id3_text_encodings[] = { static const char *const id3_text_encodings[] = {
/* $00 */ "ISO-8859-1", /* $00 */ "ISO-8859-1",
/* $01 */ "UTF-16 encoded Unicode with BOM", /* $01 */ "UTF-16 encoded Unicode with BOM",
/* $02 */ "UTF-16BE encoded Unicode without BOM", /* $02 */ "UTF-16BE encoded Unicode without BOM",
@ -428,7 +428,7 @@ write_tags(ImlibImage * im, lopt * opt)
{ {
struct id3_frame *frame = id3_tag_get_frame(opt->ctx->tag, opt->index - 1); struct id3_frame *frame = id3_tag_get_frame(opt->ctx->tag, opt->index - 1);
union id3_field *field; union id3_field *field;
int num_data; unsigned int num_data;
char *data; char *data;
if ((field = id3_frame_field(frame, 1)) && if ((field = id3_frame_field(frame, 1)) &&
@ -448,16 +448,20 @@ write_tags(ImlibImage * im, lopt * opt)
memcpy(dup, data, length); memcpy(dup, data, length);
__imlib_AttachTag(im, "id3-description", 0, dup, destructor_data); __imlib_AttachTag(im, "id3-description", 0, dup, destructor_data);
} }
if (field = id3_frame_field(frame, 0)) if ((field = id3_frame_field(frame, 0)))
__imlib_AttachTag(im, "id3-description-text-encoding", {
(num_data = (int)id3_field_gettextencoding(field)), num_data = id3_field_gettextencoding(field);
num_data < NUM_OF_ID3_TEXT_ENCODINGS ? __imlib_AttachTag(im, "id3-description-text-encoding", num_data,
id3_text_encodings[num_data] : NULL, NULL); num_data < NUM_OF_ID3_TEXT_ENCODINGS ?
if (field = id3_frame_field(frame, 2)) (char *)id3_text_encodings[num_data] : NULL, NULL);
__imlib_AttachTag(im, "id3-picture-type", }
(num_data = id3_field_getint(field)), if ((field = id3_frame_field(frame, 2)))
num_data < NUM_OF_ID3_PIC_TYPES ? {
id3_pic_types[num_data] : NULL, NULL); num_data = id3_field_getint(field);
__imlib_AttachTag(im, "id3-picture-type", num_data,
num_data < NUM_OF_ID3_PIC_TYPES ?
(char *)id3_pic_types[num_data] : NULL, NULL);
}
__imlib_AttachTag(im, "count", id3_tag_get_numframes(opt->ctx->tag), __imlib_AttachTag(im, "count", id3_tag_get_numframes(opt->ctx->tag),
NULL, NULL); NULL, NULL);
if (opt->cache_level) if (opt->cache_level)
@ -596,15 +600,11 @@ load(ImlibImage * im, ImlibProgressFunction progress,
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
/* this is the only bit you have to change... */ static const char *const list_formats[] = { "mp3" };
char *list_formats[] = { "mp3" };
int i; int i;
/* don't bother changing any of this - it just reads this in
* and sets the struct values and makes copies
*/
l->num_formats = sizeof(list_formats) / sizeof(char *); l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = (char **)malloc(sizeof(char *) * l->num_formats); l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++) for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]); l->formats[i] = strdup(list_formats[i]);

23
src/modules/loaders/loader_jpeg.c
View File

@ -16,30 +16,30 @@ _JPEGFatalErrorHandler(j_common_ptr cinfo)
errmgr = (emptr) cinfo->err; errmgr = (emptr) cinfo->err;
/* cinfo->err->output_message(cinfo);*/ /* cinfo->err->output_message(cinfo);*/
siglongjmp(errmgr->setjmp_buffer, 1); siglongjmp(errmgr->setjmp_buffer, 1);
return;
} }
static void static void
_JPEGErrorHandler(j_common_ptr cinfo) _JPEGErrorHandler(j_common_ptr cinfo)
{ {
#if 0
emptr errmgr; emptr errmgr;
errmgr = (emptr) cinfo->err; errmgr = (emptr) cinfo->err;
/* cinfo->err->output_message(cinfo);*/ /* cinfo->err->output_message(cinfo);*/
/* siglongjmp(errmgr->setjmp_buffer, 1);*/ /* siglongjmp(errmgr->setjmp_buffer, 1);*/
return; #endif
} }
static void static void
_JPEGErrorHandler2(j_common_ptr cinfo, int msg_level) _JPEGErrorHandler2(j_common_ptr cinfo, int msg_level)
{ {
#if 0
emptr errmgr; emptr errmgr;
errmgr = (emptr) cinfo->err; errmgr = (emptr) cinfo->err;
/* cinfo->err->output_message(cinfo);*/ /* cinfo->err->output_message(cinfo);*/
/* siglongjmp(errmgr->setjmp_buffer, 1);*/ /* siglongjmp(errmgr->setjmp_buffer, 1);*/
return; #endif
msg_level = 0;
} }
char char
@ -347,15 +347,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
char *list_formats[] = { "jpg", "jpeg", "jfif", "jfi" }; static const char *const list_formats[] = { "jpg", "jpeg", "jfif", "jfi" };
int i;
{ l->num_formats = sizeof(list_formats) / sizeof(char *);
int i; l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

10
src/modules/loaders/loader_lbm.c
View File

@ -129,7 +129,7 @@ loadchunks(char *name, ILBM * ilbm, int full)
break; /* Out of memory. */ break; /* Out of memory. */
s = fread(c->data, 1, c->size, f); s = fread(c->data, 1, c->size, f);
if (s != c->size) if (s != (size_t) c->size)
break; /* Error or short file. */ break; /* Error or short file. */
seek = 0; seek = 0;
@ -549,6 +549,7 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
ok = 0; ok = 0;
cancel = 0; cancel = 0;
plane[0] = NULL; plane[0] = NULL;
gran = nexty = 0;
im->data = malloc(im->w * im->h * sizeof(DATA32)); im->data = malloc(im->w * im->h * sizeof(DATA32));
n = ilbm.depth; n = ilbm.depth;
@ -637,11 +638,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
char *list_formats[] = { "iff", "ilbm", "lbm" }; static const char *const list_formats[] = { "iff", "ilbm", "lbm" };
int i; int i;
l->num_formats = sizeof(list_formats) / sizeof(list_formats[0]); l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(l->num_formats * sizeof(list_formats[0])); l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++) for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]); l->formats[i] = strdup(list_formats[i]);
} }

20
src/modules/loaders/loader_png.c
View File

@ -333,7 +333,7 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
#ifdef PNG_TEXT_SUPPORTED #ifdef PNG_TEXT_SUPPORTED
png_text text; png_text text;
text.key = "Imlib2-Comment"; text.key = (char *)"Imlib2-Comment";
text.text = tag->data; text.text = tag->data;
text.compression = PNG_TEXT_COMPRESSION_zTXt; text.compression = PNG_TEXT_COMPRESSION_zTXt;
png_set_text(png_ptr, info_ptr, &(text), 1); png_set_text(png_ptr, info_ptr, &(text), 1);
@ -415,18 +415,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
/* this is the only bit you have to change... */ static const char *const list_formats[] = { "png" };
char *list_formats[] = { "png" }; int i;
/* don't bother changing any of this - it just reads this in and sets */ l->num_formats = sizeof(list_formats) / sizeof(char *);
/* the struct values and makes copies */ l->formats = malloc(sizeof(char *) * l->num_formats);
{
int i;
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

18
src/modules/loaders/loader_pnm.c
View File

@ -1,7 +1,7 @@
#include "loader_common.h" #include "loader_common.h"
#include <ctype.h> #include <ctype.h>
int static int
do_progress(ImlibImage * im, ImlibProgressFunction progress, do_progress(ImlibImage * im, ImlibProgressFunction progress,
char progress_granularity, char *pper, int *py, int y) char progress_granularity, char *pper, int *py, int y)
{ {
@ -632,15 +632,13 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
char *list_formats[] = { "pnm", "ppm", "pgm", "pbm", "pam" }; static const char *const list_formats[] =
{ "pnm", "ppm", "pgm", "pbm", "pam" };
int i;
{ l->num_formats = sizeof(list_formats) / sizeof(char *);
int i; l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

18
src/modules/loaders/loader_tga.c
View File

@ -213,7 +213,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
return 0; return 0;
} }
if (ss.st_size < sizeof(tga_header) + sizeof(tga_footer)) if (ss.st_size < (long)(sizeof(tga_header) + sizeof(tga_footer)))
{ {
close(fd); close(fd);
return 0; return 0;
@ -329,7 +329,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
/* bufptr is the next byte to be read from the buffer */ /* bufptr is the next byte to be read from the buffer */
bufptr = filedata; bufptr = filedata;
bufend = filedata + datasize; bufend = bufptr + datasize;
/* dataptr is the next 32-bit pixel to be filled in */ /* dataptr is the next 32-bit pixel to be filled in */
dataptr = im->data; dataptr = im->data;
@ -516,16 +516,14 @@ load(ImlibImage * im, ImlibProgressFunction progress,
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
char *list_formats[] = { "tga" }; static const char *const list_formats[] = { "tga" };
int i;
{ l->num_formats = sizeof(list_formats) / sizeof(char *);
int i; l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }
/**********************/ /**********************/

30
src/modules/loaders/loader_tiff.c
View File

@ -54,9 +54,9 @@ static void
raster(TIFFRGBAImage_Extra * img, uint32 * rast, raster(TIFFRGBAImage_Extra * img, uint32 * rast,
uint32 x, uint32 y, uint32 w, uint32 h) uint32 x, uint32 y, uint32 w, uint32 h)
{ {
int image_width, image_height; uint32 image_width, image_height;
uint32 *pixel, pixel_value; uint32 *pixel, pixel_value;
int i, j, k; uint32 i, j, k;
DATA32 *buffer_pixel, *buffer = img->image->data; DATA32 *buffer_pixel, *buffer = img->image->data;
int alpha_premult; int alpha_premult;
int a, r, g, b; int a, r, g, b;
@ -408,7 +408,7 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
uint8 *buf = NULL; uint8 *buf = NULL;
DATA32 pixel, *data = im->data; DATA32 pixel, *data = im->data;
double alpha_factor; double alpha_factor;
uint32 x, y; int x, y;
uint8 r, g, b, a = 0; uint8 r, g, b, a = 0;
int has_alpha = IMAGE_HAS_ALPHA(im); int has_alpha = IMAGE_HAS_ALPHA(im);
int i = 0, pl = 0; int i = 0, pl = 0;
@ -579,27 +579,15 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
return 1; return 1;
} }
/* fills the ImlibLoader struct with a strign array of format file */
/* extensions this loader can load. eg: */
/* loader->formats = { "jpeg", "jpg"}; */
/* giving permutations is a good idea. case sensitivity is irrelevant */
/* your laoder CAN load more than one format if it likes - like: */
/* loader->formats = { "gif", "png", "jpeg", "jpg"} */
/* if it can load those formats. */
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
/* this is the only bit you have to change... */ static const char *const list_formats[] = { "tiff", "tif" };
char *list_formats[] = { "tiff", "tif" }; int i;
/* don't bother changing any of this - it just reads this in and sets */ l->num_formats = sizeof(list_formats) / sizeof(char *);
/* the struct values and makes copies */ l->formats = malloc(sizeof(char *) * l->num_formats);
{
int i;
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

28
src/modules/loaders/loader_xpm.c
View File

@ -102,7 +102,7 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
char *line, s[256], tok[256], col[256]; char *line, s[256], tok[256], col[256];
int lsz = 256; int lsz = 256;
struct _cmap { struct _cmap {
unsigned char str[6]; char str[6];
unsigned char transp; unsigned char transp;
short r, g, b; short r, g, b;
} *cmap; } *cmap;
@ -649,7 +649,7 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
lsz += 256; lsz += 256;
line = realloc(line, lsz); line = realloc(line, lsz);
} }
if (((ptr) && ((ptr - im->data) >= (w * h * sizeof(DATA32)))) || if (((ptr) && ((ptr - im->data) >= (w * h * (int)sizeof(DATA32)))) ||
((context > 1) && (count >= pixels))) ((context > 1) && (count >= pixels)))
done = 1; done = 1;
} }
@ -668,27 +668,15 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
return 1; return 1;
} }
/* fills the ImlibLoader struct with a strign array of format file */
/* extensions this loader can load. eg: */
/* loader->formats = { "jpeg", "jpg"}; */
/* giving permutations is a good idea. case sensitivity is irrelevant */
/* your laoder CAN load more than one format if it likes - like: */
/* loader->formats = { "gif", "png", "jpeg", "jpg"} */
/* if it can load those formats. */
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
/* this is the only bit you have to change... */ static const char *const list_formats[] = { "xpm" };
char *list_formats[] = { "xpm" }; int i;
/* don't bother changing any of this - it just reads this in and sets */ l->num_formats = sizeof(list_formats) / sizeof(char *);
/* the struct values and makes copies */ l->formats = malloc(sizeof(char *) * l->num_formats);
{
int i;
l->num_formats = (sizeof(list_formats) / sizeof(char *)); for (i = 0; i < l->num_formats; i++)
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats[i] = strdup(list_formats[i]);
for (i = 0; i < l->num_formats; i++)
l->formats[i] = strdup(list_formats[i]);
}
} }

6
src/modules/loaders/loader_zlib.c
View File

@ -116,13 +116,9 @@ load(ImlibImage * im, ImlibProgressFunction progress,
void void
formats(ImlibLoader * l) formats(ImlibLoader * l)
{ {
/* this is the only bit you have to change... */ static const char *const list_formats[] = { "gz" };
char *list_formats[] = { "gz" };
int i; int i;
/* don't bother changing any of this - it just reads this in
* and sets the struct values and makes copies
*/
l->num_formats = sizeof(list_formats) / sizeof(char *); l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats); l->formats = malloc(sizeof(char *) * l->num_formats);