forked from old/legacy-imlib2
loaders: Cosmetics
- Add missing const - Consistently use imdata for pointer into imlib image data - Minor changes
This commit is contained in:
parent
a55f36133d
commit
41c792bd7e
|
|
@ -38,7 +38,7 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
int rc;
|
||||
int alpha;
|
||||
uint32_t *ptr;
|
||||
uint32_t *imdata;
|
||||
int y;
|
||||
const char *fptr, *row;
|
||||
unsigned int size;
|
||||
|
|
@ -78,22 +78,22 @@ _load(ImlibImage * im, int load_data)
|
|||
|
||||
/* Load data */
|
||||
|
||||
ptr = __imlib_AllocateData(im);
|
||||
if (!ptr)
|
||||
imdata = __imlib_AllocateData(im);
|
||||
if (!imdata)
|
||||
QUIT_WITH_RC(LOAD_OOM);
|
||||
|
||||
mm_seek(row - fptr);
|
||||
|
||||
for (y = 0; y < im->h; y++)
|
||||
{
|
||||
if (mm_read(ptr, 4 * im->w))
|
||||
if (mm_read(imdata, 4 * im->w))
|
||||
goto quit;
|
||||
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
for (l = 0; l < im->w; l++)
|
||||
SWAP_LE_32_INPLACE(ptr[l]);
|
||||
SWAP_LE_32_INPLACE(imdata[l]);
|
||||
#endif
|
||||
ptr += im->w;
|
||||
imdata += im->w;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, y, 1))
|
||||
QUIT_WITH_RC(LOAD_BREAK);
|
||||
|
|
@ -110,7 +110,7 @@ _save(ImlibImage * im)
|
|||
{
|
||||
int rc;
|
||||
FILE *f = im->fi->fp;
|
||||
uint32_t *ptr;
|
||||
const uint32_t *imdata;
|
||||
int y, alpha = 0;
|
||||
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
|
|
@ -121,22 +121,21 @@ _save(ImlibImage * im)
|
|||
|
||||
fprintf(f, "ARGB %i %i %i\n", im->w, im->h, alpha);
|
||||
|
||||
ptr = im->data;
|
||||
for (y = 0; y < im->h; y++)
|
||||
imdata = im->data;
|
||||
for (y = 0; y < im->h; y++, imdata += im->w)
|
||||
{
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int x;
|
||||
|
||||
memcpy(buf, ptr, im->w * 4);
|
||||
memcpy(buf, imdata, im->w * 4);
|
||||
for (x = 0; x < im->w; x++)
|
||||
SWAP_LE_32_INPLACE(buf[x]);
|
||||
fwrite(buf, im->w, 4, f);
|
||||
}
|
||||
#else
|
||||
fwrite(ptr, im->w, 4, f);
|
||||
fwrite(imdata, im->w, 4, f);
|
||||
#endif
|
||||
ptr += im->w;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, y, 1))
|
||||
QUIT_WITH_RC(LOAD_BREAK);
|
||||
|
|
|
|||
|
|
@ -167,7 +167,7 @@ _load(ImlibImage * im, int load_data)
|
|||
unsigned char byte = 0, byte1, byte2;
|
||||
unsigned int i, k;
|
||||
int w, h, x, y, j, l;
|
||||
uint32_t *ptr, pixel;
|
||||
uint32_t *imdata, pixel;
|
||||
const unsigned char *buffer_ptr, *buffer_end, *buffer_end_safe;
|
||||
RGBQUAD rgbQuads[256];
|
||||
uint32_t argbCmap[256];
|
||||
|
|
@ -407,7 +407,7 @@ _load(ImlibImage * im, int load_data)
|
|||
buffer_ptr = fptr;
|
||||
buffer_end = fptr + imgsize;
|
||||
|
||||
ptr = im->data + ((h - 1) * w);
|
||||
imdata = im->data + ((h - 1) * w);
|
||||
|
||||
switch (bitcount)
|
||||
{
|
||||
|
|
@ -429,11 +429,11 @@ _load(ImlibImage * im, int load_data)
|
|||
if ((x & 7) == 0)
|
||||
byte = *buffer_ptr++;
|
||||
k = (byte >> 7) & 1;
|
||||
*ptr++ = argbCmap[k];
|
||||
*imdata++ = argbCmap[k];
|
||||
byte <<= 1;
|
||||
}
|
||||
buffer_ptr += skip;
|
||||
ptr -= w * 2;
|
||||
imdata -= w * 2;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, h - y - 1, -1))
|
||||
QUIT_WITH_RC(LOAD_BREAK);
|
||||
|
|
@ -474,9 +474,9 @@ _load(ImlibImage * im, int load_data)
|
|||
t2 = argbCmap[byte2 & 0xF];
|
||||
for (j = 0; j < l; j++)
|
||||
{
|
||||
*ptr++ = t1;
|
||||
*imdata++ = t1;
|
||||
if (++j < l)
|
||||
*ptr++ = t2;
|
||||
*imdata++ = t2;
|
||||
}
|
||||
x += l;
|
||||
}
|
||||
|
|
@ -488,7 +488,7 @@ _load(ImlibImage * im, int load_data)
|
|||
x = 0;
|
||||
if (++y >= h)
|
||||
goto bail_bc4;
|
||||
ptr = im->data + (h - y - 1) * w;
|
||||
imdata = im->data + (h - y - 1) * w;
|
||||
break;
|
||||
case RLE_END:
|
||||
x = 0;
|
||||
|
|
@ -507,7 +507,7 @@ _load(ImlibImage * im, int load_data)
|
|||
goto bail_bc4;
|
||||
if (y >= h)
|
||||
goto bail_bc4;
|
||||
ptr = im->data + (h - y - 1) * w + x;
|
||||
imdata = im->data + (h - y - 1) * w + x;
|
||||
break;
|
||||
default:
|
||||
l = byte2;
|
||||
|
|
@ -522,9 +522,9 @@ _load(ImlibImage * im, int load_data)
|
|||
byte = *buffer_ptr++;
|
||||
DD("%3d %3d: %d/%d: %2d %2d\n",
|
||||
x, y, j, l, byte >> 4, byte & 0xf);
|
||||
*ptr++ = argbCmap[byte >> 4];
|
||||
*imdata++ = argbCmap[byte >> 4];
|
||||
if (++j < l)
|
||||
*ptr++ = argbCmap[byte & 0xF];
|
||||
*imdata++ = argbCmap[byte & 0xF];
|
||||
}
|
||||
x += l;
|
||||
|
||||
|
|
@ -554,11 +554,11 @@ _load(ImlibImage * im, int load_data)
|
|||
if ((x & 1) == 0)
|
||||
byte = *buffer_ptr++;
|
||||
k = (byte & 0xF0) >> 4;
|
||||
*ptr++ = argbCmap[k];
|
||||
*imdata++ = argbCmap[k];
|
||||
byte <<= 4;
|
||||
}
|
||||
buffer_ptr += skip;
|
||||
ptr -= w * 2;
|
||||
imdata -= w * 2;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, h - y - 1, -1))
|
||||
QUIT_WITH_RC(LOAD_BREAK);
|
||||
|
|
@ -591,7 +591,7 @@ _load(ImlibImage * im, int load_data)
|
|||
if (x + l > w)
|
||||
goto bail_bc8;
|
||||
for (j = l; j; j--)
|
||||
*ptr++ = pixel;
|
||||
*imdata++ = pixel;
|
||||
x += l;
|
||||
}
|
||||
else
|
||||
|
|
@ -602,7 +602,7 @@ _load(ImlibImage * im, int load_data)
|
|||
x = 0;
|
||||
if (++y >= h)
|
||||
goto bail_bc8;
|
||||
ptr = im->data + ((h - y - 1) * w) + x;
|
||||
imdata = im->data + ((h - y - 1) * w) + x;
|
||||
break;
|
||||
case RLE_END:
|
||||
x = 0;
|
||||
|
|
@ -621,7 +621,7 @@ _load(ImlibImage * im, int load_data)
|
|||
goto bail_bc8;
|
||||
if (y >= h)
|
||||
goto bail_bc8;
|
||||
ptr = im->data + ((h - y - 1) * w) + x;
|
||||
imdata = im->data + ((h - y - 1) * w) + x;
|
||||
break;
|
||||
default:
|
||||
l = byte2;
|
||||
|
|
@ -634,7 +634,7 @@ _load(ImlibImage * im, int load_data)
|
|||
byte = *buffer_ptr++;
|
||||
DD("%3d %3d: %d/%d: %2d\n",
|
||||
x, y, j, l, byte);
|
||||
*ptr++ = argbCmap[byte];
|
||||
*imdata++ = argbCmap[byte];
|
||||
}
|
||||
x += l;
|
||||
if (l & 1)
|
||||
|
|
@ -661,9 +661,9 @@ _load(ImlibImage * im, int load_data)
|
|||
for (x = 0; x < w && buffer_ptr < buffer_end; x++)
|
||||
{
|
||||
byte = *buffer_ptr++;
|
||||
*ptr++ = argbCmap[byte];
|
||||
*imdata++ = argbCmap[byte];
|
||||
}
|
||||
ptr -= w * 2;
|
||||
imdata -= w * 2;
|
||||
buffer_ptr += skip;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, h - y - 1, -1))
|
||||
|
|
@ -690,10 +690,10 @@ _load(ImlibImage * im, int load_data)
|
|||
r = SCALE(r, pixel);
|
||||
g = SCALE(g, pixel);
|
||||
b = SCALE(b, pixel);
|
||||
*ptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
buffer_ptr += 2;
|
||||
}
|
||||
ptr -= w * 2;
|
||||
imdata -= w * 2;
|
||||
buffer_ptr += skip;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, h - y - 1, -1))
|
||||
|
|
@ -712,9 +712,9 @@ _load(ImlibImage * im, int load_data)
|
|||
b = *buffer_ptr++;
|
||||
g = *buffer_ptr++;
|
||||
r = *buffer_ptr++;
|
||||
*ptr++ = PIXEL_ARGB(0xff, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(0xff, r, g, b);
|
||||
}
|
||||
ptr -= w * 2;
|
||||
imdata -= w * 2;
|
||||
buffer_ptr += skip;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, h - y - 1, -1))
|
||||
|
|
@ -739,10 +739,10 @@ _load(ImlibImage * im, int load_data)
|
|||
r = SCALE(r, pixel);
|
||||
g = SCALE(g, pixel);
|
||||
b = SCALE(b, pixel);
|
||||
*ptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
buffer_ptr += 4;
|
||||
}
|
||||
ptr -= w * 2;
|
||||
imdata -= w * 2;
|
||||
buffer_ptr += skip;
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, h - y - 1, -1))
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ _load(ImlibImage * im, int load_data)
|
|||
int rowlen, i, j;
|
||||
const ff_hdr_t *hdr;
|
||||
const uint16_t *row;
|
||||
uint8_t *dat;
|
||||
uint8_t *imdata;
|
||||
|
||||
rc = LOAD_FAIL;
|
||||
|
||||
|
|
@ -51,9 +51,9 @@ _load(ImlibImage * im, int load_data)
|
|||
|
||||
rowlen = 4 * im->w; /* RGBA */
|
||||
|
||||
dat = (uint8_t *) im->data;
|
||||
imdata = (uint8_t *) im->data;
|
||||
row = (uint16_t *) (hdr + 1);
|
||||
for (i = 0; i < im->h; i++, dat += rowlen, row += rowlen)
|
||||
for (i = 0; i < im->h; i++, imdata += rowlen, row += rowlen)
|
||||
{
|
||||
if (!mm_check(row + rowlen))
|
||||
goto quit;
|
||||
|
|
@ -64,10 +64,10 @@ _load(ImlibImage * im, int load_data)
|
|||
* 16-Bit to 8-Bit (RGBA -> BGRA)
|
||||
* 255 * 257 = 65535 = 2^16-1 = UINT16_MAX
|
||||
*/
|
||||
dat[j + 2] = ntohs(row[j + 0]) / 257;
|
||||
dat[j + 1] = ntohs(row[j + 1]) / 257;
|
||||
dat[j + 0] = ntohs(row[j + 2]) / 257;
|
||||
dat[j + 3] = ntohs(row[j + 3]) / 257;
|
||||
imdata[j + 2] = ntohs(row[j + 0]) / 257;
|
||||
imdata[j + 1] = ntohs(row[j + 1]) / 257;
|
||||
imdata[j + 0] = ntohs(row[j + 2]) / 257;
|
||||
imdata[j + 3] = ntohs(row[j + 3]) / 257;
|
||||
}
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, i, 1))
|
||||
|
|
@ -88,7 +88,7 @@ _save(ImlibImage * im)
|
|||
size_t rowlen, i, j;
|
||||
uint32_t tmp32;
|
||||
uint16_t *row;
|
||||
uint8_t *dat;
|
||||
const uint8_t *imdata;
|
||||
|
||||
rc = LOAD_FAIL;
|
||||
row = NULL;
|
||||
|
|
@ -110,8 +110,8 @@ _save(ImlibImage * im)
|
|||
if (!row)
|
||||
goto quit;
|
||||
|
||||
dat = (uint8_t *) im->data;
|
||||
for (i = 0; i < (uint32_t) im->h; ++i, dat += rowlen)
|
||||
imdata = (uint8_t *) im->data;
|
||||
for (i = 0; i < (uint32_t) im->h; ++i, imdata += rowlen)
|
||||
{
|
||||
for (j = 0; j < rowlen; j += 4)
|
||||
{
|
||||
|
|
@ -119,10 +119,10 @@ _save(ImlibImage * im)
|
|||
* 8-Bit to 16-Bit
|
||||
* 255 * 257 = 65535 = 2^16-1 = UINT16_MAX
|
||||
*/
|
||||
row[j + 0] = htons(dat[j + 2] * 257);
|
||||
row[j + 1] = htons(dat[j + 1] * 257);
|
||||
row[j + 2] = htons(dat[j + 0] * 257);
|
||||
row[j + 3] = htons(dat[j + 3] * 257);
|
||||
row[j + 0] = htons(imdata[j + 2] * 257);
|
||||
row[j + 1] = htons(imdata[j + 1] * 257);
|
||||
row[j + 2] = htons(imdata[j + 0] * 257);
|
||||
row[j + 3] = htons(imdata[j + 3] * 257);
|
||||
}
|
||||
if (fwrite(row, sizeof(uint16_t), rowlen, f) != rowlen)
|
||||
goto quit;
|
||||
|
|
|
|||
|
|
@ -270,7 +270,7 @@ _load(ImlibImage * im, int load_data)
|
|||
uint32_t *cmap;
|
||||
uint8_t *pxls, *mask, *psrc;
|
||||
ie_t *ie;
|
||||
uint32_t *pdst;
|
||||
uint32_t *imdata;
|
||||
uint32_t pixel;
|
||||
ImlibImageFrame *pf;
|
||||
|
||||
|
|
@ -361,12 +361,12 @@ _load(ImlibImage * im, int load_data)
|
|||
pxls = ie->pxls;
|
||||
mask = ie->mask;
|
||||
|
||||
pdst = im->data + (h - 1) * w; /* Start in lower left corner */
|
||||
imdata = im->data + (h - 1) * w; /* Start in lower left corner */
|
||||
|
||||
switch (ie->bih.bpp)
|
||||
{
|
||||
case 1:
|
||||
for (y = 0; y < h; y++, pdst -= 2 * w)
|
||||
for (y = 0; y < h; y++, imdata -= 2 * w)
|
||||
{
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
|
|
@ -374,13 +374,13 @@ _load(ImlibImage * im, int load_data)
|
|||
if (ico_data_get_bit(mask, w, x, y) == 0)
|
||||
pixel |= 0xff000000;
|
||||
|
||||
*pdst++ = pixel;
|
||||
*imdata++ = pixel;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 4:
|
||||
for (y = 0; y < h; y++, pdst -= 2 * w)
|
||||
for (y = 0; y < h; y++, imdata -= 2 * w)
|
||||
{
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
|
|
@ -388,13 +388,13 @@ _load(ImlibImage * im, int load_data)
|
|||
if (ico_data_get_bit(mask, w, x, y) == 0)
|
||||
pixel |= 0xff000000;
|
||||
|
||||
*pdst++ = pixel;
|
||||
*imdata++ = pixel;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 8:
|
||||
for (y = 0; y < h; y++, pdst -= 2 * w)
|
||||
for (y = 0; y < h; y++, imdata -= 2 * w)
|
||||
{
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
|
|
@ -402,13 +402,13 @@ _load(ImlibImage * im, int load_data)
|
|||
if (ico_data_get_bit(mask, w, x, y) == 0)
|
||||
pixel |= 0xff000000;
|
||||
|
||||
*pdst++ = pixel;
|
||||
*imdata++ = pixel;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
for (y = 0; y < h; y++, pdst -= 2 * w)
|
||||
for (y = 0; y < h; y++, imdata -= 2 * w)
|
||||
{
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
|
|
@ -421,7 +421,7 @@ _load(ImlibImage * im, int load_data)
|
|||
i = 0xff;
|
||||
pixel = PIXEL_ARGB(i, psrc[2], psrc[1], psrc[0]);
|
||||
|
||||
*pdst++ = pixel;
|
||||
*imdata++ = pixel;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ _load(ImlibImage * im, int load_data)
|
|||
opj_image_t *jimage;
|
||||
OPJ_CODEC_FORMAT jfmt;
|
||||
int i, j;
|
||||
uint32_t *dst;
|
||||
uint32_t *imdata;
|
||||
OPJ_INT32 *pa, *pr, *pg, *pb;
|
||||
unsigned char a, r, g, b;
|
||||
|
||||
|
|
@ -207,7 +207,7 @@ _load(ImlibImage * im, int load_data)
|
|||
|
||||
/* Ignoring color_space and data format details... */
|
||||
|
||||
dst = im->data;
|
||||
imdata = im->data;
|
||||
pa = jimage->comps[0].data; /* Avoid compiler warning */
|
||||
|
||||
switch (jimage->numcomps)
|
||||
|
|
@ -231,7 +231,7 @@ _load(ImlibImage * im, int load_data)
|
|||
b = *pb++;
|
||||
a = (jimage->numcomps == 4) ? *pa++ : 0xff;
|
||||
|
||||
*dst++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
}
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, i, 1))
|
||||
|
|
@ -251,7 +251,7 @@ _load(ImlibImage * im, int load_data)
|
|||
g = *pg++;
|
||||
a = (jimage->numcomps == 2) ? *pa++ : 0xff;
|
||||
|
||||
*dst++ = PIXEL_ARGB(a, g, g, g);
|
||||
*imdata++ = PIXEL_ARGB(a, g, g, g);
|
||||
}
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, i, 1))
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ _load(ImlibImage * im, int load_data)
|
|||
struct jpeg_decompress_struct jds;
|
||||
ImLib_JPEG_data jdata;
|
||||
uint8_t *ptr, *line[16];
|
||||
uint32_t *ptr2;
|
||||
uint32_t *imdata;
|
||||
int x, y, l, scans, inc;
|
||||
ExifInfo ei = { 0 };
|
||||
|
||||
|
|
@ -135,8 +135,8 @@ _load(ImlibImage * im, int load_data)
|
|||
QUIT_WITH_RC(LOAD_OOM);
|
||||
|
||||
/* must set the im->data member before callign progress function */
|
||||
ptr2 = __imlib_AllocateData(im);
|
||||
if (!ptr2)
|
||||
imdata = __imlib_AllocateData(im);
|
||||
if (!imdata)
|
||||
QUIT_WITH_RC(LOAD_OOM);
|
||||
|
||||
for (y = 0; y < jds.rec_outbuf_height; y++)
|
||||
|
|
@ -158,40 +158,40 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
default:
|
||||
case ORIENT_TOPLEFT:
|
||||
ptr2 = im->data + (l + y) * w;
|
||||
imdata = im->data + (l + y) * w;
|
||||
inc = 1;
|
||||
break;
|
||||
case ORIENT_TOPRIGHT:
|
||||
ptr2 = im->data + (l + y) * w + w - 1;
|
||||
imdata = im->data + (l + y) * w + w - 1;
|
||||
inc = -1;
|
||||
break;
|
||||
case ORIENT_BOTRIGHT:
|
||||
ptr2 = im->data + (h - 1 - (l + y)) * w + w - 1;
|
||||
imdata = im->data + (h - 1 - (l + y)) * w + w - 1;
|
||||
inc = -1;
|
||||
break;
|
||||
case ORIENT_BOTLEFT:
|
||||
ptr2 = im->data + (h - 1 - (l + y)) * w;
|
||||
imdata = im->data + (h - 1 - (l + y)) * w;
|
||||
inc = 1;
|
||||
break;
|
||||
case ORIENT_LEFTTOP:
|
||||
ptr2 = im->data + (l + y);
|
||||
imdata = im->data + (l + y);
|
||||
inc = h;
|
||||
break;
|
||||
case ORIENT_RIGHTTOP:
|
||||
ptr2 = im->data + (h - 1 - (l + y));
|
||||
imdata = im->data + (h - 1 - (l + y));
|
||||
inc = h;
|
||||
break;
|
||||
case ORIENT_RIGHTBOT:
|
||||
ptr2 = im->data + (h - 1 - (l + y)) + (w - 1) * h;
|
||||
imdata = im->data + (h - 1 - (l + y)) + (w - 1) * h;
|
||||
inc = -h;
|
||||
break;
|
||||
case ORIENT_LEFTBOT:
|
||||
ptr2 = im->data + (l + y) + (w - 1) * h;
|
||||
imdata = im->data + (l + y) + (w - 1) * h;
|
||||
inc = -h;
|
||||
break;
|
||||
}
|
||||
DL("l,s,y=%d,%d, %d - x,y=%4ld,%4ld\n", l, y, l + y,
|
||||
(ptr2 - im->data) % im->w, (ptr2 - im->data) / im->w);
|
||||
(imdata - im->data) % im->w, (imdata - im->data) / im->w);
|
||||
|
||||
switch (jds.out_color_space)
|
||||
{
|
||||
|
|
@ -200,27 +200,27 @@ _load(ImlibImage * im, int load_data)
|
|||
case JCS_GRAYSCALE:
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
*ptr2 = PIXEL_ARGB(0xff, ptr[0], ptr[0], ptr[0]);
|
||||
*imdata = PIXEL_ARGB(0xff, ptr[0], ptr[0], ptr[0]);
|
||||
ptr++;
|
||||
ptr2 += inc;
|
||||
imdata += inc;
|
||||
}
|
||||
break;
|
||||
case JCS_RGB:
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
*ptr2 = PIXEL_ARGB(0xff, ptr[0], ptr[1], ptr[2]);
|
||||
*imdata = PIXEL_ARGB(0xff, ptr[0], ptr[1], ptr[2]);
|
||||
ptr += jds.output_components;
|
||||
ptr2 += inc;
|
||||
imdata += inc;
|
||||
}
|
||||
break;
|
||||
case JCS_CMYK:
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
*ptr2 = PIXEL_ARGB(0xff, ptr[0] * ptr[3] / 255,
|
||||
ptr[1] * ptr[3] / 255,
|
||||
ptr[2] * ptr[3] / 255);
|
||||
*imdata = PIXEL_ARGB(0xff, ptr[0] * ptr[3] / 255,
|
||||
ptr[1] * ptr[3] / 255,
|
||||
ptr[2] * ptr[3] / 255);
|
||||
ptr += jds.output_components;
|
||||
ptr2 += inc;
|
||||
imdata += inc;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -258,7 +258,7 @@ _save(ImlibImage * im)
|
|||
ImLib_JPEG_data jdata;
|
||||
FILE *f = im->fi->fp;
|
||||
uint8_t *buf;
|
||||
uint32_t *ptr;
|
||||
const uint32_t *imdata;
|
||||
JSAMPROW *jbuf;
|
||||
int y, quality, compression;
|
||||
ImlibImageTag *tag;
|
||||
|
|
@ -321,14 +321,14 @@ _save(ImlibImage * im)
|
|||
|
||||
jpeg_start_compress(&jcs, TRUE);
|
||||
/* get the start pointer */
|
||||
ptr = im->data;
|
||||
imdata = im->data;
|
||||
/* go one scanline at a time... and save */
|
||||
for (y = 0; jcs.next_scanline < jcs.image_height; y++)
|
||||
{
|
||||
/* convcert scaline from ARGB to RGB packed */
|
||||
for (j = 0, i = 0; i < im->w; i++)
|
||||
{
|
||||
uint32_t pixel = *ptr++;
|
||||
uint32_t pixel = *imdata++;
|
||||
|
||||
buf[j++] = PIXEL_R(pixel);
|
||||
buf[j++] = PIXEL_G(pixel);
|
||||
|
|
|
|||
|
|
@ -19,16 +19,16 @@ _scanline_cb(void *opaque, size_t x, size_t y,
|
|||
{
|
||||
ImlibImage *im = opaque;
|
||||
const uint8_t *pix = pixels;
|
||||
uint32_t *ptr;
|
||||
uint32_t *imdata;
|
||||
size_t i;
|
||||
|
||||
DL("%s: x,y=%ld,%ld len=%lu\n", __func__, x, y, num_pixels);
|
||||
|
||||
ptr = im->data + (im->w * y) + x;
|
||||
imdata = im->data + (im->w * y) + x;
|
||||
|
||||
/* libjxl outputs ABGR pixels (stream order RGBA) - convert to ARGB */
|
||||
for (i = 0; i < num_pixels; i++, pix += 4)
|
||||
*ptr++ = PIXEL_ARGB(pix[3], pix[0], pix[1], pix[2]);
|
||||
*imdata++ = PIXEL_ARGB(pix[3], pix[0], pix[1], pix[2]);
|
||||
|
||||
/* Due to possible multithreading it's probably best not do do
|
||||
* progress calbacks here. */
|
||||
|
|
@ -230,7 +230,7 @@ _save(ImlibImage * im)
|
|||
.endianness = JXL_NATIVE_ENDIAN,
|
||||
};
|
||||
ImlibImageTag *tag;
|
||||
const uint32_t *ptr;
|
||||
const uint32_t *imdata;
|
||||
uint8_t *buffer = NULL, *buf_ptr;
|
||||
size_t buf_len, i, npix;
|
||||
|
||||
|
|
@ -321,25 +321,25 @@ _save(ImlibImage * im)
|
|||
QUIT_WITH_RC(LOAD_OOM);
|
||||
|
||||
// Convert format for libjxl
|
||||
ptr = im->data;
|
||||
imdata = im->data;
|
||||
buf_ptr = buffer;
|
||||
if (pbuf_fmt.num_channels == 3)
|
||||
{
|
||||
for (i = 0; i < npix; i++, ptr++, buf_ptr += 3)
|
||||
for (i = 0; i < npix; i++, imdata++, buf_ptr += 3)
|
||||
{
|
||||
buf_ptr[0] = R_VAL(ptr);
|
||||
buf_ptr[1] = G_VAL(ptr);
|
||||
buf_ptr[2] = B_VAL(ptr);
|
||||
buf_ptr[0] = R_VAL(imdata);
|
||||
buf_ptr[1] = G_VAL(imdata);
|
||||
buf_ptr[2] = B_VAL(imdata);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < npix; i++, ptr++, buf_ptr += 4)
|
||||
for (i = 0; i < npix; i++, imdata++, buf_ptr += 4)
|
||||
{
|
||||
buf_ptr[0] = R_VAL(ptr);
|
||||
buf_ptr[1] = G_VAL(ptr);
|
||||
buf_ptr[2] = B_VAL(ptr);
|
||||
buf_ptr[3] = A_VAL(ptr);
|
||||
buf_ptr[0] = R_VAL(imdata);
|
||||
buf_ptr[1] = G_VAL(imdata);
|
||||
buf_ptr[2] = B_VAL(imdata);
|
||||
buf_ptr[3] = A_VAL(imdata);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -222,7 +222,7 @@ row_callback(png_struct * png_ptr, png_byte * new_row,
|
|||
{
|
||||
ctx_t *ctx = png_get_progressive_ptr(png_ptr);
|
||||
ImlibImage *im = ctx->im;
|
||||
uint32_t *dptr;
|
||||
uint32_t *imdata;
|
||||
const uint32_t *sptr;
|
||||
int x, y, x0, dx, y0, dy;
|
||||
|
||||
|
|
@ -246,16 +246,16 @@ row_callback(png_struct * png_ptr, png_byte * new_row,
|
|||
|
||||
sptr = PCAST(const uint32_t *, new_row); /* Assuming aligned */
|
||||
|
||||
dptr = im->data + y * im->w;
|
||||
imdata = im->data + y * im->w;
|
||||
for (x = x0; x < im->w; x += dx)
|
||||
{
|
||||
#if 0
|
||||
dptr[x] = PIXEL_ARGB(new_row[ii + 3], new_row[ii + 2],
|
||||
new_row[ii + 1], new_row[ii + 0]);
|
||||
imdata[x] = PIXEL_ARGB(new_row[ii + 3], new_row[ii + 2],
|
||||
new_row[ii + 1], new_row[ii + 0]);
|
||||
D("x,y = %d,%d (i,j, ii=%d,%d %d): %08x\n", x, y,
|
||||
ii / 4, row_num, ii, dptr[x]);
|
||||
ii / 4, row_num, ii, imdata[x]);
|
||||
#else
|
||||
dptr[x] = *sptr++;
|
||||
imdata[x] = *sptr++;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -263,8 +263,8 @@ row_callback(png_struct * png_ptr, png_byte * new_row,
|
|||
{
|
||||
y = row_num;
|
||||
|
||||
dptr = im->data + y * im->w;
|
||||
memcpy(dptr, new_row, sizeof(uint32_t) * im->w);
|
||||
imdata = im->data + y * im->w;
|
||||
memcpy(imdata, new_row, sizeof(uint32_t) * im->w);
|
||||
|
||||
if (im->lc && im->frame == 0)
|
||||
{
|
||||
|
|
@ -603,7 +603,7 @@ _save(ImlibImage * im)
|
|||
png_structp png_ptr;
|
||||
png_infop info_ptr;
|
||||
misc_data_t misc;
|
||||
uint32_t *ptr;
|
||||
const uint32_t *imdata;
|
||||
int x, y, j, interlace;
|
||||
png_bytep row_ptr;
|
||||
png_color_8 sig_bit;
|
||||
|
|
@ -710,20 +710,22 @@ _save(ImlibImage * im)
|
|||
|
||||
for (pass = 0; pass < n_passes; pass++)
|
||||
{
|
||||
ptr = im->data;
|
||||
imdata = im->data;
|
||||
|
||||
if (im->lc)
|
||||
__imlib_LoadProgressSetPass(im, pass, n_passes);
|
||||
|
||||
for (y = 0; y < im->h; y++)
|
||||
for (y = 0; y < im->h; y++, imdata += im->w)
|
||||
{
|
||||
if (has_alpha)
|
||||
row_ptr = (png_bytep) ptr;
|
||||
{
|
||||
row_ptr = (png_bytep) imdata;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (j = 0, x = 0; x < im->w; x++)
|
||||
{
|
||||
uint32_t pixel = ptr[x];
|
||||
uint32_t pixel = imdata[x];
|
||||
|
||||
misc.data[j++] = PIXEL_R(pixel);
|
||||
misc.data[j++] = PIXEL_G(pixel);
|
||||
|
|
@ -735,8 +737,6 @@ _save(ImlibImage * im)
|
|||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, y, 1))
|
||||
QUIT_WITH_RC(LOAD_BREAK);
|
||||
|
||||
ptr += im->w;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -617,7 +617,7 @@ _save(ImlibImage * im)
|
|||
int rc;
|
||||
FILE *f = im->fi->fp;
|
||||
uint8_t *buf, *bptr;
|
||||
uint32_t *ptr;
|
||||
const uint32_t *imdata;
|
||||
int x, y;
|
||||
|
||||
rc = LOAD_FAIL;
|
||||
|
|
@ -627,7 +627,7 @@ _save(ImlibImage * im)
|
|||
if (!buf)
|
||||
goto quit;
|
||||
|
||||
ptr = im->data;
|
||||
imdata = im->data;
|
||||
|
||||
/* if the image has a useful alpha channel */
|
||||
if (im->has_alpha)
|
||||
|
|
@ -638,7 +638,7 @@ _save(ImlibImage * im)
|
|||
bptr = buf;
|
||||
for (x = 0; x < im->w; x++)
|
||||
{
|
||||
uint32_t pixel = *ptr++;
|
||||
uint32_t pixel = *imdata++;
|
||||
|
||||
bptr[0] = PIXEL_R(pixel);
|
||||
bptr[1] = PIXEL_G(pixel);
|
||||
|
|
@ -660,7 +660,7 @@ _save(ImlibImage * im)
|
|||
bptr = buf;
|
||||
for (x = 0; x < im->w; x++)
|
||||
{
|
||||
uint32_t pixel = *ptr++;
|
||||
uint32_t pixel = *imdata++;
|
||||
|
||||
bptr[0] = PIXEL_R(pixel);
|
||||
bptr[1] = PIXEL_G(pixel);
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ _load(ImlibImage * im, int load_data)
|
|||
unsigned char *pdata;
|
||||
int rowlen;
|
||||
unsigned char *src;
|
||||
uint32_t *dst;
|
||||
uint32_t *imdata;
|
||||
int i, j;
|
||||
ImlibImageFrame *pf;
|
||||
|
||||
|
|
@ -114,7 +114,7 @@ _load(ImlibImage * im, int load_data)
|
|||
}
|
||||
|
||||
src = pdata;
|
||||
dst = im->data;
|
||||
imdata = im->data;
|
||||
|
||||
D("rowlen=%d (%d)\n", rowlen, 4 * im->w);
|
||||
|
||||
|
|
@ -122,7 +122,7 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
src = pdata + i * rowlen;
|
||||
for (j = 0; j < im->w; j++, src += 4)
|
||||
*dst++ = PIXEL_ARGB(0xff, src[2], src[1], src[0]);
|
||||
*imdata++ = PIXEL_ARGB(0xff, src[2], src[1], src[0]);
|
||||
|
||||
if (im->lc && __imlib_LoadProgressRows(im, i, 1))
|
||||
QUIT_WITH_RC(LOAD_BREAK);
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ _load(ImlibImage * im, int load_data)
|
|||
int rle, bpp, hasa, hasc, fliph, flipv;
|
||||
unsigned long datasize;
|
||||
const unsigned char *bufptr, *bufend, *palette;
|
||||
uint32_t *dataptr;
|
||||
uint32_t *imdata;
|
||||
int palcnt = 0, palbpp = 0;
|
||||
unsigned char a, r, g, b;
|
||||
unsigned int pix16;
|
||||
|
|
@ -225,8 +225,8 @@ _load(ImlibImage * im, int load_data)
|
|||
if (!__imlib_AllocateData(im))
|
||||
QUIT_WITH_RC(LOAD_OOM);
|
||||
|
||||
/* dataptr is the next 32-bit pixel to be filled in */
|
||||
dataptr = im->data;
|
||||
/* imdata is the next 32-bit pixel to be filled in */
|
||||
imdata = im->data;
|
||||
|
||||
if (!rle)
|
||||
{
|
||||
|
|
@ -235,12 +235,12 @@ _load(ImlibImage * im, int load_data)
|
|||
/* decode uncompressed BGRA data */
|
||||
for (y = 0; y < im->h; y++) /* for each row */
|
||||
{
|
||||
/* point dataptr at the beginning of the row */
|
||||
/* point imdata at the beginning of the row */
|
||||
if (flipv)
|
||||
/* some TGA's are stored upside-down! */
|
||||
dataptr = im->data + ((im->h - y - 1) * im->w);
|
||||
imdata = im->data + ((im->h - y - 1) * im->w);
|
||||
else
|
||||
dataptr = im->data + (y * im->w);
|
||||
imdata = im->data + (y * im->w);
|
||||
|
||||
for (x = 0; (x < im->w); x++) /* for each pixel in the row */
|
||||
{
|
||||
|
|
@ -254,7 +254,7 @@ _load(ImlibImage * im, int load_data)
|
|||
g = *bufptr++;
|
||||
r = *bufptr++;
|
||||
a = *bufptr++;
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 24: /* 24-bit BGR pixels */
|
||||
|
|
@ -262,7 +262,7 @@ _load(ImlibImage * im, int load_data)
|
|||
g = *bufptr++;
|
||||
r = *bufptr++;
|
||||
a = 0xff;
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 16:
|
||||
|
|
@ -280,7 +280,7 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
r = g = b;
|
||||
}
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 8: /* 8-bit grayscale or palette */
|
||||
|
|
@ -298,7 +298,7 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
r = g = b;
|
||||
}
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -311,10 +311,10 @@ _load(ImlibImage * im, int load_data)
|
|||
else
|
||||
{
|
||||
/* decode RLE compressed data */
|
||||
uint32_t *final_pixel = dataptr + im->w * im->h;
|
||||
uint32_t *final_pixel = imdata + im->w * im->h;
|
||||
|
||||
/* loop until we've got all the pixels or run out of input */
|
||||
while ((dataptr < final_pixel))
|
||||
while ((imdata < final_pixel))
|
||||
{
|
||||
int i, count;
|
||||
unsigned char curbyte;
|
||||
|
|
@ -334,8 +334,8 @@ _load(ImlibImage * im, int load_data)
|
|||
g = *bufptr++;
|
||||
r = *bufptr++;
|
||||
a = *bufptr++;
|
||||
for (i = 0; (i < count) && (dataptr < final_pixel); i++)
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
for (i = 0; (i < count) && (imdata < final_pixel); i++)
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 24:
|
||||
|
|
@ -343,8 +343,8 @@ _load(ImlibImage * im, int load_data)
|
|||
g = *bufptr++;
|
||||
r = *bufptr++;
|
||||
a = 0xff;
|
||||
for (i = 0; (i < count) && (dataptr < final_pixel); i++)
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
for (i = 0; (i < count) && (imdata < final_pixel); i++)
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 16:
|
||||
|
|
@ -362,8 +362,8 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
r = g = b;
|
||||
}
|
||||
for (i = 0; (i < count) && (dataptr < final_pixel); i++)
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
for (i = 0; (i < count) && (imdata < final_pixel); i++)
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 8:
|
||||
|
|
@ -381,14 +381,14 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
r = g = b;
|
||||
}
|
||||
for (i = 0; (i < count) && (dataptr < final_pixel); i++)
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
for (i = 0; (i < count) && (imdata < final_pixel); i++)
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
}
|
||||
} /* end if (RLE packet) */
|
||||
else /* raw packet */
|
||||
{
|
||||
for (i = 0; (i < count) && (dataptr < final_pixel); i++)
|
||||
for (i = 0; (i < count) && (imdata < final_pixel); i++)
|
||||
{
|
||||
if ((bufptr + bpp / 8) > bufend)
|
||||
goto quit;
|
||||
|
|
@ -400,7 +400,7 @@ _load(ImlibImage * im, int load_data)
|
|||
g = *bufptr++;
|
||||
r = *bufptr++;
|
||||
a = *bufptr++;
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 24: /* 24-bit BGR pixels */
|
||||
|
|
@ -408,7 +408,7 @@ _load(ImlibImage * im, int load_data)
|
|||
g = *bufptr++;
|
||||
r = *bufptr++;
|
||||
a = 0xff;
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 16:
|
||||
|
|
@ -426,7 +426,7 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
r = g = b;
|
||||
}
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
|
||||
case 8: /* 8-bit grayscale or palette */
|
||||
|
|
@ -444,7 +444,7 @@ _load(ImlibImage * im, int load_data)
|
|||
{
|
||||
r = g = b;
|
||||
}
|
||||
*dataptr++ = PIXEL_ARGB(a, r, g, b);
|
||||
*imdata++ = PIXEL_ARGB(a, r, g, b);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -499,7 +499,7 @@ _save(ImlibImage * im)
|
|||
{
|
||||
int rc;
|
||||
FILE *f = im->fi->fp;
|
||||
uint32_t *dataptr;
|
||||
const uint32_t *imdata;
|
||||
unsigned char *buf, *bufptr;
|
||||
int y;
|
||||
tga_header header;
|
||||
|
|
@ -538,7 +538,7 @@ _save(ImlibImage * im)
|
|||
goto quit;
|
||||
|
||||
/* now we have to read from im->data into buf, swapping RGBA to BGRA */
|
||||
dataptr = im->data;
|
||||
imdata = im->data;
|
||||
bufptr = buf;
|
||||
|
||||
/* for each row */
|
||||
|
|
@ -549,7 +549,7 @@ _save(ImlibImage * im)
|
|||
/* for each pixel in the row */
|
||||
for (x = 0; x < im->w; x++)
|
||||
{
|
||||
uint32_t pixel = *dataptr++;
|
||||
uint32_t pixel = *imdata++;
|
||||
|
||||
*bufptr++ = PIXEL_B(pixel);
|
||||
*bufptr++ = PIXEL_G(pixel);
|
||||
|
|
|
|||
|
|
@ -457,7 +457,8 @@ _save(ImlibImage * im)
|
|||
int rc;
|
||||
TIFF *tif = NULL;
|
||||
uint8_t *buf = NULL;
|
||||
uint32_t pixel, *data = im->data;
|
||||
const uint32_t *imdata;
|
||||
uint32_t pixel;
|
||||
double alpha_factor;
|
||||
int x, y;
|
||||
uint8_t r, g, b, a = 0;
|
||||
|
|
@ -541,12 +542,13 @@ _save(ImlibImage * im)
|
|||
if (!buf)
|
||||
goto quit;
|
||||
|
||||
imdata = im->data;
|
||||
for (y = 0; y < im->h; y++)
|
||||
{
|
||||
i = 0;
|
||||
for (x = 0; x < im->w; x++)
|
||||
{
|
||||
pixel = data[(y * im->w) + x];
|
||||
pixel = imdata[(y * im->w) + x];
|
||||
|
||||
r = PIXEL_R(pixel);
|
||||
g = PIXEL_G(pixel);
|
||||
|
|
|
|||
|
|
@ -216,7 +216,7 @@ _save(ImlibImage * im)
|
|||
const char *s, *name;
|
||||
char *bname;
|
||||
int i, k, x, y, bits, nval, val;
|
||||
uint32_t *ptr;
|
||||
const uint32_t *imdata;
|
||||
|
||||
rc = LOAD_SUCCESS;
|
||||
|
||||
|
|
@ -233,14 +233,14 @@ _save(ImlibImage * im)
|
|||
free(bname);
|
||||
|
||||
nval = ((im->w + 7) / 8) * im->h;
|
||||
ptr = im->data;
|
||||
imdata = im->data;
|
||||
x = k = 0;
|
||||
for (y = 0; y < im->h;)
|
||||
{
|
||||
bits = 0;
|
||||
for (i = 0; i < 8 && x < im->w; i++, x++)
|
||||
{
|
||||
val = _bitmap_dither(x, y, *ptr++);
|
||||
val = _bitmap_dither(x, y, *imdata++);
|
||||
if (val)
|
||||
bits |= 1 << i;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue