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
formats(ImlibLoader * l)
{
char *list_formats[] = { "argb", "arg" };
static const char *const list_formats[] = { "argb", "arg" };
int i;
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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 long i, w, h;
unsigned short x, y;
DATA32 *ptr, *data_end;
DATA32 *ptr;
unsigned char *buffer_ptr, *buffer, *buffer_end;
RGBQUAD rgbQuads[256];
unsigned long rmask = 0xff, gmask = 0xff, bmask = 0xff;
@ -303,7 +303,6 @@ load(ImlibImage * im, ImlibProgressFunction progress,
buffer_ptr = buffer;
buffer_end = buffer + imgsize;
data_end = im->data + w * h;
ptr = im->data + ((h - 1) * w);
if (bitcount == 1)
@ -329,16 +328,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -490,16 +489,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -532,16 +531,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -634,16 +633,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -671,16 +670,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -726,16 +725,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -766,16 +765,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -820,16 +819,16 @@ load(ImlibImage * im, ImlibProgressFunction progress,
if (progress)
{
char per;
int l;
int ll;
per = (char)((100 * y) / im->h);
if (((per - pper) >= progress_granularity) ||
(y == (im->h - 1)))
{
l = y - pl;
ll = y - pl;
if (!progress
(im, per, 0, im->h - y - 1, im->w,
im->h - y + l))
im->h - y + ll))
{
free(buffer);
return 2;
@ -851,7 +850,7 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
{
FILE *f;
Imlib_Color pixel_color;
unsigned long i, j, pad;
int i, j, pad;
if (!im->data)
return 0;
@ -902,14 +901,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void
formats(ImlibLoader * l)
{
char *list_formats[] = { "bmp" };
static const char *const list_formats[] = { "bmp" };
int i;
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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
formats(ImlibLoader * l)
{
/* this is the only bit you have to change... */
char *list_formats[] = { "bz2" };
static const char *const list_formats[] = { "bz2" };
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->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;
}
/* 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
formats(ImlibLoader * l)
{
/* this is the only bit you have to change... */
char *list_formats[] = { "gif" };
static const char *const list_formats[] = { "gif" };
int i;
/* don't bother changing any of this - it just reads this in and sets */
/* the struct values and makes copies */
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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)
{
value = tok;
tok = "index";
tok = (char *)"index";
}
else
{
@ -297,7 +297,7 @@ get_options(lopt * opt, ImlibImage * im)
if (htag && 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))
{
if (index)
@ -386,7 +386,7 @@ get_loader(lopt * opt, ImlibLoader ** loader)
return 1;
}
static char *id3_pic_types[] = {
static const char *const id3_pic_types[] = {
/* $00 */ "Other",
/* $01 */ "32x32 pixels file icon",
/* $02 */ "Other file icon",
@ -413,7 +413,7 @@ static char *id3_pic_types[] = {
#define NUM_OF_ID3_PIC_TYPES \
(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",
/* $01 */ "UTF-16 encoded Unicode with 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);
union id3_field *field;
int num_data;
unsigned int num_data;
char *data;
if ((field = id3_frame_field(frame, 1)) &&
@ -448,16 +448,20 @@ write_tags(ImlibImage * im, lopt * opt)
memcpy(dup, data, length);
__imlib_AttachTag(im, "id3-description", 0, dup, destructor_data);
}
if (field = id3_frame_field(frame, 0))
__imlib_AttachTag(im, "id3-description-text-encoding",
(num_data = (int)id3_field_gettextencoding(field)),
num_data < NUM_OF_ID3_TEXT_ENCODINGS ?
id3_text_encodings[num_data] : NULL, NULL);
if (field = id3_frame_field(frame, 2))
__imlib_AttachTag(im, "id3-picture-type",
(num_data = id3_field_getint(field)),
num_data < NUM_OF_ID3_PIC_TYPES ?
id3_pic_types[num_data] : NULL, NULL);
if ((field = id3_frame_field(frame, 0)))
{
num_data = id3_field_gettextencoding(field);
__imlib_AttachTag(im, "id3-description-text-encoding", num_data,
num_data < NUM_OF_ID3_TEXT_ENCODINGS ?
(char *)id3_text_encodings[num_data] : NULL, NULL);
}
if ((field = id3_frame_field(frame, 2)))
{
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),
NULL, NULL);
if (opt->cache_level)
@ -596,15 +600,11 @@ load(ImlibImage * im, ImlibProgressFunction progress,
void
formats(ImlibLoader * l)
{
/* this is the only bit you have to change... */
char *list_formats[] = { "mp3" };
static const char *const list_formats[] = { "mp3" };
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->formats = (char **)malloc(sizeof(char *) * l->num_formats);
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_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;
/* cinfo->err->output_message(cinfo);*/
siglongjmp(errmgr->setjmp_buffer, 1);
return;
}
static void
_JPEGErrorHandler(j_common_ptr cinfo)
{
#if 0
emptr errmgr;
errmgr = (emptr) cinfo->err;
/* cinfo->err->output_message(cinfo);*/
/* siglongjmp(errmgr->setjmp_buffer, 1);*/
return;
#endif
}
static void
_JPEGErrorHandler2(j_common_ptr cinfo, int msg_level)
{
#if 0
emptr errmgr;
errmgr = (emptr) cinfo->err;
/* cinfo->err->output_message(cinfo);*/
/* siglongjmp(errmgr->setjmp_buffer, 1);*/
return;
msg_level = 0;
#endif
}
char
@ -347,15 +347,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void
formats(ImlibLoader * l)
{
char *list_formats[] = { "jpg", "jpeg", "jfif", "jfi" };
static const char *const list_formats[] = { "jpg", "jpeg", "jfif", "jfi" };
int i;
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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. */
s = fread(c->data, 1, c->size, f);
if (s != c->size)
if (s != (size_t) c->size)
break; /* Error or short file. */
seek = 0;
@ -549,6 +549,7 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
ok = 0;
cancel = 0;
plane[0] = NULL;
gran = nexty = 0;
im->data = malloc(im->w * im->h * sizeof(DATA32));
n = ilbm.depth;
@ -637,11 +638,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void
formats(ImlibLoader * l)
{
char *list_formats[] = { "iff", "ilbm", "lbm" };
static const char *const list_formats[] = { "iff", "ilbm", "lbm" };
int i;
l->num_formats = sizeof(list_formats) / sizeof(list_formats[0]);
l->formats = malloc(l->num_formats * sizeof(list_formats[0]));
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_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
png_text text;
text.key = "Imlib2-Comment";
text.key = (char *)"Imlib2-Comment";
text.text = tag->data;
text.compression = PNG_TEXT_COMPRESSION_zTXt;
png_set_text(png_ptr, info_ptr, &(text), 1);
@ -415,18 +415,12 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void
formats(ImlibLoader * l)
{
/* this is the only bit you have to change... */
char *list_formats[] = { "png" };
static const char *const list_formats[] = { "png" };
int i;
/* don't bother changing any of this - it just reads this in and sets */
/* the struct values and makes copies */
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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 <ctype.h>
int
static int
do_progress(ImlibImage * im, ImlibProgressFunction progress,
char progress_granularity, char *pper, int *py, int y)
{
@ -632,15 +632,13 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
void
formats(ImlibLoader * l)
{
char *list_formats[] = { "pnm", "ppm", "pgm", "pbm", "pam" };
static const char *const list_formats[] =
{ "pnm", "ppm", "pgm", "pbm", "pam" };
int i;
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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;
}
if (ss.st_size < sizeof(tga_header) + sizeof(tga_footer))
if (ss.st_size < (long)(sizeof(tga_header) + sizeof(tga_footer)))
{
close(fd);
return 0;
@ -329,7 +329,7 @@ load(ImlibImage * im, ImlibProgressFunction progress,
/* bufptr is the next byte to be read from the buffer */
bufptr = filedata;
bufend = filedata + datasize;
bufend = bufptr + datasize;
/* dataptr is the next 32-bit pixel to be filled in */
dataptr = im->data;
@ -516,16 +516,14 @@ load(ImlibImage * im, ImlibProgressFunction progress,
void
formats(ImlibLoader * l)
{
char *list_formats[] = { "tga" };
static const char *const list_formats[] = { "tga" };
int i;
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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,
uint32 x, uint32 y, uint32 w, uint32 h)
{
int image_width, image_height;
uint32 image_width, image_height;
uint32 *pixel, pixel_value;
int i, j, k;
uint32 i, j, k;
DATA32 *buffer_pixel, *buffer = img->image->data;
int alpha_premult;
int a, r, g, b;
@ -408,7 +408,7 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
uint8 *buf = NULL;
DATA32 pixel, *data = im->data;
double alpha_factor;
uint32 x, y;
int x, y;
uint8 r, g, b, a = 0;
int has_alpha = IMAGE_HAS_ALPHA(im);
int i = 0, pl = 0;
@ -579,27 +579,15 @@ save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
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
formats(ImlibLoader * l)
{
/* this is the only bit you have to change... */
char *list_formats[] = { "tiff", "tif" };
static const char *const list_formats[] = { "tiff", "tif" };
int i;
/* don't bother changing any of this - it just reads this in and sets */
/* the struct values and makes copies */
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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];
int lsz = 256;
struct _cmap {
unsigned char str[6];
char str[6];
unsigned char transp;
short r, g, b;
} *cmap;
@ -649,7 +649,7 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
lsz += 256;
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)))
done = 1;
}
@ -668,27 +668,15 @@ load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
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
formats(ImlibLoader * l)
{
/* this is the only bit you have to change... */
char *list_formats[] = { "xpm" };
static const char *const list_formats[] = { "xpm" };
int i;
/* don't bother changing any of this - it just reads this in and sets */
/* the struct values and makes copies */
{
int i;
l->num_formats = sizeof(list_formats) / sizeof(char *);
l->formats = malloc(sizeof(char *) * l->num_formats);
l->num_formats = (sizeof(list_formats) / sizeof(char *));
l->formats = malloc(sizeof(char *) * l->num_formats);
for (i = 0; i < l->num_formats; i++)
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
formats(ImlibLoader * l)
{
/* this is the only bit you have to change... */
char *list_formats[] = { "gz" };
static const char *const list_formats[] = { "gz" };
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->formats = malloc(sizeof(char *) * l->num_formats);