X-Git-Url: https://git.draconx.ca/gitweb/liblbx.git/blobdiff_plain/0806586ee10e29b60a77c351d355a00087f81f57..f5c3db7a3cc9d46f8bb8b2d0d010eb73d68bb9c5:/src/image.c diff --git a/src/image.c b/src/image.c index 86f6f98..fda9dfc 100644 --- a/src/image.c +++ b/src/image.c @@ -1,40 +1,76 @@ +/* 2ooM: The Master of Orion II Reverse Engineering Project + * Library for working with LBX image files. + * Copyright (C) 2006-2008 Nick Bowler + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include +#include #include #include -#include "lbx.h" #include "byteorder.h" +#include "misc.h" +#include "lbx.h" +#include "image.h" + +#define FLAG_OVERWRITE 0x0400 /* Draw each frame on a clean slate (unsure). */ +#define FLAG_PALETTE 0x1000 /* Image contains embedded palette. */ +#define FLAG_LOOPING 0x2000 /* Loop over all frames in the image (unsure). */ struct lbx_image { - FILE *f; uint16_t width, height; - uint16_t wtf1, wtf2; - uint16_t offs, frames; + uint16_t wtf1; + uint16_t frames, leadin; + uint16_t flags; + uint16_t palstart, palcount; + + FILE *f; + long foff, paloff; + + int currentframe; + int currentx, currenty; + unsigned char **framedata; + unsigned char **mask; + 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; + size_t rc; if (fread(&tmp.width, sizeof tmp.width, 1, f) != 1) goto readerr; if (fread(&tmp.height, sizeof tmp.height, 1, f) != 1) goto readerr; if (fread(&tmp.wtf1, sizeof tmp.wtf1, 1, f) != 1) goto readerr; - if (fread(&tmp.offs, sizeof tmp.offs, 1, f) != 1) goto readerr; if (fread(&tmp.frames, sizeof tmp.frames, 1, f) != 1) goto readerr; - if (fread(&tmp.wtf2, sizeof tmp.wtf2, 1, f) != 1) goto readerr; + if (fread(&tmp.leadin, sizeof tmp.leadin, 1, f) != 1) goto readerr; + if (fread(&tmp.flags, sizeof tmp.flags, 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.frames = letohs(tmp.frames); tmp.foff += sizeof tmp.frames; + tmp.leadin = letohs(tmp.leadin); tmp.foff += sizeof tmp.leadin; + tmp.flags = letohs(tmp.flags); tmp.foff += sizeof tmp.flags; /* * DEBUG ONLY. These assertions exist to catch otherwise valid image @@ -42,19 +78,41 @@ 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.frames > tmp.leadin); /* cmbtshp.lbx breaks this. */ + _lbx_assert(!(tmp.flags & ~(FLAG_PALETTE|FLAG_OVERWRITE|FLAG_LOOPING))); - new = malloc(sizeof *new + tmp.offs * sizeof *new->offsets); + new = malloc(sizeof *new + (tmp.frames+1) * sizeof *new->offsets); if (!new) { lbx_errno = -errno; return NULL; } *new = tmp; + new->currentframe = -1; - if (fread(new->offsets, sizeof *new->offsets, new->offs, f) != new->offs) + rc = fread(new->offsets, sizeof *new->offsets, new->frames+1, f); + if (rc < new->frames+1) goto readerr; + new->foff += sizeof *new->offsets * (new->frames+1); + + if (new->flags & FLAG_PALETTE) { + if (fread(&new->palstart, sizeof new->palstart, 1, f) != 1) + goto readerr; + if (fread(&new->palcount, sizeof new->palcount, 1, f) != 1) + goto readerr; + + new->palstart = letohs(new->palstart); + new->palcount = letohs(new->palcount); + new->foff += sizeof new->palstart + sizeof new->palcount; + new->paloff = new->foff; + + if (new->palstart + new->palcount > 256) { + lbx_errno = LBX_EFORMAT; + free(new); + return NULL; + } + } return new; readerr: @@ -68,10 +126,278 @@ 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); + assert(img->mask); + + 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; + } + + 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; + 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; +} + +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) { + lbx_errno = LBX_ERANGE; + return NULL; + } + + if (!img->framedata) { + img->framedata = allocframebuffer(img->width, img->height); + if (!img->framedata) + return NULL; + } + + if (!img->mask) { + img->mask = allocframebuffer(img->width, img->height); + if (!img->mask) + return NULL; + } + + /* Start over if we are backtracking. */ + if (img->currentframe > frame) + img->currentframe == -1; + + 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) { + 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]) +{ + unsigned int i; + size_t rc; + + uint8_t entry[4]; + + /* Do nothing if the image doesn't have embedded palette data. */ + if (!(img->flags & FLAG_PALETTE)) + return 0; + + if (_lbx_fseek(img->f, &img->foff, img->paloff) == -1) + return -1; + + for (i = 0; i < img->palcount; i++) { + rc = fread(entry, 1, sizeof entry, img->f); + img->foff += rc; + + if (rc < sizeof entry) { + goto readerr; + } + + if (entry[0] != 0) { + lbx_errno = LBX_EFORMAT; + return -1; + } + + palette[img->palstart + i] = (struct lbx_colour){ + .red = entry[1] << 2, + .green = entry[2] << 2, + .blue = entry[3] << 2, + }; + } + + return 0; +readerr: + lbx_errno = feof(img->f) ? LBX_EEOF : -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, + .palettesz = (img->flags & FLAG_PALETTE) ? img->palcount : 0, + }; + + /* There seems to be two ways of specifying that an image loops. */ + if (img->flags & FLAG_LOOPING) { + info->loopstart = 0; + info->looping = 1; + } else if (img->leadin != img->frames - 1) { + info->loopstart = img->leadin; + info->looping = 1; + } +} + +unsigned char **lbximg_getmask(struct lbx_image *img) +{ + return img->mask; +} + void lbximg_close(struct lbx_image *img) { if (!img) return; + if (img->framedata) { + free(img->framedata[0]); + free(img->framedata); + } + + if (img->mask) { + free(img->mask[0]); + free(img->mask); + } + if (img->f) { fclose(img->f); }