This is an automated email from the git hooks/post-receive script.

git pushed a commit to branch master
in repository legacy-imlib2.

View the commit online.

commit 41c792bd7e88702597a63dabd34db3717e414208
Author: Kim Woelders <k...@woelders.dk>
AuthorDate: Fri Apr 28 12:55:39 2023 +0200

    loaders: Cosmetics
    
    - Add missing const
    - Consistently use imdata for pointer into imlib image data
    - Minor changes
---
 src/modules/loaders/loader_argb.c | 23 ++++++++--------
 src/modules/loaders/loader_bmp.c  | 48 ++++++++++++++++-----------------
 src/modules/loaders/loader_ff.c   | 28 ++++++++++----------
 src/modules/loaders/loader_ico.c  | 20 +++++++-------
 src/modules/loaders/loader_j2k.c  |  8 +++---
 src/modules/loaders/loader_jpeg.c | 46 ++++++++++++++++----------------
 src/modules/loaders/loader_jxl.c  | 28 ++++++++++----------
 src/modules/loaders/loader_png.c  | 30 ++++++++++-----------
 src/modules/loaders/loader_pnm.c  |  8 +++---
 src/modules/loaders/loader_ps.c   |  6 ++---
 src/modules/loaders/loader_tga.c  | 56 +++++++++++++++++++--------------------
 src/modules/loaders/loader_tiff.c |  6 +++--
 src/modules/loaders/loader_xbm.c  |  6 ++---
 13 files changed, 157 insertions(+), 156 deletions(-)

diff --git a/src/modules/loaders/loader_argb.c b/src/modules/loaders/loader_argb.c
index ca97799..e822b28 100644
--- a/src/modules/loaders/loader_argb.c
+++ b/src/modules/loaders/loader_argb.c
@@ -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);
diff --git a/src/modules/loaders/loader_bmp.c b/src/modules/loaders/loader_bmp.c
index 95d25b1..ed4cbe2 100644
--- a/src/modules/loaders/loader_bmp.c
+++ b/src/modules/loaders/loader_bmp.c
@@ -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))
diff --git a/src/modules/loaders/loader_ff.c b/src/modules/loaders/loader_ff.c
index 1d62266..a3ac260 100644
--- a/src/modules/loaders/loader_ff.c
+++ b/src/modules/loaders/loader_ff.c
@@ -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;
diff --git a/src/modules/loaders/loader_ico.c b/src/modules/loaders/loader_ico.c
index 7301e49..eed1881 100644
--- a/src/modules/loaders/loader_ico.c
+++ b/src/modules/loaders/loader_ico.c
@@ -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;
diff --git a/src/modules/loaders/loader_j2k.c b/src/modules/loaders/loader_j2k.c
index a84a65e..65958f7 100644
--- a/src/modules/loaders/loader_j2k.c
+++ b/src/modules/loaders/loader_j2k.c
@@ -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))
diff --git a/src/modules/loaders/loader_jpeg.c b/src/modules/loaders/loader_jpeg.c
index 436ccfd..42015a4 100644
--- a/src/modules/loaders/loader_jpeg.c
+++ b/src/modules/loaders/loader_jpeg.c
@@ -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);
diff --git a/src/modules/loaders/loader_jxl.c b/src/modules/loaders/loader_jxl.c
index c9037c1..8541b14 100644
--- a/src/modules/loaders/loader_jxl.c
+++ b/src/modules/loaders/loader_jxl.c
@@ -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);
           }
      }
 
diff --git a/src/modules/loaders/loader_png.c b/src/modules/loaders/loader_png.c
index 6dc743f..b8ad084 100644
--- a/src/modules/loaders/loader_png.c
+++ b/src/modules/loaders/loader_png.c
@@ -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;
           }
      }
 
diff --git a/src/modules/loaders/loader_pnm.c b/src/modules/loaders/loader_pnm.c
index 32ca492..b194d69 100644
--- a/src/modules/loaders/loader_pnm.c
+++ b/src/modules/loaders/loader_pnm.c
@@ -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);
diff --git a/src/modules/loaders/loader_ps.c b/src/modules/loaders/loader_ps.c
index b6deb8d..6fdf818 100644
--- a/src/modules/loaders/loader_ps.c
+++ b/src/modules/loaders/loader_ps.c
@@ -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 = ""
-   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 = "" + 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);
diff --git a/src/modules/loaders/loader_tga.c b/src/modules/loaders/loader_tga.c
index 3c95f39..083f455 100644
--- a/src/modules/loaders/loader_tga.c
+++ b/src/modules/loaders/loader_tga.c
@@ -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);
diff --git a/src/modules/loaders/loader_tiff.c b/src/modules/loaders/loader_tiff.c
index 1770249..e3ccc72 100644
--- a/src/modules/loaders/loader_tiff.c
+++ b/src/modules/loaders/loader_tiff.c
@@ -457,7 +457,8 @@ _save(ImlibImage * im)
    int                 rc;
    TIFF               *tif = NULL;
    uint8_t            *buf = NULL;
-   uint32_t            pixel, *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);
diff --git a/src/modules/loaders/loader_xbm.c b/src/modules/loaders/loader_xbm.c
index 0b7abbc..97dbe41 100644
--- a/src/modules/loaders/loader_xbm.c
+++ b/src/modules/loaders/loader_xbm.c
@@ -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;
           }

-- 
To stop receiving notification emails like this one, please contact
the administrator of this repository.

Reply via email to