forked from old/legacy-imlib2
Silence compiler warnings (loaders).
This commit is contained in:
parent
0c647a7f24
commit
357852ebb9
|
@ -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;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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" };
|
||||
|
||||
/* don't bother changing any of this - it just reads this in and sets */
|
||||
/* the struct values and makes copies */
|
||||
{
|
||||
static const char *const list_formats[] = { "gif" };
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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)),
|
||||
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 ?
|
||||
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)),
|
||||
(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 ?
|
||||
id3_pic_types[num_data] : NULL, NULL);
|
||||
(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]);
|
||||
|
|
|
@ -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;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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]);
|
||||
}
|
||||
|
|
|
@ -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" };
|
||||
|
||||
/* don't bother changing any of this - it just reads this in and sets */
|
||||
/* the struct values and makes copies */
|
||||
{
|
||||
static const char *const list_formats[] = { "png" };
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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,17 +516,15 @@ load(ImlibImage * im, ImlibProgressFunction progress,
|
|||
void
|
||||
formats(ImlibLoader * l)
|
||||
{
|
||||
char *list_formats[] = { "tga" };
|
||||
|
||||
{
|
||||
static const char *const list_formats[] = { "tga" };
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
||||
/**********************/
|
||||
|
||||
|
|
|
@ -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" };
|
||||
|
||||
/* don't bother changing any of this - it just reads this in and sets */
|
||||
/* the struct values and makes copies */
|
||||
{
|
||||
static const char *const list_formats[] = { "tiff", "tif" };
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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" };
|
||||
|
||||
/* don't bother changing any of this - it just reads this in and sets */
|
||||
/* the struct values and makes copies */
|
||||
{
|
||||
static const char *const list_formats[] = { "xpm" };
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof(char *));
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
Loading…
Reference in New Issue