Enlightenment CVS committal

Author  : jbickers
Project : e17
Module  : libs/imlib2

Dir     : e17/libs/imlib2/loaders


Modified Files:
        loader_lbm.c 


Log Message:
Fixed start-of-line HAM problem.
Added SHAM and CTBL load.
Added greyscale load.
Added IMLIB2_LBM_NOMASK check to disable masking.
Added colour gun scaling, e.g. 4-bit 0x0f scales to 8-bit 0xff, not 0xf0.
Changed RLE decompression by scanline instead of by byte.
Removed empty save() function altogether as per some other loaders.

===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/imlib2/loaders/loader_lbm.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -3 -r1.1 -r1.2
--- loader_lbm.c        26 Aug 2004 17:26:10 -0000      1.1
+++ loader_lbm.c        28 Aug 2004 20:59:59 -0000      1.2
@@ -1,9 +1,14 @@
 /*------------------------------------------------------------------------------
- * Reads regular Amiga IFF ILBM files. Does not handle sliced HAM, etc.
+ * Reads regular Amiga IFF ILBM files.
+ *
+ * Supports IMLIB2_LBM_NOMASK environment variable. If this is set to "1", then
+ * a transparency mask in an image will be ignored. On the Amiga a mask is often
+ * applied only when loading a brush rather than a picture, but this loader has
+ * no way to tell when the user wants this behaviour from the picture alone.
  *
  * Author:  John Bickers <[EMAIL PROTECTED]>
  * Since:   2004-08-21
- * Version: 2004-08-23
+ * Version: 2004-08-28
  *------------------------------------------------------------------------------*/
 
 #ifdef HAVE_CONFIG_H
@@ -13,453 +18,444 @@
 #include "common.h"
 #include "image.h"
 
-char                load(ImlibImage * im, ImlibProgressFunction progress,
-                         char progress_granularity, char immediate_load);
-char                save(ImlibImage * im, ImlibProgressFunction progress,
-                         char progress_granularity);
-void                formats(ImlibLoader * l);
+char    load(ImlibImage *im, ImlibProgressFunction progress, char 
progress_granularity, char immediate_load);
+#if 0
+char    save(ImlibImage *im, ImlibProgressFunction progress, char 
progress_granularity);
+#endif
+void    formats(ImlibLoader *l);
+
 
 #define L2RLONG(a) ((((long)((a)[0]) & 0xff) << 24) + (((long)((a)[1]) & 0xff) << 16) 
+ (((long)((a)[2]) & 0xff) << 8) + ((long)((a)[3]) & 0xff))
 #define L2RWORD(a) ((((long)((a)[0]) & 0xff) << 8) + ((long)((a)[1]) & 0xff))
 
 typedef struct CHUNK {
-   long                size;
-   unsigned char      *data;
+    long    size;
+    unsigned char *data;
 } CHUNK;
 
-typedef struct BODY {
-   long                size;
-   unsigned char      *data;
-   int                 offset;
-   int                 count;
-   int                 rle;
-   int                 rletype;
-} BODY;
-
-static int          loadchunks(char *name, CHUNK * bmhd, CHUNK * camg,
-                               CHUNK * cmap, BODY * body);
-static unsigned char bodybyte(BODY *);
-static void         deplane(DATA32 * row, int w, CHUNK * bmhd, CHUNK * cmap,
-                            unsigned char *plane[], int depth, int mask,
-                            int ham, int hbrite);
+typedef struct ILBM {
+    CHUNK   bmhd;
+    CHUNK   camg;
+    CHUNK   cmap;
+    CHUNK   ctbl;
+    CHUNK   sham;
+    CHUNK   body;
+
+    int     depth;
+    int     mask;
+    int     ham;
+    int     hbrite;
+
+    int     row;
+
+    int     offset;
+    int     count;
+    int     rle;
+} ILBM;
+
+static void freeilbm(ILBM *);
+static int loadchunks(char *, ILBM *, int);
+static void bodyrow(unsigned char *, int, ILBM *);
+static unsigned char scalegun(unsigned char, int);
+static void scalecmap(ILBM *);
+static void deplane(DATA32 *, int, ILBM *, unsigned char **);
+
 
 /*------------------------------------------------------------------------------
- * Reads the given chunks out of a file, returns 0 if the file had a problem.
- *
- * Format FORMsizeILBMBMHDsize....CAMGsize....CMAPsize....BODYsize....
+ * Frees memory allocated as part of an ILBM structure.
  *------------------------------------------------------------------------------*/
-static int
-loadchunks(char *name, CHUNK * bmhd, CHUNK * camg, CHUNK * cmap, BODY * body)
+static void freeilbm(ILBM *ilbm)
 {
-   FILE               *f;
-   size_t              s;
-   long                formsize, pos, z;
-   int                 ok, seek;
-   char                buf[12];
-
-   if (bmhd)
-     {
-        bmhd->size = 0;
-        bmhd->data = NULL;
-     }
-   if (camg)
-     {
-        camg->size = 0;
-        camg->data = NULL;
-     }
-   if (cmap)
-     {
-        cmap->size = 0;
-        cmap->data = NULL;
-     }
-   if (body)
-     {
-        body->size = 0;
-        body->data = NULL;
-     }
-
-   ok = 0;
-
-   f = fopen(name, "rb");
-   if (f)
-     {
-        s = fread(buf, 1, 12, f);
-        if (s == 12 && !memcmp(buf, "FORM", 4) && !memcmp(buf + 8, "ILBM", 4))
-          {
-             formsize = L2RLONG(buf + 4);
-
-             while (1)
-               {
-                  pos = ftell(f);
-                  if (pos < 0 || pos >= formsize + 8)
-                     break;     /* Error or FORM data is finished. */
-                  seek = 1;
-
-                  s = fread(buf, 1, 8, f);
-                  if (s != 8)
-                     break;     /* Error or short file. */
-
-                  z = L2RLONG(buf + 4);
-                  if (z < 0)
-                     break;     /* Corrupt file. */
-
-                  if (!memcmp(buf, "BMHD", 4) && bmhd && !bmhd->data)
-                    {
-                       bmhd->size = z;
-                       bmhd->data = malloc(bmhd->size);
-                       if (!bmhd->data)
-                          break;
-
-                       s = fread(bmhd->data, 1, bmhd->size, f);
-                       if (s != bmhd->size)
-                          break;        /* Error or short file. */
-
-                       if (!cmap && !camg && !body)
-                         {
-                            ok = 1;
-                            break;
-                         }
+    if (ilbm->bmhd.data) free(ilbm->bmhd.data);
+    if (ilbm->camg.data) free(ilbm->camg.data);
+    if (ilbm->cmap.data) free(ilbm->cmap.data);
+    if (ilbm->ctbl.data) free(ilbm->ctbl.data);
+    if (ilbm->sham.data) free(ilbm->sham.data);
+    if (ilbm->body.data) free(ilbm->body.data);
 
-                       seek = 0;
-                    }
+    memset(ilbm, 0, sizeof(*ilbm));
+}
 
-                  if (!memcmp(buf, "CAMG", 4) && camg && !camg->data)
-                    {
-                       camg->size = z;
-                       camg->data = malloc(camg->size);
-                       if (!camg->data)
-                          break;
-
-                       s = fread(camg->data, 1, camg->size, f);
-                       if (s != camg->size)
-                          break;
 
-                       seek = 0;
-                    }
+/*------------------------------------------------------------------------------
+ * Reads the given chunks out of a file, returns 0 if the file had a problem.
+ *
+ * Format FORMsizeILBMtag.size....tag.size....tag.size....
+ *------------------------------------------------------------------------------*/
+static int loadchunks(char *name, ILBM *ilbm, int full)
+{
+CHUNK   *c;
+FILE    *f;
+size_t  s;
+long    formsize, pos, z;
+int     ok, seek;
+char    buf[12];
 
-                  if (!memcmp(buf, "CMAP", 4) && cmap && !cmap->data)
-                    {
-                       cmap->size = z;
-                       cmap->data = malloc(cmap->size);
-                       if (!cmap->data)
-                          break;
-
-                       s = fread(cmap->data, 1, cmap->size, f);
-                       if (s != cmap->size)
-                          break;
+    ok = 0;
 
-                       seek = 0;
+    f = fopen(name, "rb");
+    if (f) {
+        s = fread(buf, 1, 12, f);
+        if (s == 12 && !memcmp(buf, "FORM", 4) && !memcmp(buf + 8, "ILBM", 4)) {
+            memset(ilbm, 0, sizeof(*ilbm));
+            formsize = L2RLONG(buf + 4);
+
+            while (1) {
+                pos = ftell(f);
+                if (pos < 0 || pos >= formsize + 8) break;  /* Error or FORM data is 
finished. */
+                seek = 1;
+
+                s = fread(buf, 1, 8, f);
+                if (s != 8) break;                          /* Error or short file. */
+
+                z = L2RLONG(buf + 4);
+                if (z < 0) break;                           /* Corrupt file. */
+
+                c = NULL;
+                if (!memcmp(buf, "BMHD", 4)) c = &(ilbm->bmhd);
+                else if (full) {
+                    if (!memcmp(buf, "CAMG", 4)) c = &(ilbm->camg);
+                    else if (!memcmp(buf, "CMAP", 4)) c = &(ilbm->cmap);
+                    else if (!memcmp(buf, "CTBL", 4)) c = &(ilbm->ctbl);
+                    else if (!memcmp(buf, "SHAM", 4)) c = &(ilbm->sham);
+                    else if (!memcmp(buf, "BODY", 4)) c = &(ilbm->body);
+                }
+
+                if (c && !c->data) {
+                    c->size = z;
+                    c->data = malloc(c->size);
+                    if (!c->data) break;                    /* Out of memory. */
+
+                    s = fread(c->data, 1, c->size, f);
+                    if (s != c->size) break;                /* Error or short file. */
+
+                    seek = 0;
+                    if (!full) {                            /* Only BMHD required. */
+                        ok = 1;
+                        break;
                     }
+                }
 
-                  if (!memcmp(buf, "BODY", 4) && body && !body->data)
-                    {
-                       body->size = z;
-                       body->data = malloc(body->size);
-                       if (!body->data)
-                          break;
-
-                       s = fread(body->data, 1, body->size, f);
-                       if (s != body->size)
-                          break;
-
-                       if (bmhd && bmhd->data)
-                         {      /* BMHD must be before BODY. */
-                            ok = 1;
-                            break;
-                         }
-
-                       seek = 0;
-                    }
+                if (pos + 8 + z >= formsize + 8) break;     /* This was last chunk. */
 
-                  if (pos + 8 + z >= formsize + 8)
-                     break;     /* This was last chunk. */
+                if (seek && fseek(f, z, SEEK_CUR) != 0) break;
+            }
 
-                  if (seek && fseek(f, z, SEEK_CUR) != 0)
-                     break;
-               }
-          }
+          /* File may end strangely, especially if body size is uneven, but it's
+           * ok if we have the chunks we want. !full check is already done. */
+            if (ilbm->bmhd.data && ilbm->body.data) ok = 1;
+            if (!ok) freeilbm(ilbm);
+        }
         fclose(f);
-     }
+    }
 
-   if (!ok)
-     {
-        if (bmhd && bmhd->data)
-           free(bmhd->data);
-        if (camg && camg->data)
-           free(camg->data);
-        if (cmap && cmap->data)
-           free(cmap->data);
-        if (body && body->data)
-           free(body->data);
-     }
-
-   return ok;
+    return ok;
 }
 
+
 /*------------------------------------------------------------------------------
- * Returns a byte of data from a BODY chunk.
+ * Unpacks a row of possibly RLE data at a time.
  *
  * RLE compression depends on a count byte, followed by data bytes.
  *
  * 0x80 means skip.
  * 0xff to 0x81 means repeat one data byte (256 - count) + 1 times.
  * 0x00 to 0x7f means copy count + 1 data bytes.
+ *
+ * In theory RLE compression is not supposed to create runs across scanlines.
  *------------------------------------------------------------------------------*/
-static unsigned char
-bodybyte(BODY * body)
+static void bodyrow(unsigned char *p, int z, ILBM *ilbm)
 {
-   unsigned char       b;
+int     i, x, w;
+unsigned char b;
 
-   if (body->offset >= body->size)
-      return 0;
+    if (ilbm->offset >= ilbm->body.size) {
+        memset(p, 0, z);
+        return;
+    }
+
+    if (!ilbm->rle) {
+        w = ilbm->body.size - ilbm->offset;
+        if (w > z) w = z;
+        memcpy(p, ilbm->body.data + ilbm->offset, w);
+        if (w < z) memset(p + w, 0, z - w);
+        ilbm->offset += w;
+        return;
+    }
+
+    for (i = 0; i < z; ) {
+        b = ilbm->body.data[ilbm->offset++];
+        while (b == 0x80 && ilbm->offset < ilbm->body.size) b = 
ilbm->body.data[ilbm->offset++];
+        if (ilbm->offset >= ilbm->body.size) break;
+
+        if (b & 0x80) {
+            w = (0x100 - b) + 1;
+            if (w > z - i) w = z - i;
+            
+            b = ilbm->body.data[ilbm->offset++];
+            memset(p + i, b, w);
+            i += w;
+        }
+        else {
+            w = (b & 0x7f) + 1;
+            if (w > ilbm->body.size - ilbm->offset) w = ilbm->body.size - 
ilbm->offset; 
+            x = (w <= z - i)? w: z - i;
+            memcpy(p + i, ilbm->body.data + ilbm->offset, x);
+            i += x;
+            ilbm->offset += w;
+        }
+    }
+    
+    if (i < z) memset(p, 0, z - i);
+}
 
-   if (body->rle)
-     {
-        if (body->count == 0)
-          {
-             b = body->data[body->offset++];
-             while (b == 0x80 && body->offset < body->size)
-                b = body->data[body->offset++];
-
-             body->rletype = (b & 0x80);
-             if (body->rletype)
-                body->count = (0x100 - b) + 1;
-             else
-                body->count = (b & 0x7f) + 1;
-
-             if (body->offset >= body->size)
-                return 0;
-          }
-
-        body->count--;
-        if (body->rletype)
-          {
-             if (body->count == 0)
-                return body->data[body->offset++];
-             return body->data[body->offset];
-          }
 
-        return body->data[body->offset++];
-     }
+/*------------------------------------------------------------------------------
+ * Shifts a value to produce an 8-bit colour gun, and fills in the lower bits
+ * from the high bits of the value so that, for example, 4-bit 0x0f scales to
+ * 0xff, or 1-bit 0x01 scales to 0xff.
+ *------------------------------------------------------------------------------*/
+static unsigned char scalegun(unsigned char v, int sl)
+{
+int     sr;
+
+    switch (sl) {
+        case 1:
+        case 2:
+        case 3:
+            sr = 8 - sl;
+            return (v << sl) | (v >> sr);
+
+        case 4:
+            return (v << 4) | v;
+
+        case 5:
+            return v * 0x24;
+
+        case 6:
+            return v * 0x55;
+
+        case 7:
+            return v * 0xff;
+    }
+    return v;
+}
+
+
+/*------------------------------------------------------------------------------
+ * Scales the colours in a CMAP chunk if they all look like 4-bit colour, so
+ * that they use all 8-bits. This is done by copying the high nybble into the
+ * low nybble, so for example 0xf0 becomes 0xff.
+ *------------------------------------------------------------------------------*/
+static void scalecmap(ILBM *ilbm)
+{
+int     i;
+
+    if (!ilbm->cmap.data) return;
+
+    for (i = 0; i < ilbm->cmap.size; i++)
+        if (ilbm->cmap.data[i] & 0x0f) return;
 
-   return body->data[body->offset++];
+    for (i = 0; i < ilbm->cmap.size; i++)
+        ilbm->cmap.data[i] |= ilbm->cmap.data[i] >> 4;
 }
 
+
 /*------------------------------------------------------------------------------
  * Deplanes and converts an array of bitplanes to a single scanline of DATA32
  * (unsigned int) values. DATA32 is ARGB.
  *------------------------------------------------------------------------------*/
-static void
-deplane(DATA32 * row, int w, CHUNK * bmhd, CHUNK * cmap, unsigned char *plane[],
-        int depth, int mask, int ham, int hbrite)
+static void deplane(DATA32 *row, int w, ILBM *ilbm, unsigned char *plane[])
 {
-   unsigned long       l;
-   int                 i, o, x;
-   unsigned char       bit, r, g, b, a, v, h;
-
-   bit = 0x80;
-   o = 0;
-   for (x = 0; x < w; x++)
-     {
+unsigned long l;
+int     i, o, sl, x;
+unsigned char bit, r, g, b, a, v, h, *pal;
+
+    pal = NULL;
+    if (ilbm->sham.data && ilbm->sham.size >= 2 + (ilbm->row + 1) * 2 * 16)
+        pal = ilbm->sham.data + 2 + ilbm->row * 2 * 16;
+    if (ilbm->ctbl.data && ilbm->ctbl.size >= (ilbm->row + 1) * 2 * 16)
+        pal = ilbm->ctbl.data + ilbm->row * 2 * 16;
+
+    if (ilbm->ham) r = g = b = 0;
+
+    bit = 0x80;
+    o = 0;
+    for (x = 0; x < w; x++) {
         l = 0;
-        for (i = depth - 1; i >= 0; i--)
-          {
-             l = l << 1;
-             if (plane[i][o] & bit)
-                l = l | 1;
-          }
-        a = (mask == 0 || (mask == 1 && (plane[depth][o] & bit))
-             || mask == 2) ? 0xff : 0x00;
-
-        if (depth == 32)
-          {
-             a = (l >> 24) & 0xff;
-             b = (l >> 16) & 0xff;
-             g = (l >> 8) & 0xff;
-             r = l & 0xff;
-          }
-        else if (depth == 24)
-          {
-             b = (l >> 16) & 0xff;
-             g = (l >> 8) & 0xff;
-             r = l & 0xff;
-          }
-        else if (ham)
-          {
-             v = l & ((1 << (depth - 2)) - 1);
-             h = (l & ~v) >> (depth - 2);
-
-             if (x == 0 || h == 0x00)
-               {
-                  r = cmap->data[v * 3];
-                  g = cmap->data[v * 3 + 1];
-                  b = cmap->data[v * 3 + 2];
-               }
-             else if (h == 0x01)
-               {
-                  b = v << (8 - (depth - 2));
-               }
-             else if (h == 0x02)
-               {
-                  r = v << (8 - (depth - 2));
-               }
-             else if (h == 0x03)
-               {
-                  g = v << (8 - (depth - 2));
-               }
-          }
-        else if (hbrite)
-          {
-             v = l & ((1 << (depth - 1)) - 1);
-             h = (l & ~v) >> (depth - 1);
-
-             r = cmap->data[v * 3];
-             g = cmap->data[v * 3 + 1];
-             b = cmap->data[v * 3 + 2];
-
-             if (h)
-               {
-                  r = r >> 1;
-                  g = g >> 1;
-                  b = b >> 1;
-               }
-
-             if (mask == 2 && v == L2RWORD(bmhd->data + 12))
-                a = 0x00;
-          }
-        else
-          {
-             v = l & 0xff;
-             if ((v + 1) * 3 <= cmap->size)
-               {
-                  r = cmap->data[v * 3];
-                  g = cmap->data[v * 3 + 1];
-                  b = cmap->data[v * 3 + 2];
-               }
-             else
-                r = g = b = 0;
-
-             if (mask == 2 && v == L2RWORD(bmhd->data + 12))
-                a = 0x00;
-          }
-
-        row[x] =
-            ((unsigned long)a << 24) | ((unsigned long)r << 16) |
-            ((unsigned long)g << 8) | (unsigned long)b;
+        for (i = ilbm->depth - 1; i >= 0; i--) {
+            l = l << 1;
+            if (plane[i][o] & bit) l = l | 1;
+        }
+        a = (ilbm->mask == 0 || (ilbm->mask == 1 && (plane[ilbm->depth][o] & bit)) || 
ilbm->mask == 2)? 0xff: 0x00;
+
+        if (ilbm->depth == 32) {
+            a = (l >> 24) & 0xff;
+            b = (l >> 16) & 0xff;
+            g = (l >> 8) & 0xff;
+            r = l & 0xff;
+        }
+        else if (ilbm->depth == 24) {
+            b = (l >> 16) & 0xff;
+            g = (l >> 8) & 0xff;
+            r = l & 0xff;
+        }
+        else if (ilbm->ham) {
+            v = l & ((1 << (ilbm->depth - 2)) - 1);
+            h = (l & ~v) >> (ilbm->depth - 2);
+
+            if (h == 0x00) {
+                if (!pal) {
+                    if ((v + 1) * 3 <= ilbm->cmap.size) {
+                        r = ilbm->cmap.data[v * 3];
+                        g = ilbm->cmap.data[v * 3 + 1];
+                        b = ilbm->cmap.data[v * 3 + 2];
+                    }
+                    else r = g = b = 0;
+                }
+                else {
+                    r = scalegun(pal[v * 2] & 0x0f, 4);
+                    g = scalegun((pal[v * 2 + 1] & 0xf0) >> 4, 4);
+                    b = scalegun((pal[v * 2 + 1] & 0x0f), 4);
+                }
+            }
+            else if (h == 0x01) b = scalegun(v, 8 - (ilbm->depth - 2));
+            else if (h == 0x02) r = scalegun(v, 8 - (ilbm->depth - 2));
+            else g = scalegun(v, 8 - (ilbm->depth - 2));
+        }
+        else if (ilbm->hbrite) {
+            v = l & ((1 << (ilbm->depth - 1)) - 1);
+            h = (l & ~v) >> (ilbm->depth - 1);
+
+            if (!pal) {
+                if ((v + 1) * 3 <= ilbm->cmap.size) {
+                    r = ilbm->cmap.data[v * 3];
+                    g = ilbm->cmap.data[v * 3 + 1];
+                    b = ilbm->cmap.data[v * 3 + 2];
+                }
+                else r = g = b = 0;
+            }
+            else {
+                r = scalegun(pal[v * 2] & 0x0f, 4);
+                g = scalegun((pal[v * 2 + 1] & 0xf0) >> 4, 4);
+                b = scalegun((pal[v * 2 + 1] & 0x0f), 4);
+            }
+
+            if (h) {
+                r = r >> 1;
+                g = g >> 1;
+                b = b >> 1;
+            }
+
+            if (ilbm->mask == 2 && v == L2RWORD(ilbm->bmhd.data + 12)) a = 0x00;
+        }
+        else if (ilbm->cmap.size == 0 && !pal) {
+            v = l & ((1 << ilbm->depth) - 1);
+            r = scalegun(v, ilbm->depth);
+            g = r;
+            b = r;
+        }
+        else {
+            v = l & 0xff;
+            if (!pal) {
+                if ((v + 1) * 3 <= ilbm->cmap.size) {
+                    r = ilbm->cmap.data[v * 3];
+                    g = ilbm->cmap.data[v * 3 + 1];
+                    b = ilbm->cmap.data[v * 3 + 2];
+                }
+                else r = g = b = 0;
+            }
+            else {
+                r = scalegun(pal[v * 2] & 0x0f, 4);
+                g = scalegun((pal[v * 2 + 1] & 0xf0) >> 4, 4);
+                b = scalegun((pal[v * 2 + 1] & 0x0f), 4);
+            }
+
+            if (ilbm->mask == 2 && v == L2RWORD(ilbm->bmhd.data + 12)) a = 0x00;
+        }
+
+        row[x] = ((unsigned long)a << 24) | ((unsigned long)r << 16) | ((unsigned 
long)g << 8) | (unsigned long)b;
 
         bit = bit >> 1;
-        if (bit == 0)
-          {
-             o++;
-             bit = 0x80;
-          }
-     }
+        if (bit == 0) {
+            o++;
+            bit = 0x80;
+        }
+    }
 }
 
+
 /*------------------------------------------------------------------------------
  * Loads an image. If im->loader is non-zero, or immediate_load is non-zero, or
  * progress is non-zero, then the file is fully loaded, otherwise only the width
  * and height are read.
  *
- * Uses BMHD, CAMG, CMAP, and BODY chunks. Ignores others, e.g. DPI_ or ANNO.
+ * Imlib2 doesn't support reading comment chunks like ANNO.
  *------------------------------------------------------------------------------*/
-char
-load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
-     char immediate_load)
+char    load(ImlibImage *im, ImlibProgressFunction progress, char 
progress_granularity, char immediate_load)
 {
-   int                 cancel, full, ham, hbrite, i, j, k, mask, n, rle, ok,
-       planes, y, z, prevy;
-   unsigned char      *plane[40];
-   char                per, pper;
-   BODY                body;
-   CHUNK               bmhd, camg, cmap;
+char    *env;
+int     cancel, full, i, j, k, n, ok, y, z, gran, nexty, prevy;
+unsigned char *plane[40];
+ILBM    ilbm;
 
   /*----------
    * Do nothing if the data is already loaded.
    *----------*/
-   if (im->data)
-      return 0;
+    if (im->data) return 0;
 
   /*----------
-   * Load the chunk(s) we're interested in. If full is not true, then
-   * we only want the image size and format.
+   * Load the chunk(s) we're interested in. If full is not true, then we only
+   * want the image size and format.
    *----------*/
-   full = (im->loader || immediate_load || progress);
-   if (full)
-      ok = loadchunks(im->real_file, &bmhd, &camg, &cmap, &body);
-   else
-      ok = loadchunks(im->real_file, &bmhd, NULL, NULL, NULL);
-   if (!ok)
-      return 0;
+    full = (im->loader || immediate_load || progress);
+    ok = loadchunks(im->real_file, &ilbm, full);
+    if (!ok) return 0;
 
   /*----------
    * Use and check header.
    *----------*/
-   ok = 0;
-   if (bmhd.size >= 20)
-     {
+    ok = 0;
+    if (ilbm.bmhd.size >= 20) {
         ok = 1;
 
-        im->w = L2RWORD(bmhd.data);
-        im->h = L2RWORD(bmhd.data + 2);
-
-        planes = bmhd.data[8];
-        if (planes < 1 || (planes > 8 && planes != 24 && planes != 32))
-           ok = 0;              /* Only 1 to 8, 24, or 32 planes. */
-
-        if (bmhd.data[10] > 1)
-           ok = 0;              /* Only NONE or RLE compression. */
-        rle = bmhd.data[10];
-
-        mask = bmhd.data[9];
-
-        if (mask || planes == 32)
-           SET_FLAG(im->flags, F_HAS_ALPHA);
-        else
-           UNSET_FLAG(im->flags, F_HAS_ALPHA);
-
-        if (!im->format)
-           im->format = strdup("lbm");
-
-        ham = 0;
-        hbrite = 0;
-        if (planes <= 8)
-          {
-             if (camg.size == 4)
-               {
-                  if (camg.data[2] & 0x08)
-                     ham = 1;
-                  if (camg.data[3] & 0x80)
-                     hbrite = 1;
-
-                  if (ham && full
-                      && (planes < 6 || cmap.size < 3 * (1 << (planes - 2))))
-                     ham = 0;
-                  if (hbrite && full
-                      && (planes < 5 || cmap.size < 3 * (1 << (planes - 1))))
-                     hbrite = 0;
-               }
-             else
-               {
-                  if (planes == 6 && full && cmap.size >= 3 * 16)
-                     ham = 1;
-                  if (full && !ham && planes > 1
-                      && cmap.size == 3 * (1 << (planes - 1)))
-                     hbrite = 1;
-               }
-          }
-     }
-   if (!full || !ok)
-     {
-        free(bmhd.data);
-        if (full && camg.data)
-           free(camg.data);
-        if (full && cmap.data)
-           free(cmap.data);
-        if (full && body.data)
-           free(body.data);
+        im->w = L2RWORD(ilbm.bmhd.data);
+        im->h = L2RWORD(ilbm.bmhd.data + 2);
+        if (im->w <= 0 || im->h <= 0) ok = 0;
+
+        ilbm.depth = ilbm.bmhd.data[8];
+        if (ilbm.depth < 1 || (ilbm.depth > 8 && ilbm.depth != 24 && ilbm.depth != 
32)) ok = 0; /* Only 1 to 8, 24, or 32 planes. */
+
+        ilbm.rle = ilbm.bmhd.data[10];
+        if (ilbm.rle < 0 || ilbm.rle > 1) ok = 0;       /* Only NONE or RLE 
compression. */
+
+        ilbm.mask = ilbm.bmhd.data[9];
+
+        if (ilbm.mask || ilbm.depth == 32) SET_FLAG(im->flags, F_HAS_ALPHA);
+        else UNSET_FLAG(im->flags, F_HAS_ALPHA);
+
+        env = getenv("IMLIB2_LBM_NOMASK");
+        if (env && (!strcmp(env, "true") || !strcmp(env, "1") || !strcmp(env, "yes") 
|| !strcmp(env, "on"))) UNSET_FLAG(im->flags, F_HAS_ALPHA);
+
+        if (!im->format) im->format = strdup("lbm");
+
+        ilbm.ham = 0;
+        ilbm.hbrite = 0;
+        if (ilbm.depth <= 8) {
+            if (ilbm.camg.size == 4) {
+                if (ilbm.camg.data[2] & 0x08) ilbm.ham = 1;
+                if (ilbm.camg.data[3] & 0x80) ilbm.hbrite = 1;
+            }
+            else {                                      /* Only guess at ham and 
hbrite if CMAP is present. */
+                if (ilbm.depth == 6 && full && ilbm.cmap.size >= 3 * 16) ilbm.ham = 1;
+                if (full && !ilbm.ham && ilbm.depth > 1 && ilbm.cmap.size == 3 * (1 
<< (ilbm.depth - 1))) ilbm.hbrite = 1;
+            }
+        }
+    }
+    if (!full || !ok) {
+        freeilbm(&ilbm);
         return ok;
-     }
+    }
 
   /*----------
    * The source data is planar. Each plane is an even number of bytes wide. If
@@ -467,104 +463,88 @@
    * from each plane are interleaved, from top to bottom. The first plane is the
    * 0 bit.
    *----------*/
-   ok = 0;
-   cancel = 0;
-   plane[0] = NULL;
-
-   im->data = malloc(im->w * im->h * sizeof(DATA32));
-   if (im->data)
-     {
-        body.offset = 0;
-        body.count = 0;
-        body.rle = rle;
-        body.rletype = 0;
-
-        n = planes;
-        if (mask == 1)
-           n++;
+    ok = 0;
+    cancel = 0;
+    plane[0] = NULL;
+
+    im->data = malloc(im->w * im->h * sizeof(DATA32));
+    if (im->data) {
+        n = ilbm.depth;
+        if (ilbm.mask == 1) n++;
 
         plane[0] = malloc(((im->w + 15) / 16) * 2 * n);
-        for (i = 1; i < n; i++)
-           plane[i] = plane[i - 1] + ((im->w + 15) / 16) * 2;
+        for (i = 1; i < n; i++) plane[i] = plane[i - 1] + ((im->w + 15) / 16) * 2;
 
         z = ((im->w + 15) / 16) * 2 * n;
 
-        pper = 0;
-        prevy = 0;
-
-        for (y = 0; y < im->h; y++)
-          {
-             for (i = 0; i < z; i++)
-                plane[0][i] = bodybyte(&body);
-
-             deplane(im->data + im->w * y, im->w, &bmhd, &cmap, plane, planes,
-                     mask, ham, hbrite);
-
-             if (progress)
-               {
-                  per = (char)((100 * y) / im->h);
-                  if (per - pper >= progress_granularity || y == im->h - 1)
-                    {
-                       if (!progress(im, per, 0, prevy, im->w, y + 1))
-                         {
-                            cancel = 1;
-                            break;
-                         }
-                       pper = per;
-                       prevy = y;
-                    }
-               }
-          }
+        if (progress) {
+            prevy = 0;
+            if (progress_granularity <= 0) progress_granularity = 1;
+            gran = progress_granularity;
+            nexty = ((im->h * gran) / 100);
+        }
+
+        scalecmap(&ilbm);
+
+        for (y = 0; y < im->h; y++) {
+            bodyrow(plane[0], z, &ilbm);
+
+            deplane(im->data + im->w * y, im->w, &ilbm, plane);
+            ilbm.row++;
+
+            if (progress && (y >= nexty || y == im->h - 1)) {
+                if (!progress(im, (char)((100 * (y + 1)) / im->h), 0, prevy, im->w, y 
+ 1)) {
+                    cancel = 1;
+                    break;
+                }
+                prevy = y;
+                gran += progress_granularity;
+                nexty = ((im->h * gran) / 100);
+            }
+        }
 
         ok = !cancel;
-     }
+    }
 
   /*----------
    * We either had a successful decode, the user cancelled, or we couldn't get
    * the memory for im->data.
    *----------*/
-   if (!ok)
-     {
-        if (im->data)
-           free(im->data);
+    if (!ok) {
+        if (im->data) free(im->data);
         im->data = NULL;
-     }
+    }
 
-   if (plane[0])
-      free(plane[0]);
+    if (plane[0]) free(plane[0]);
 
-   free(bmhd.data);
-   if (camg.data)
-      free(camg.data);
-   if (cmap.data)
-      free(cmap.data);
-   if (body.data)
-      free(body.data);
+    freeilbm(&ilbm);
 
-   return (cancel) ? 2 : ok;
+    return (cancel)? 2: ok;
 }
 
+
 /*------------------------------------------------------------------------------
- * Does nothing. Perhaps save only in 24-bit format?
+ * Perhaps save only in 32-bit format? The IFF ILBM format has pretty much gone
+ * the way of the Amiga, who saves in this format any more?
  *------------------------------------------------------------------------------*/
-char
-save(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity)
+#if 0
+char    save(ImlibImage *im, ImlibProgressFunction progress, char 
progress_granularity)
 {
-   return 0;
+    return 0;
 }
+#endif
+
 
 /*------------------------------------------------------------------------------
  * Identifies the file extensions this loader handles. Standard code from other
  * loaders.
  *------------------------------------------------------------------------------*/
-void
-formats(ImlibLoader * l)
+void    formats(ImlibLoader *l)
 {
-   char               *list_formats[] = { "iff", "ilbm", "lbm" };
-   int                 i;
+char    *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]));
-   for (i = 0; i < l->num_formats; i++)
-      l->formats[i] = strdup(list_formats[i]);
+    l->num_formats = sizeof(list_formats) / sizeof(list_formats[0]);
+    l->formats = malloc(l->num_formats * sizeof(list_formats[0]));
+    for (i = 0; i < l->num_formats; i++) l->formats[i] = strdup(list_formats[i]);
 }




-------------------------------------------------------
This SF.Net email is sponsored by BEA Weblogic Workshop
FREE Java Enterprise J2EE developer tools!
Get your free copy of BEA WebLogic Workshop 8.1 today.
http://ads.osdn.com/?ad_id=5047&alloc_id=10808&op=click
_______________________________________________
enlightenment-cvs mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/enlightenment-cvs

Reply via email to