Fixes to image processing.

[liblbx.git] / src / image.c

diff --git a/src/image.c b/src/image.c
index a5b8b058557cc6f6179d27477eb1abd3cf2346b0..c1ad351983f8300e213946e1b8f941713cd83f0a 100644 (file)
--- a/src/image.c
+++ b/src/image.c
@@ -29,7 +29,7 @@ struct lbx_image {
 
 struct lbx_image *lbximg_fopen(FILE *f)
 {
-       struct lbx_image tmp = {.f = f}, *new;
+       struct lbx_image tmp = {.f = f}, *new = NULL;
 
        if (fread(&tmp.width,  sizeof tmp.width,   1, f) != 1) goto readerr;
        if (fread(&tmp.height, sizeof tmp.height,  1, f) != 1) goto readerr;
@@ -45,14 +45,23 @@ struct lbx_image *lbximg_fopen(FILE *f)
        tmp.frames = letohs(tmp.frames); tmp.foff += sizeof tmp.frames;
        tmp.wtf2   = letohs(tmp.wtf2);   tmp.foff += sizeof tmp.wtf2;
 
+       /* For some reason, the format seems to need this. */
+       tmp.offs++;
+       tmp.frames++;
+
+       if (tmp.offs <= tmp.frames) {
+               lbx_errno = LBX_EFORMAT;
+               return NULL;
+       }
+
        /*
         * DEBUG ONLY.  These assertions exist to catch otherwise valid image
         * files which differ from what I believe to be true of all LBX images.
         * If we never find any exceptions, we can replace the assertions with
         * assumptions.
         */
-       assert(tmp.wtf1 == 0);
-       assert(tmp.offs == tmp.frames + 1);
+       _lbx_assert(tmp.wtf1 == 0);
+       _lbx_assert(tmp.offs == tmp.frames + 1);
 
        new = malloc(sizeof *new + tmp.offs * sizeof *new->offsets);
        if (!new) {
@@ -100,18 +109,17 @@ static int _lbx_drawrow(int first, struct lbx_image *img)
        if (type == 0) {
                if (fread(&yval,  sizeof yval,  1, img->f) != 1) goto readerr;
                yval = letohs(yval); img->foff += sizeof yval;
-
                if (yval == 1000)
                        return 1;
-
                if (fread(&count, sizeof count, 1, img->f) != 1) goto readerr;
                count = letohs(count); img->foff += sizeof count;
                if (fread(&xval,  sizeof xval,  1, img->f) != 1) goto readerr;
                xval = letohs(xval); img->foff += sizeof xval;
+               if (xval == 1000)
+                       return 1;
 
                /* Ensure that the row fits in the image. */
-               if (img->height - img->currenty <= yval
-                   || xval >= img->width || count > img->width - xval) {
+               if (img->height - img->currenty <= yval || xval >= img->width) {
                        lbx_errno = LBX_EFORMAT;
                        return -1;
                }
@@ -119,14 +127,22 @@ static int _lbx_drawrow(int first, struct lbx_image *img)
                img->currenty += yval;
                img->currentx  = xval;
        } else {
-               count = 0;
-/*
-               count = type;
-               if (count > img->width - img->currentx) {
+               if (fread(&xval,  sizeof xval,  1, img->f) != 1) goto readerr;
+               xval = letohs(xval); img->foff += sizeof xval;
+
+               if (img->width - img->currentx <= xval) {
                        lbx_errno = LBX_EFORMAT;
                        return -1;
                }
-*/
+               img->currentx += xval;
+
+               count = type;
+
+       }
+
+       if (count > img->width - img->currentx) {
+               lbx_errno = LBX_EFORMAT;
+               return -1;
        }
 
        pos = &img->framedata[img->currenty][img->currentx];
@@ -204,7 +220,7 @@ unsigned char **lbximg_getframe(struct lbx_image *img, int frame)
                                return NULL;
                        first = 0;
 
-                       if (img->foff > img->offsets[frame+1]) {
+                       if (!rc && img->foff > img->offsets[frame+1]) {
                                lbx_errno = LBX_EFORMAT;
                                return NULL;
                        }
@@ -215,6 +231,89 @@ unsigned char **lbximg_getframe(struct lbx_image *img, int frame)
        return img->framedata;
 }
 
+int lbximg_loadpalette(FILE *f, struct lbx_colour palette[static 256])
+{
+       uint8_t entry[4];
+       int i;
+
+       for (i = 0; i < 256; i++) {
+               if (fread(entry, sizeof entry, 1, f) != 1) {
+                       lbx_errno = (feof(f)) ? LBX_EEOF : -errno;
+                       return -1;
+               }
+
+               if (entry[0] != 1) {
+                       lbx_errno = LBX_EFORMAT;
+                       return -1;
+               }
+
+               palette[i] = (struct lbx_colour){
+                       .red   = entry[1] << 2,
+                       .green = entry[2] << 2,
+                       .blue  = entry[3] << 2,
+               };
+       }
+
+       return 0;
+}
+
+int
+lbximg_getpalette(struct lbx_image *img, struct lbx_colour palette[static 256])
+{
+       int index = 0;
+       size_t rc;
+       size_t hdrlen = 6*(sizeof img->width)
+                       + (img->offs)*(sizeof *img->offsets);
+       
+       uint8_t entry[4];
+
+       /* Palette data is located right after the header. */
+       if (_lbx_fseek(img->f, &img->foff, hdrlen) == -1)
+               return -1;
+       
+       while (img->foff + sizeof entry <= img->offsets[0]) {
+               rc = fread(entry, 1, sizeof entry, img->f);
+               img->foff += rc;
+
+               if (rc < sizeof entry) {
+                       goto readerr;
+               }
+
+               if (entry[0] == 0) {
+                       index++;
+                       if (index >= 256) {
+                               lbx_errno = LBX_EFORMAT;
+                               return -1;
+                       }
+               } else {
+                       index = entry[0];
+               }
+
+               palette[index] = (struct lbx_colour){
+                       .red   = entry[1] << 2,
+                       .green = entry[2] << 2,
+                       .blue  = entry[3] << 2,
+               };
+       }
+
+       return 0;
+readerr:
+       if (feof(img->f))
+               lbx_errno = LBX_EEOF;
+       else
+               lbx_errno = -errno;
+       return -1;
+}
+
+void lbximg_getinfo(struct lbx_image *img, struct lbx_imginfo *info)
+{
+       *info = (struct lbx_imginfo) {
+               .width   = img->width,
+               .height  = img->height,
+               .nframes = img->frames,
+       };
+}
+
 void lbximg_close(struct lbx_image *img)
 {
        if (!img) return;