lib_LTLIBRARIES += liblbx.la
liblbx_la_SOURCES = src/lbx.c src/fops.c src/image.c src/pack.c src/error.c
+liblbx_la_LDFLAGS = -export-symbols-regex '^lbx_'
bin_PROGRAMS += lbxtool
lbxtool_SOURCES = src/lbxtool.c
if (!image)
return;
- lbximg_getinfo(image, &info);
+ lbx_img_getinfo(image, &info);
spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
play = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "playbutton"));
if (framebuf)
g_object_unref(framebuf);
- lbximg_getinfo(image, &info);
+ lbx_img_getinfo(image, &info);
framebuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8,
info.width, info.height);
g_return_val_if_fail(framebuf, -1);
file = lbx_file_open(archive, index);
g_return_val_if_fail(file, NULL);
- image = lbximg_open(file, &lbx_arch_fops, close_image);
+ image = lbx_img_open(file, &lbx_arch_fops, close_image);
if (!image)
lbx_file_close(file);
return image;
img = load_lbx_image(lbx, index);
if (img) {
- lbximg_getpalette(img, palette_override);
- lbximg_close(img);
+ lbx_img_getpalette(img, palette_override);
+ lbx_img_close(img);
redraw_image();
}
}
f = lbx_file_open(lbx, index);
if (f) {
- if (lbximg_loadpalette(f, &lbx_arch_fops, palette_external))
+ if (lbx_img_loadpalette(f, &lbx_arch_fops, palette_external))
memset(palette_external, 0, sizeof palette_external);
lbx_file_close(f);
}
LBXimg *img;
if (image) {
- lbximg_close(image);
+ lbx_img_close(image);
image = NULL;
}
img = load_lbx_image(lbx, index);
if (img) {
- if (lbximg_getpalette(img, palette_internal) == -1) {
+ if (lbx_img_getpalette(img, palette_internal) == -1) {
puts("crap");
- lbximg_close(img);
+ lbx_img_close(img);
}
if (alloc_framebuffer(img) == -1) {
puts("crap");
- lbximg_close(img);
+ lbx_img_close(img);
}
}
struct lbx_imginfo info;
unsigned stride;
- lbximg_getinfo(image, &info);
+ lbx_img_getinfo(image, &info);
assert(info.width == gdk_pixbuf_get_width(pixbuf));
assert(info.height == gdk_pixbuf_get_height(pixbuf));
- framedata = lbximg_getframe(image, frame);
+ framedata = lbx_img_getframe(image, frame);
g_return_val_if_fail(framedata, -1);
- framemask = lbximg_getmask(image);
+ framemask = lbx_img_getmask(image);
outbuf = gdk_pixbuf_get_pixels(pixbuf);
stride = gdk_pixbuf_get_rowstride(pixbuf);
unsigned long offsets[];
};
-static struct lbx_image *lbximg_init(unsigned char hdr[static HDR_LEN])
+static struct lbx_image *lbx_img_init(unsigned char hdr[static HDR_LEN])
{
unsigned short nframes = unpack_16_le(hdr+6);
struct lbx_image *img;
return img;
}
-struct lbx_image *lbximg_open(void *f, const struct lbx_file_ops *fops,
- int (*destructor)(void *))
+struct lbx_image *lbx_img_open(void *f, const struct lbx_file_ops *fops,
+ int (*destructor)(void *))
{
unsigned char hdr_buf[HDR_LEN];
struct lbx_image *img;
return NULL;
}
- img = lbximg_init(hdr_buf);
+ img = lbx_img_init(hdr_buf);
if (!img)
return NULL;
return fclose((FILE *)f);
}
-struct lbx_image *lbximg_fopen(const char *file)
+struct lbx_image *lbx_img_fopen(const char *file)
{
struct lbx_pipe_state *p;
FILE *f;
return NULL;
if (fseek(f, 0, SEEK_CUR) == 0)
- return lbximg_open(f, &lbx_default_fops, file_close);
+ return lbx_img_open(f, &lbx_default_fops, file_close);
p = malloc(sizeof *p);
if (!p) {
}
*p = (struct lbx_pipe_state) { .f = f };
- return lbximg_open(p, &lbx_pipe_fops, pipe_close);
+ return lbx_img_open(p, &lbx_pipe_fops, pipe_close);
}
static int _lbx_drawrow(int first, struct lbx_image *img)
return img->framedata;
}
-unsigned char **lbximg_getframe(struct lbx_image *img, int frame)
+unsigned char **lbx_img_getframe(struct lbx_image *img, int frame)
{
if (frame >= img->frames || frame < 0) {
lbx_error_raise(LBX_ENOENT);
/* We must have previous frame decoded to continue. */
if (frame > img->currentframe + 1) {
- if (!lbximg_getframe(img, frame-1))
+ if (!lbx_img_getframe(img, frame-1))
return NULL;
}
}
}
int
-lbximg_loadpalette(void *f, const struct lbx_file_ops *fops,
- struct lbx_colour palette[static 256])
+lbx_img_loadpalette(void *f, const struct lbx_file_ops *fops,
+ struct lbx_colour palette[static 256])
{
unsigned char entry[4];
int i;
}
int
-lbximg_getpalette(struct lbx_image *img, struct lbx_colour palette[static 256])
+lbx_img_getpalette(struct lbx_image *img, struct lbx_colour palette[static 256])
{
unsigned char entry[4];
unsigned int i;
return -1;
}
-void lbximg_getinfo(struct lbx_image *img, struct lbx_imginfo *info)
+void lbx_img_getinfo(struct lbx_image *img, struct lbx_imginfo *info)
{
*info = (struct lbx_imginfo) {
.width = img->width,
}
}
-unsigned char **lbximg_getmask(struct lbx_image *img)
+unsigned char **lbx_img_getmask(struct lbx_image *img)
{
return img->mask;
}
-int lbximg_close(struct lbx_image *img)
+int lbx_img_close(struct lbx_image *img)
{
int rc = 0;
int palettesz, looping;
};
-LBXimg *lbximg_open(void *f, const struct lbx_file_ops *fops,
+LBXimg *lbx_img_open(void *f, const struct lbx_file_ops *fops,
int (*destructor)(void *));
-LBXimg *lbximg_fopen(const char *file);
-int lbximg_close(LBXimg *img);
+LBXimg *lbx_img_fopen(const char *file);
+int lbx_img_close(LBXimg *img);
-unsigned char **lbximg_getframe(LBXimg *img, int frame);
-unsigned char **lbximg_getmask(LBXimg *img);
+unsigned char **lbx_img_getframe(LBXimg *img, int frame);
+unsigned char **lbx_img_getmask(LBXimg *img);
-int lbximg_loadpalette(void *f, const struct lbx_file_ops *fops,
+int lbx_img_loadpalette(void *f, const struct lbx_file_ops *fops,
struct lbx_colour palette[static 256]);
-int lbximg_getpalette(LBXimg *img, struct lbx_colour palette[static 256]);
+int lbx_img_getpalette(LBXimg *img, struct lbx_colour palette[static 256]);
-void lbximg_getinfo(LBXimg *img, struct lbx_imginfo *info);
+void lbx_img_getinfo(LBXimg *img, struct lbx_imginfo *info);
#endif
static int loadoverride(FILE *f, struct lbx_colour palette[static 256])
{
- LBXimg *overimg = lbximg_open(f, &lbx_default_fops, NULL);
+ LBXimg *overimg = lbx_img_open(f, &lbx_default_fops, NULL);
struct lbx_imginfo info;
if (!overimg) {
errmsg("failed to open override image: %s\n", lbx_errmsg());
return -1;
}
- lbximg_getinfo(overimg, &info);
+ lbx_img_getinfo(overimg, &info);
if (!info.palettesz) {
errmsg("override image has no palette.\n", 0);
- lbximg_close(overimg);
+ lbx_img_close(overimg);
return -1;
}
- if (lbximg_getpalette(overimg, palette) == -1) {
+ if (lbx_img_getpalette(overimg, palette) == -1) {
errmsg("error reading override palette: %s\n", lbx_errmsg());
- lbximg_close(overimg);
+ lbx_img_close(overimg);
return -1;
}
- lbximg_close(overimg);
+ lbx_img_close(overimg);
return 0;
}
}
/* Read the external palette, if any. */
- if (palf && lbximg_loadpalette(palf, &lbx_default_fops, palette) != 0) {
+ if (palf && lbx_img_loadpalette(palf, &lbx_default_fops, palette) != 0) {
errmsg("error reading external palette: %s\n", lbx_errmsg());
return -1;
}
/* Read the embedded palette, if any. */
- if (info->palettesz && lbximg_getpalette(img, palette) == -1) {
+ if (info->palettesz && lbx_img_getpalette(img, palette) == -1) {
errmsg("error reading embedded palette: %s\n", lbx_errmsg());
return -1;
}
int extracted = 0;
unsigned int i;
- lbximg_getinfo(img, &info);
+ lbx_img_getinfo(img, &info);
framebits = calloc(1, info.nframes / CHAR_BIT + 1);
if (!framebits) {
if (!(framebits[i / CHAR_BIT] & (1 << (i % CHAR_BIT))))
continue;
- data = lbximg_getframe(img, i);
+ data = lbx_img_getframe(img, i);
if (!data) {
errmsg("error in frame %u: %s\n", i, lbx_errmsg());
continue;
}
- mask = lbximg_getmask(img);
+ mask = lbx_img_getmask(img);
if (!outpng(i, data, mask, info.width, info.height, palette)) {
extracted = 1;
}
if (file)
- img = lbximg_fopen(file);
+ img = lbx_img_fopen(file);
else
- img = lbximg_open(&stdin_handle, &lbx_pipe_fops, NULL);
+ img = lbx_img_open(&stdin_handle, &lbx_pipe_fops, NULL);
if (!img) {
errmsg("failed to open image: %s.\n", lbx_errmsg());
if (!file)
file = "stdin";
- lbximg_getinfo(img, &info);
+ lbx_img_getinfo(img, &info);
printf("%s is %ux%u LBX image, %u frame(s)%s%s\n",
file, info.width, info.height, info.nframes,
info.palettesz ? ", embedded palette" : "",
break;
}
- lbximg_close(img);
+ lbx_img_close(img);
return rc;
}