Implement image masks to handle transparency in images.

This makes a whole bootload of images work properly.

LBX doesn't translate nicely to PNG when there are transparent pixels.
Therefore, lbximg will use 256-colour paletted PNG when there are no such
pixels, and 32-bit RGBA PNG when there is at least one such pixel.  This choice
is mainly because working with 32-bit RGBA PNGs takes forever on my laptop.

Apparently the simtex logo image contains some transparent pixels, thus the
regression test has been suitably updated.

diff --git a/src/image.c b/src/image.c
index 2d34b52b0e2c742611e292c1d68cd8bcbec35e77..f32a66094372eda5de7418afa32450abad9ab2f2 100644 (file)
--- a/src/image.c
+++ b/src/image.c
@@ -29,6 +29,7 @@ struct lbx_image {
        int currentframe;
        int currentx, currenty;
        unsigned char **framedata;
+       unsigned char **mask;
 
        uint32_t offsets[];
 };
@@ -101,6 +102,7 @@ static int _lbx_drawrow(int first, struct lbx_image *img)
        size_t rc;
 
        assert(img->framedata);
+       assert(img->mask);
 
        if (fread(&type, sizeof type, 1, img->f) != 1) goto readerr;
        type = letohs(type); img->foff += sizeof type;
@@ -150,6 +152,8 @@ static int _lbx_drawrow(int first, struct lbx_image *img)
                return -1;
        }
 
+       memset(&img->mask[img->currenty][img->currentx], 1, count);
+
        pos = &img->framedata[img->currenty][img->currentx];
        rc  = fread(pos, 1, count, img->f);
        img->currentx += rc;
@@ -174,6 +178,31 @@ readerr:
        return -1;
 }
 
+static unsigned char **allocframebuffer(size_t width, size_t height)
+{
+       unsigned char **new, *tmp;
+       size_t i;
+
+       tmp = calloc(height, width);
+       if (!tmp) {
+               lbx_errno = -errno;
+               return NULL;
+       }
+
+       new = malloc(height * sizeof *new);
+       if (!new) {
+               lbx_errno = -errno;
+               free(tmp);
+               return NULL;
+       }
+
+       for (i = 0; i < height; i++) {
+               new[i] = tmp + i * width;
+       }
+
+       return new;
+}
+
 unsigned char **lbximg_getframe(struct lbx_image *img, int frame)
 {
        if (frame >= img->frames || frame < 0) {
@@ -182,25 +211,15 @@ unsigned char **lbximg_getframe(struct lbx_image *img, int frame)
        }
 
        if (!img->framedata) {
-               unsigned char *tmp;
-               int i;
-
-               tmp = malloc(img->width * img->height);
-               if (!tmp) {
-                       lbx_errno = -errno;
+               img->framedata = allocframebuffer(img->width, img->height);
+               if (!img->framedata)
                        return NULL;
-               }
+       }
 
-               img->framedata = malloc(img->height * sizeof *img->framedata);
-               if (!img->framedata) {
-                       lbx_errno = -errno;
-                       free(tmp);
+       if (!img->mask) {
+               img->mask = allocframebuffer(img->width, img->height);
+               if (!img->mask)
                        return NULL;
-               }
-
-               for (i = 0; i < img->height; i++) {
-                       img->framedata[i] = tmp + i * img->width;
-               }
        }
 
        /* Start over if we are backtracking. */
@@ -210,6 +229,7 @@ unsigned char **lbximg_getframe(struct lbx_image *img, int frame)
        if (img->flags & FLAG_OVERWRITE) {
                /* Clear the slate. */
                memset(img->framedata[0], 0, img->width * img->height);
+               memset(img->mask[0],      0, img->width * img->height);
        } else {
                /* We must have previous frame decoded to continue. */
                if (frame > img->currentframe + 1) {
@@ -346,6 +366,11 @@ void lbximg_getinfo(struct lbx_image *img, struct lbx_imginfo *info)
        }
 }
 
+unsigned char **lbximg_getmask(struct lbx_image *img)
+{
+       return img->mask;
+}
+
 void lbximg_close(struct lbx_image *img)
 {
        if (!img) return;
@@ -355,6 +380,11 @@ void lbximg_close(struct lbx_image *img)
                free(img->framedata);
        }
 
+       if (img->mask) {
+               free(img->mask[0]);
+               free(img->mask);
+       }
+
        if (img->f) {
                fclose(img->f);
        }

diff --git a/src/image.h b/src/image.h
index a1f2eff86c7df9af068c2ed5e2174993aa4f6263..3ef95ab95f821430dec4d028634b2a3f947d84ae 100644 (file)
--- a/src/image.h
+++ b/src/image.h
@@ -21,6 +21,7 @@ struct lbx_imginfo {
 LBX_IMG *lbximg_fopen(FILE *f);
 void     lbximg_close(LBX_IMG *img);
 unsigned char **lbximg_getframe(LBX_IMG *img, int frame);
+unsigned char **lbximg_getmask(LBX_IMG *img);
 
 int lbximg_loadpalette(FILE *f, struct lbx_colour palette[static 256]);
 int lbximg_getpalette(LBX_IMG *img, struct lbx_colour palette[static 256]);

diff --git a/src/lbximg.c b/src/lbximg.c
index d5282908d5a3db9b3a40f68a3080f1efa1092d6d..6c6de5759e32e9e24ab83ca56c60f7bfc0e3558d 100644 (file)
--- a/src/lbximg.c
+++ b/src/lbximg.c
@@ -76,11 +76,26 @@ int parserange(struct lbx_imginfo *info, char *str, unsigned char *bits)
        return 0;
 }
 
-int outpng(unsigned int frameno, unsigned char **framedata,
-           unsigned int width,   unsigned int height,
+static int ismasked(unsigned char **mask, unsigned width, unsigned height)
+{
+       unsigned y, x;
+       for (y = 0; y < height; y++) {
+               for (x = 0; x < width; x++) {
+                       if (mask[y][x] == 0) return 1;
+               }
+       }
+
+       return 0;
+}
+
+int outpng(unsigned int frameno,
+           unsigned char **framedata, unsigned char **mask,
+           unsigned int width, unsigned int height,
            struct lbx_colour palette[static 256])
 {
        char name[strlen(outname) + sizeof ".65535.png"];
+       unsigned char *row;
+       unsigned int x, y;
        FILE *of;
 
        png_structp png;
@@ -88,10 +103,17 @@ int outpng(unsigned int frameno, unsigned char **framedata,
 
        assert(frameno < 65536);
        snprintf(name, sizeof name, "%s.%03d.png", outname, frameno);
-       
+
+       row = malloc(4 * width);
+       if (!row) {
+               errmsg("failed to allocate row buffer: %s\n", strerror(errno));
+               return -1;
+       }
+
        of = fopen(name, "wb");
        if (!of) {
                errmsg("failed to open %s: %s.\n", name, strerror(errno));
+               free(row);
                return -1;
        }
 
@@ -109,22 +131,54 @@ int outpng(unsigned int frameno, unsigned char **framedata,
        }
 
        if (setjmp(png_jmpbuf(png))) {
+               free(row);
                png_destroy_write_struct(&png, &info);
                goto err;
        }
 
-               
-       png_set_IHDR(png, info, width, height, 8,
-                    usepalette ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_GRAY,
-                    PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
-                    PNG_FILTER_TYPE_DEFAULT);
+       png_init_io(png, of);
 
-       if (usepalette)
-               png_set_PLTE(png, info, (png_colorp)palette, 256);
-       png_set_rows(png, info, framedata);
+       if (!ismasked(mask, width, height)) {
+               /*
+                * This case is easy; we can just feed the palette and pixel
+                * data to libpng and let it do its magic.
+                */
 
-       png_init_io(png, of);
-       png_write_png(png, info, PNG_TRANSFORM_IDENTITY, NULL);
+               png_set_IHDR(png, info, width, height, 8,
+                            PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
+                            PNG_COMPRESSION_TYPE_DEFAULT,
+                            PNG_FILTER_TYPE_DEFAULT);
+               
+               png_set_PLTE(png, info, (png_colorp)palette, 256);
+               png_set_rows(png, info, framedata);
+               png_write_png(png, info, PNG_TRANSFORM_IDENTITY, NULL);
+       } else {
+               /*
+                * Unfortunately, LBX doesn't translate nicely to PNG here.
+                * LBX has a 256 colour palette _plus_ transparency.
+                * We'll form an RGBA PNG to deal with this.
+                */
+
+               png_set_IHDR(png, info, width, height, 8,
+                            PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
+                            PNG_COMPRESSION_TYPE_DEFAULT,
+                            PNG_FILTER_TYPE_DEFAULT);
+       
+               png_write_info(png, info);
+       
+               for (y = 0; y < height; y++) {
+                       for (x = 0; x < width; x++) {
+                               row[4*x+0] = palette[framedata[y][x]].red;
+                               row[4*x+1] = palette[framedata[y][x]].green;
+                               row[4*x+2] = palette[framedata[y][x]].blue;
+                               row[4*x+3] = (mask[y][x]) ? -1 : 0;
+                       }
+       
+                       png_write_row(png, row);
+               }
+       
+               png_write_end(png, NULL);
+       }
 
        png_destroy_write_struct(&png, &info);
        fclose(of);
@@ -133,35 +187,84 @@ int outpng(unsigned int frameno, unsigned char **framedata,
                printf("wrote %s\n", name);
 
        return 0;
+
 err:
        fclose(of);
        remove(name);
+       free(row);
        return -1;
 }
 
+static int loadoverride(FILE *f, struct lbx_colour palette[static 256])
+{
+       LBX_IMG *overimg = lbximg_fopen(f);
+       struct lbx_imginfo info;
+
+       if (!overimg) {
+               errmsg("failed to open override image: %s\n", lbx_strerror());
+               return -1;
+       }
+       lbximg_getinfo(overimg, &info);
+
+       if (!info.haspalette) {
+               errmsg("override image has no palette.\n", 0);
+               lbximg_close(overimg);
+               return -1;
+       }
+
+       if (lbximg_getpalette(overimg, palette) == -1) {
+               errmsg("error reading override palette: %s\n", lbx_strerror());
+               lbximg_close(overimg);
+               return -1;
+       }
+
+       lbximg_close(overimg);
+       return 0;
+}
+
 static int loadpalette(LBX_IMG *img, struct lbx_imginfo *info,
-                       FILE *palf, struct lbx_colour palette[static 256])
+                       FILE *palf, FILE *override,
+                       struct lbx_colour palette[static 256])
 {
        int i;
 
-       for (i = 0; i < 256; i++)
-               palette[i] = (struct lbx_colour){0xff, 0x00, 0xff};
-
-       if (palf) {
-               if (lbximg_loadpalette(palf, palette) == -1) {
-                       errmsg("error reading palette: %s\n", lbx_strerror());
-                       return -1;
+       /* In no-palette mode, use palette indices for colour. */
+       if (!usepalette) {
+               for (i = 0; i < 256; i++) {
+                       palette[i] = (struct lbx_colour){i,i,i};
                }
-       } else if (!info->haspalette) {
+
+               return 0;
+       }
+
+       /* For sanity. */
+       if (!palf && !info->haspalette && !override) {
                errmsg("no palette available.\n", 0);
                return -1;
        }
 
-       if (lbximg_getpalette(img, palette) == -1) {
+       /* Default the palette to a wonderful pink. */
+       for (i = 0; i < 256; i++) {
+               palette[i] = (struct lbx_colour){0xff, 0x00, 0xff};
+       }
+
+       /* Read the external palette, if any. */
+       if (palf && lbximg_loadpalette(palf, palette) == -1) {
+               errmsg("error reading external palette: %s\n", lbx_strerror());
+               return -1;
+       }
+
+       /* Read the embedded palette, if any. */
+       if (info->haspalette && lbximg_getpalette(img, palette) == -1) {
                errmsg("error reading embedded palette: %s\n", lbx_strerror());
                return -1;
        }
 
+       /* Read the override palette, if any. */
+       if (override && loadoverride(override, palette) == -1) {
+               return -1;
+       }
+
        return 0;
 }
 
@@ -190,51 +293,27 @@ int decode(LBX_IMG *img, FILE *palf, FILE *override, char **argv)
                }
        }
 
-       if (usepalette && loadpalette(img, &info, palf, palette) == -1) {
+       if (loadpalette(img, &info, palf, override, palette) == -1) {
                goto err;
        }
 
-       if (override) {
-               LBX_IMG *overimg = lbximg_fopen(override);
-               struct lbx_imginfo info;
-
-               if (!overimg) {
-                       errmsg("failed to open override image: %s\n",
-                              lbx_strerror());
-                       goto err;
-               }
-               lbximg_getinfo(overimg, &info);
-
-               if (!info.haspalette) {
-                       errmsg("override image has no palette.\n", 0);
-                       lbximg_close(overimg);
-                       goto err;
-               }
-
-               if (lbximg_getpalette(overimg, palette) == -1) {
-                       errmsg("error reading override palette: %s\n",
-                              lbx_strerror());
-                       lbximg_close(overimg);
-                       goto err;
-               }
-
-               lbximg_close(overimg);
-       }
-
        /* Extract the images, in order. */
        for (i = 0; i < info.nframes; i++) {
-               unsigned char **framedata;
+               unsigned char **data;
+               unsigned char **mask;
 
                if (!(framebits[i / CHAR_BIT] & (1 << (i % CHAR_BIT))))
                        continue;
 
-               framedata = lbximg_getframe(img, i);
-               if (!framedata) {
+               data = lbximg_getframe(img, i);
+               if (!data) {
                        errmsg("error in frame %u: %s\n", i, lbx_strerror());
                        continue;
                }
 
-               if (!outpng(i, framedata, info.width, info.height, palette)) {
+               mask = lbximg_getmask(img);
+
+               if (!outpng(i, data, mask, info.width, info.height, palette)) {
                        extracted = 1;
                }
        }
@@ -243,7 +322,7 @@ int decode(LBX_IMG *img, FILE *palf, FILE *override, char **argv)
                errmsg("no frames extracted.\n", 0);
                goto err;
        }
-       
+
        free(framebits);
        return EXIT_SUCCESS;
 err:

diff --git a/tests/regress.sh b/tests/regress.sh
index 9c56d776ab8cb9a95c239bf985ab5256776213ec..5d893e58c860fd34f8fe817e4bef44eef336c7c3 100755 (executable)
--- a/tests/regress.sh
+++ b/tests/regress.sh
@@ -58,7 +58,7 @@ $LBXTOOL -xf $DATADIR/logo.lbx
 
 echo "logo.lbx.000: single frame, embedded palette:"
 $LBXIMG -df logo.lbx.000
-compare 0 75f9e5a7205192b414f009424ffb7dc3
+compare 0 5cc8d2b761390d15be2738030c658bfc
 
 echo "logo.lbx.001: multi frame, embedded palette:"
 $LBXIMG -df logo.lbx.001 0 30 63