X-Git-Url: https://git.draconx.ca/gitweb/liblbx.git/blobdiff_plain/0806586ee10e29b60a77c351d355a00087f81f57..a5ebd4f7732ad6846b0dc992c8d43cac636f580d:/src/image.c diff --git a/src/image.c b/src/image.c index 86f6f98..c1ad351 100644 --- a/src/image.c +++ b/src/image.c @@ -7,20 +7,29 @@ #include #include -#include "lbx.h" #include "byteorder.h" +#include "misc.h" +#include "lbx.h" +#include "image.h" struct lbx_image { - FILE *f; uint16_t width, height; uint16_t wtf1, wtf2; uint16_t offs, frames; + + FILE *f; + long foff; + + int currentframe; + int currentx, currenty; + unsigned char **framedata; + uint32_t offsets[]; }; 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; @@ -29,12 +38,21 @@ struct lbx_image *lbximg_fopen(FILE *f) if (fread(&tmp.frames, sizeof tmp.frames, 1, f) != 1) goto readerr; if (fread(&tmp.wtf2, sizeof tmp.wtf2, 1, f) != 1) goto readerr; - tmp.width = letohs(tmp.width); - tmp.height = letohs(tmp.height); - tmp.wtf1 = letohs(tmp.wtf1); - tmp.offs = letohs(tmp.offs); - tmp.frames = letohs(tmp.frames); - tmp.wtf2 = letohs(tmp.wtf2); + tmp.width = letohs(tmp.width); tmp.foff += sizeof tmp.width; + tmp.height = letohs(tmp.height); tmp.foff += sizeof tmp.height; + tmp.wtf1 = letohs(tmp.wtf1); tmp.foff += sizeof tmp.wtf1; + tmp.offs = letohs(tmp.offs); tmp.foff += sizeof tmp.offs; + 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 @@ -42,8 +60,8 @@ struct lbx_image *lbximg_fopen(FILE *f) * 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) { @@ -52,9 +70,11 @@ struct lbx_image *lbximg_fopen(FILE *f) } *new = tmp; + new->currentframe = -1; - if (fread(new->offsets, sizeof *new->offsets, new->offs, f) != new->offs) + if (fread(new->offsets, sizeof *new->offsets, new->offs, f)!= new->offs) goto readerr; + new->foff += sizeof *new->offsets * new->offs; return new; readerr: @@ -68,10 +88,241 @@ readerr: return NULL; } +static int _lbx_drawrow(int first, struct lbx_image *img) +{ + uint16_t type, yval, count, xval; + unsigned char *pos; + unsigned char abyss; + size_t rc; + + assert(img->framedata); + + if (fread(&type, sizeof type, 1, img->f) != 1) goto readerr; + type = letohs(type); img->foff += sizeof type; + + if (first) { + img->currentx = 0; + img->currenty = 0; + type = 0; + } + + 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) { + lbx_errno = LBX_EFORMAT; + return -1; + } + + img->currenty += yval; + img->currentx = xval; + } else { + 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]; + rc = fread(pos, 1, count, img->f); + img->currentx += rc; + img->foff += rc; + + if (rc < count) + goto readerr; + + if (count % 2) { + if (fread(&abyss, 1, 1, img->f) != 1) + goto readerr; + img->foff += 1; + } + + return 0; +readerr: + if (feof(img->f)) { + lbx_errno = LBX_EEOF; + } else { + lbx_errno = -errno; + } + return -1; +} + +unsigned char **lbximg_getframe(struct lbx_image *img, int frame) +{ + if (frame >= img->frames || frame < 0) { + lbx_errno = LBX_ERANGE; + return NULL; + } + + if (!img->framedata) { + unsigned char *tmp; + int i; + + tmp = malloc(img->width * img->height); + if (!tmp) { + lbx_errno = -errno; + return NULL; + } + + img->framedata = malloc(img->height * sizeof *img->framedata); + if (!img->framedata) { + lbx_errno = -errno; + free(tmp); + return NULL; + } + + for (i = 0; i < img->height; i++) { + img->framedata[i] = tmp + i * img->width; + } + } + + /* Start over if we are backtracking. */ + if (img->currentframe > frame) + img->currentframe == -1; + + /* We must have previous frame decoded to continue. */ + if (frame > img->currentframe + 1) { + if (!lbximg_getframe(img, frame-1)) + return NULL; + } + + if (img->currentframe != frame) { + int rc, first = 1; + + if (_lbx_fseek(img->f, &img->foff, img->offsets[frame]) == -1) + return NULL; + + do { + rc = _lbx_drawrow(first, img); + if (rc == -1) + return NULL; + first = 0; + + if (!rc && img->foff > img->offsets[frame+1]) { + lbx_errno = LBX_EFORMAT; + return NULL; + } + } while (!rc); + } + + img->currentframe = 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; + if (img->framedata) { + free(img->framedata[0]); + free(img->framedata); + } + if (img->f) { fclose(img->f); }