1.1 --- a/.hgignore	Sun Nov 01 00:09:12 2015 +0200
     1.2 +++ b/.hgignore	Sun Nov 01 00:36:56 2015 +0200
     1.3 @@ -3,6 +3,7 @@
     1.4  \.d$
     1.5  \.jpg$
     1.6  \.png$
     1.7 -^data/
     1.8 +^data
     1.9  ^bin/
    1.10  ^lib/
    1.11 +^halloween$

     2.1 --- a/Makefile	Sun Nov 01 00:09:12 2015 +0200
     2.2 +++ b/Makefile	Sun Nov 01 00:36:56 2015 +0200
     2.3 @@ -1,17 +1,39 @@
     2.4 -src = $(wildcard src/*.cc) $(wildcard src/audio/*.cc)
     2.5 -csrc = $(wildcard src/*.c) $(wildcard src/dsys/*.c)
     2.6 +src = $(wildcard src/*.cc) \
     2.7 +	  $(wildcard src/audio/*.cc) \
     2.8 +	  $(wildcard libs/vmath/*.cc)
     2.9 +csrc = $(wildcard src/*.c) \
    2.10 +	   $(wildcard src/dsys/*.c) \
    2.11 +	   $(wildcard libs/vmath/*.c) \
    2.12 +	   $(wildcard libs/imago/*.c) \
    2.13 +	   $(wildcard libs/libjpeg/*.c) \
    2.14 +	   $(wildcard libs/libpng/*.c) \
    2.15 +	   $(wildcard libs/zlib/*.c) \
    2.16 +	   $(wildcard libs/ogg/*.c) \
    2.17 +	   $(wildcard libs/vorbis/*.c)
    2.18 +
    2.19  obj = $(src:.cc=.o) $(csrc:.c=.o)
    2.20  dep = $(obj:.o=.d)
    2.21  bin = halloween
    2.22  
    2.23  opt = -O2
    2.24  
    2.25 -CFLAGS = -pedantic -Wall -g $(opt) -Isrc
    2.26 -CXXFLAGS = -pedantic -Wall -g $(opt) -Isrc
    2.27 -LDFLAGS = -lGL -lGLU -lglut -lGLEW -lvmath -limago -lm -ldl -lpthread \
    2.28 -		  -lvorbisfile -logg -lpthread -lopenal
    2.29 +inc = -Isrc -Ilibs/libjpeg -Ilibs/zlib -Ilibs/libpng -Ilibs/imago \
    2.30 +	  -Ilibs/ogg -Ilibs/vorbis
    2.31  
    2.32 -$(bin): $(obj)
    2.33 +CFLAGS = -pedantic -Wall -g $(opt) $(inc)
    2.34 +CXXFLAGS = -pedantic -Wall -g $(opt) $(inc)
    2.35 +LDFLAGS = $(libgl) $(libal) -lm -ldl -lpthread
    2.36 +
    2.37 +sys = $(shell uname -s)
    2.38 +ifeq ($(sys), Darwin)
    2.39 +	libgl = -lGL -lGLU -lglut -lGLEW
    2.40 +	libal = -lopenal
    2.41 +else
    2.42 +	libgl = -framework OpenGL -framework GLUT -lGLEW
    2.43 +	libal = -framework OpenAL
    2.44 +endif
    2.45 +
    2.46 +$(bin): $(obj) Makefile
    2.47  	$(CXX) -o $@ $(obj) $(LDFLAGS)
    2.48  
    2.49  -include $(dep)

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/libs/imago/conv.c	Sun Nov 01 00:36:56 2015 +0200
     3.3 @@ -0,0 +1,260 @@
     3.4 +/*
     3.5 +libimago - a multi-format image file input/output library.
     3.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     3.7 +
     3.8 +This program is free software: you can redistribute it and/or modify
     3.9 +it under the terms of the GNU Lesser General Public License as published
    3.10 +by the Free Software Foundation, either version 3 of the License, or
    3.11 +(at your option) any later version.
    3.12 +
    3.13 +This program is distributed in the hope that it will be useful,
    3.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    3.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    3.16 +GNU Lesser General Public License for more details.
    3.17 +
    3.18 +You should have received a copy of the GNU Lesser General Public License
    3.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    3.20 +*/
    3.21 +#include <string.h>
    3.22 +#include "imago2.h"
    3.23 +
    3.24 +/* pixel-format conversions are sub-optimal at the moment to avoid
    3.25 + * writing a lot of code. optimize at some point ?
    3.26 + */
    3.27 +
    3.28 +#define CLAMP(x, a, b)	((x) < (a) ? (a) : ((x) > (b) ? (b) : (x)))
    3.29 +
    3.30 +struct pixel {
    3.31 +	float r, g, b, a;
    3.32 +};
    3.33 +
    3.34 +static void unpack_grey8(struct pixel *unp, void *pptr, int count);
    3.35 +static void unpack_rgb24(struct pixel *unp, void *pptr, int count);
    3.36 +static void unpack_rgba32(struct pixel *unp, void *pptr, int count);
    3.37 +static void unpack_greyf(struct pixel *unp, void *pptr, int count);
    3.38 +static void unpack_rgbf(struct pixel *unp, void *pptr, int count);
    3.39 +static void unpack_rgbaf(struct pixel *unp, void *pptr, int count);
    3.40 +
    3.41 +static void pack_grey8(void *pptr, struct pixel *unp, int count);
    3.42 +static void pack_rgb24(void *pptr, struct pixel *unp, int count);
    3.43 +static void pack_rgba32(void *pptr, struct pixel *unp, int count);
    3.44 +static void pack_greyf(void *pptr, struct pixel *unp, int count);
    3.45 +static void pack_rgbf(void *pptr, struct pixel *unp, int count);
    3.46 +static void pack_rgbaf(void *pptr, struct pixel *unp, int count);
    3.47 +
    3.48 +/* XXX keep in sync with enum img_fmt at imago2.h */
    3.49 +static void (*unpack[])(struct pixel*, void*, int) = {
    3.50 +	unpack_grey8,
    3.51 +	unpack_rgb24,
    3.52 +	unpack_rgba32,
    3.53 +	unpack_greyf,
    3.54 +	unpack_rgbf,
    3.55 +	unpack_rgbaf
    3.56 +};
    3.57 +
    3.58 +/* XXX keep in sync with enum img_fmt at imago2.h */
    3.59 +static void (*pack[])(void*, struct pixel*, int) = {
    3.60 +	pack_grey8,
    3.61 +	pack_rgb24,
    3.62 +	pack_rgba32,
    3.63 +	pack_greyf,
    3.64 +	pack_rgbf,
    3.65 +	pack_rgbaf
    3.66 +};
    3.67 +
    3.68 +
    3.69 +int img_convert(struct img_pixmap *img, enum img_fmt tofmt)
    3.70 +{
    3.71 +	struct pixel pbuf[8];
    3.72 +	int bufsz = (img->width & 7) == 0 ? 8 : ((img->width & 3) == 0 ? 4 : 1);
    3.73 +	int i, num_pix = img->width * img->height;
    3.74 +	int num_iter = num_pix / bufsz;
    3.75 +	char *sptr, *dptr;
    3.76 +	struct img_pixmap nimg;
    3.77 +
    3.78 +	if(img->fmt == tofmt) {
    3.79 +		return 0;	/* nothing to do */
    3.80 +	}
    3.81 +
    3.82 +	img_init(&nimg);
    3.83 +	if(img_set_pixels(&nimg, img->width, img->height, tofmt, 0) == -1) {
    3.84 +		img_destroy(&nimg);
    3.85 +		return -1;
    3.86 +	}
    3.87 +
    3.88 +	sptr = img->pixels;
    3.89 +	dptr = nimg.pixels;
    3.90 +
    3.91 +	for(i=0; i<num_iter; i++) {
    3.92 +		unpack[img->fmt](pbuf, sptr, bufsz);
    3.93 +		pack[tofmt](dptr, pbuf, bufsz);
    3.94 +
    3.95 +		sptr += bufsz * img->pixelsz;
    3.96 +		dptr += bufsz * nimg.pixelsz;
    3.97 +	}
    3.98 +
    3.99 +	img_copy(img, &nimg);
   3.100 +	img_destroy(&nimg);
   3.101 +	return 0;
   3.102 +}
   3.103 +
   3.104 +/* the following functions *could* benefit from SIMD */
   3.105 +
   3.106 +static void unpack_grey8(struct pixel *unp, void *pptr, int count)
   3.107 +{
   3.108 +	int i;
   3.109 +	unsigned char *pix = pptr;
   3.110 +
   3.111 +	for(i=0; i<count; i++) {
   3.112 +		unp->r = unp->g = unp->b = (float)*pix++ / 255.0;
   3.113 +		unp->a = 1.0;
   3.114 +		unp++;
   3.115 +	}
   3.116 +}
   3.117 +
   3.118 +static void unpack_rgb24(struct pixel *unp, void *pptr, int count)
   3.119 +{
   3.120 +	int i;
   3.121 +	unsigned char *pix = pptr;
   3.122 +
   3.123 +	for(i=0; i<count; i++) {
   3.124 +		unp->r = (float)*pix++ / 255.0;
   3.125 +		unp->g = (float)*pix++ / 255.0;
   3.126 +		unp->b = (float)*pix++ / 255.0;
   3.127 +		unp->a = 1.0;
   3.128 +		unp++;
   3.129 +	}
   3.130 +}
   3.131 +
   3.132 +static void unpack_rgba32(struct pixel *unp, void *pptr, int count)
   3.133 +{
   3.134 +	int i;
   3.135 +	unsigned char *pix = pptr;
   3.136 +
   3.137 +	for(i=0; i<count; i++) {
   3.138 +		unp->r = (float)*pix++ / 255.0;
   3.139 +		unp->g = (float)*pix++ / 255.0;
   3.140 +		unp->b = (float)*pix++ / 255.0;
   3.141 +		unp->a = (float)*pix++ / 255.0;
   3.142 +		unp++;
   3.143 +	}
   3.144 +}
   3.145 +
   3.146 +static void unpack_greyf(struct pixel *unp, void *pptr, int count)
   3.147 +{
   3.148 +	int i;
   3.149 +	float *pix = pptr;
   3.150 +
   3.151 +	for(i=0; i<count; i++) {
   3.152 +		unp->r = unp->g = unp->b = *pix++;
   3.153 +		unp->a = 1.0;
   3.154 +		unp++;
   3.155 +	}
   3.156 +}
   3.157 +
   3.158 +static void unpack_rgbf(struct pixel *unp, void *pptr, int count)
   3.159 +{
   3.160 +	int i;
   3.161 +	float *pix = pptr;
   3.162 +
   3.163 +	for(i=0; i<count; i++) {
   3.164 +		unp->r = *pix++;
   3.165 +		unp->g = *pix++;
   3.166 +		unp->b = *pix++;
   3.167 +		unp->a = 1.0;
   3.168 +		unp++;
   3.169 +	}
   3.170 +}
   3.171 +
   3.172 +static void unpack_rgbaf(struct pixel *unp, void *pptr, int count)
   3.173 +{
   3.174 +	int i;
   3.175 +	float *pix = pptr;
   3.176 +
   3.177 +	for(i=0; i<count; i++) {
   3.178 +		unp->r = *pix++;
   3.179 +		unp->g = *pix++;
   3.180 +		unp->b = *pix++;
   3.181 +		unp->a = *pix++;
   3.182 +		unp++;
   3.183 +	}
   3.184 +}
   3.185 +
   3.186 +
   3.187 +static void pack_grey8(void *pptr, struct pixel *unp, int count)
   3.188 +{
   3.189 +	int i;
   3.190 +	unsigned char *pix = pptr;
   3.191 +
   3.192 +	for(i=0; i<count; i++) {
   3.193 +		int lum = (int)(255.0 * (unp->r + unp->g + unp->b) / 3.0);
   3.194 +		*pix++ = CLAMP(lum, 0, 255);
   3.195 +		unp++;
   3.196 +	}
   3.197 +}
   3.198 +
   3.199 +static void pack_rgb24(void *pptr, struct pixel *unp, int count)
   3.200 +{
   3.201 +	int i;
   3.202 +	unsigned char *pix = pptr;
   3.203 +
   3.204 +	for(i=0; i<count; i++) {
   3.205 +		int r = (int)(unp->r * 255.0);
   3.206 +		int g = (int)(unp->g * 255.0);
   3.207 +		int b = (int)(unp->b * 255.0);
   3.208 +
   3.209 +		*pix++ = CLAMP(r, 0, 255);
   3.210 +		*pix++ = CLAMP(g, 0, 255);
   3.211 +		*pix++ = CLAMP(b, 0, 255);
   3.212 +		unp++;
   3.213 +	}
   3.214 +}
   3.215 +
   3.216 +static void pack_rgba32(void *pptr, struct pixel *unp, int count)
   3.217 +{
   3.218 +	int i;
   3.219 +	unsigned char *pix = pptr;
   3.220 +
   3.221 +	for(i=0; i<count; i++) {
   3.222 +		int r = (int)(unp->r * 255.0);
   3.223 +		int g = (int)(unp->g * 255.0);
   3.224 +		int b = (int)(unp->b * 255.0);
   3.225 +		int a = (int)(unp->a * 255.0);
   3.226 +
   3.227 +		*pix++ = CLAMP(r, 0, 255);
   3.228 +		*pix++ = CLAMP(g, 0, 255);
   3.229 +		*pix++ = CLAMP(b, 0, 255);
   3.230 +		*pix++ = CLAMP(a, 0, 255);
   3.231 +		unp++;
   3.232 +	}
   3.233 +}
   3.234 +
   3.235 +static void pack_greyf(void *pptr, struct pixel *unp, int count)
   3.236 +{
   3.237 +	int i;
   3.238 +	float *pix = pptr;
   3.239 +
   3.240 +	for(i=0; i<count; i++) {
   3.241 +		*pix++ = (unp->r + unp->g + unp->b) / 3.0;
   3.242 +		unp++;
   3.243 +	}
   3.244 +}
   3.245 +
   3.246 +static void pack_rgbf(void *pptr, struct pixel *unp, int count)
   3.247 +{
   3.248 +	int i;
   3.249 +	float *pix = pptr;
   3.250 +
   3.251 +	for(i=0; i<count; i++) {
   3.252 +		*pix++ = unp->r;
   3.253 +		*pix++ = unp->g;
   3.254 +		*pix++ = unp->b;
   3.255 +		unp++;
   3.256 +	}
   3.257 +}
   3.258 +
   3.259 +static void pack_rgbaf(void *pptr, struct pixel *unp, int count)
   3.260 +{
   3.261 +	memcpy(pptr, unp, count * sizeof *unp);
   3.262 +}
   3.263 +

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/libs/imago/file_jpeg.c	Sun Nov 01 00:36:56 2015 +0200
     4.3 @@ -0,0 +1,294 @@
     4.4 +/*
     4.5 +libimago - a multi-format image file input/output library.
     4.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     4.7 +
     4.8 +This program is free software: you can redistribute it and/or modify
     4.9 +it under the terms of the GNU Lesser General Public License as published
    4.10 +by the Free Software Foundation, either version 3 of the License, or
    4.11 +(at your option) any later version.
    4.12 +
    4.13 +This program is distributed in the hope that it will be useful,
    4.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    4.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    4.16 +GNU Lesser General Public License for more details.
    4.17 +
    4.18 +You should have received a copy of the GNU Lesser General Public License
    4.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    4.20 +*/
    4.21 +
    4.22 +/* -- JPEG module -- */
    4.23 +
    4.24 +#include <stdio.h>
    4.25 +#include <stdlib.h>
    4.26 +#include <string.h>
    4.27 +
    4.28 +#ifdef WIN32
    4.29 +#include <windows.h>
    4.30 +#define HAVE_BOOLEAN
    4.31 +#endif
    4.32 +
    4.33 +#include <jpeglib.h>
    4.34 +#include "imago2.h"
    4.35 +#include "ftype_module.h"
    4.36 +
    4.37 +#define INPUT_BUF_SIZE	512
    4.38 +#define OUTPUT_BUF_SIZE	512
    4.39 +
    4.40 +/* data source manager: adapted from jdatasrc.c */
    4.41 +struct src_mgr {
    4.42 +	struct jpeg_source_mgr pub;
    4.43 +
    4.44 +	struct img_io *io;
    4.45 +	unsigned char buffer[INPUT_BUF_SIZE];
    4.46 +	int start_of_file;
    4.47 +};
    4.48 +
    4.49 +/* data destination manager: adapted from jdatadst.c */
    4.50 +struct dst_mgr {
    4.51 +	struct jpeg_destination_mgr pub;
    4.52 +
    4.53 +	struct img_io *io;
    4.54 +	unsigned char buffer[OUTPUT_BUF_SIZE];
    4.55 +};
    4.56 +
    4.57 +static int check(struct img_io *io);
    4.58 +static int readbuf(struct img_pixmap *img, struct img_io *io);
    4.59 +static int writebuf(struct img_pixmap *img, struct img_io *io);
    4.60 +
    4.61 +/* read source functions */
    4.62 +static void init_source(j_decompress_ptr jd);
    4.63 +static boolean fill_input_buffer(j_decompress_ptr jd);
    4.64 +static void skip_input_data(j_decompress_ptr jd, long num_bytes);
    4.65 +static void term_source(j_decompress_ptr jd);
    4.66 +
    4.67 +/* write destination functions */
    4.68 +static void init_destination(j_compress_ptr jc);
    4.69 +static boolean empty_output_buffer(j_compress_ptr jc);
    4.70 +static void term_destination(j_compress_ptr jc);
    4.71 +
    4.72 +int img_register_jpeg(void)
    4.73 +{
    4.74 +	static struct ftype_module mod = {".jpg", check, readbuf, writebuf};
    4.75 +	return img_register_module(&mod);
    4.76 +}
    4.77 +
    4.78 +
    4.79 +static int check(struct img_io *io)
    4.80 +{
    4.81 +	unsigned char sig[10];
    4.82 +
    4.83 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    4.84 +
    4.85 +	if(io->read(sig, 10, io->uptr) < 10) {
    4.86 +		io->seek(pos, SEEK_SET, io->uptr);
    4.87 +		return -1;
    4.88 +	}
    4.89 +
    4.90 +	if(memcmp(sig, "\xff\xd8\xff\xe0", 4) != 0 && memcmp(sig, "\xff\xd8\xff\xe1", 4) != 0
    4.91 +			&& memcmp(sig + 6, "JFIF", 4) != 0) {
    4.92 +		io->seek(pos, SEEK_SET, io->uptr);
    4.93 +		return -1;
    4.94 +	}
    4.95 +	io->seek(pos, SEEK_SET, io->uptr);
    4.96 +	return 0;
    4.97 +}
    4.98 +
    4.99 +static int readbuf(struct img_pixmap *img, struct img_io *io)
   4.100 +{
   4.101 +	int i, nlines = 0;
   4.102 +	struct jpeg_decompress_struct cinfo;
   4.103 +	struct jpeg_error_mgr jerr;
   4.104 +	struct src_mgr src;
   4.105 +	unsigned char **scanlines;
   4.106 +
   4.107 +	io->seek(0, SEEK_CUR, io->uptr);
   4.108 +
   4.109 +	cinfo.err = jpeg_std_error(&jerr);	/* XXX change... */
   4.110 +	jpeg_create_decompress(&cinfo);
   4.111 +
   4.112 +	src.pub.init_source = init_source;
   4.113 +	src.pub.fill_input_buffer = fill_input_buffer;
   4.114 +	src.pub.skip_input_data = skip_input_data;
   4.115 +	src.pub.resync_to_restart = jpeg_resync_to_restart;
   4.116 +	src.pub.term_source = term_source;
   4.117 +	src.pub.next_input_byte = 0;
   4.118 +	src.pub.bytes_in_buffer = 0;
   4.119 +	src.io = io;
   4.120 +	cinfo.src = (struct jpeg_source_mgr*)&src;
   4.121 +
   4.122 +	jpeg_read_header(&cinfo, 1);
   4.123 +	cinfo.out_color_space = JCS_RGB;
   4.124 +
   4.125 +	if(img_set_pixels(img, cinfo.image_width, cinfo.image_height, IMG_FMT_RGB24, 0) == -1) {
   4.126 +		jpeg_destroy_decompress(&cinfo);
   4.127 +		return -1;
   4.128 +	}
   4.129 +
   4.130 +	if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
   4.131 +		jpeg_destroy_decompress(&cinfo);
   4.132 +		return -1;
   4.133 +	}
   4.134 +	scanlines[0] = img->pixels;
   4.135 +	for(i=1; i<img->height; i++) {
   4.136 +		scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
   4.137 +	}
   4.138 +
   4.139 +	jpeg_start_decompress(&cinfo);
   4.140 +	while(nlines < img->height) {
   4.141 +		int res = jpeg_read_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
   4.142 +		nlines += res;
   4.143 +	}
   4.144 +	jpeg_finish_decompress(&cinfo);
   4.145 +	jpeg_destroy_decompress(&cinfo);
   4.146 +
   4.147 +	free(scanlines);
   4.148 +	return 0;
   4.149 +}
   4.150 +
   4.151 +static int writebuf(struct img_pixmap *img, struct img_io *io)
   4.152 +{
   4.153 +	int i, nlines = 0;
   4.154 +	struct jpeg_compress_struct cinfo;
   4.155 +	struct jpeg_error_mgr jerr;
   4.156 +	struct dst_mgr dest;
   4.157 +	struct img_pixmap tmpimg;
   4.158 +	unsigned char **scanlines;
   4.159 +
   4.160 +	img_init(&tmpimg);
   4.161 +
   4.162 +	if(img->fmt != IMG_FMT_RGB24) {
   4.163 +		if(img_copy(&tmpimg, img) == -1) {
   4.164 +			return -1;
   4.165 +		}
   4.166 +		if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
   4.167 +			img_destroy(&tmpimg);
   4.168 +			return -1;
   4.169 +		}
   4.170 +		img = &tmpimg;
   4.171 +	}
   4.172 +
   4.173 +	if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
   4.174 +		img_destroy(&tmpimg);
   4.175 +		return -1;
   4.176 +	}
   4.177 +	scanlines[0] = img->pixels;
   4.178 +	for(i=1; i<img->height; i++) {
   4.179 +		scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
   4.180 +	}
   4.181 +
   4.182 +	cinfo.err = jpeg_std_error(&jerr);	/* XXX */
   4.183 +	jpeg_create_compress(&cinfo);
   4.184 +
   4.185 +	dest.pub.init_destination = init_destination;
   4.186 +	dest.pub.empty_output_buffer = empty_output_buffer;
   4.187 +	dest.pub.term_destination = term_destination;
   4.188 +	dest.io = io;
   4.189 +	cinfo.dest = (struct jpeg_destination_mgr*)&dest;
   4.190 +
   4.191 +	cinfo.image_width = img->width;
   4.192 +	cinfo.image_height = img->height;
   4.193 +	cinfo.input_components = 3;
   4.194 +	cinfo.in_color_space = JCS_RGB;
   4.195 +
   4.196 +	jpeg_set_defaults(&cinfo);
   4.197 +
   4.198 +	jpeg_start_compress(&cinfo, 1);
   4.199 +	while(nlines < img->height) {
   4.200 +		int res = jpeg_write_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
   4.201 +		nlines += res;
   4.202 +	}
   4.203 +	jpeg_finish_compress(&cinfo);
   4.204 +	jpeg_destroy_compress(&cinfo);
   4.205 +
   4.206 +	free(scanlines);
   4.207 +	img_destroy(&tmpimg);
   4.208 +	return 0;
   4.209 +}
   4.210 +
   4.211 +/* -- read source functions --
   4.212 + * the following functions are adapted from jdatasrc.c in jpeglib
   4.213 + */
   4.214 +static void init_source(j_decompress_ptr jd)
   4.215 +{
   4.216 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   4.217 +	src->start_of_file = 1;
   4.218 +}
   4.219 +
   4.220 +static boolean fill_input_buffer(j_decompress_ptr jd)
   4.221 +{
   4.222 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   4.223 +	size_t nbytes;
   4.224 +
   4.225 +	nbytes = src->io->read(src->buffer, INPUT_BUF_SIZE, src->io->uptr);
   4.226 +
   4.227 +	if(nbytes <= 0) {
   4.228 +		if(src->start_of_file) {
   4.229 +			return 0;
   4.230 +		}
   4.231 +		/* insert a fake EOI marker */
   4.232 +		src->buffer[0] = 0xff;
   4.233 +		src->buffer[1] = JPEG_EOI;
   4.234 +		nbytes = 2;
   4.235 +	}
   4.236 +
   4.237 +	src->pub.next_input_byte = src->buffer;
   4.238 +	src->pub.bytes_in_buffer = nbytes;
   4.239 +	src->start_of_file = 0;
   4.240 +	return 1;
   4.241 +}
   4.242 +
   4.243 +static void skip_input_data(j_decompress_ptr jd, long num_bytes)
   4.244 +{
   4.245 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   4.246 +
   4.247 +	if(num_bytes > 0) {
   4.248 +		while(num_bytes > (long)src->pub.bytes_in_buffer) {
   4.249 +			num_bytes -= (long)src->pub.bytes_in_buffer;
   4.250 +			fill_input_buffer(jd);
   4.251 +		}
   4.252 +		src->pub.next_input_byte += (size_t)num_bytes;
   4.253 +		src->pub.bytes_in_buffer -= (size_t)num_bytes;
   4.254 +	}
   4.255 +}
   4.256 +
   4.257 +static void term_source(j_decompress_ptr jd)
   4.258 +{
   4.259 +	/* nothing to see here, move along */
   4.260 +}
   4.261 +
   4.262 +
   4.263 +/* -- write destination functions --
   4.264 + * the following functions are adapted from jdatadst.c in jpeglib
   4.265 + */
   4.266 +static void init_destination(j_compress_ptr jc)
   4.267 +{
   4.268 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   4.269 +
   4.270 +	dest->pub.next_output_byte = dest->buffer;
   4.271 +	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
   4.272 +}
   4.273 +
   4.274 +static boolean empty_output_buffer(j_compress_ptr jc)
   4.275 +{
   4.276 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   4.277 +
   4.278 +	if(dest->io->write(dest->buffer, OUTPUT_BUF_SIZE, dest->io->uptr) != OUTPUT_BUF_SIZE) {
   4.279 +		return 0;
   4.280 +	}
   4.281 +
   4.282 +	dest->pub.next_output_byte = dest->buffer;
   4.283 +	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
   4.284 +	return 1;
   4.285 +}
   4.286 +
   4.287 +static void term_destination(j_compress_ptr jc)
   4.288 +{
   4.289 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   4.290 +	size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
   4.291 +
   4.292 +	/* write any remaining data in the buffer */
   4.293 +	if(datacount > 0) {
   4.294 +		dest->io->write(dest->buffer, datacount, dest->io->uptr);
   4.295 +	}
   4.296 +	/* XXX flush? ... */
   4.297 +}

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/libs/imago/file_png.c	Sun Nov 01 00:36:56 2015 +0200
     5.3 @@ -0,0 +1,261 @@
     5.4 +/*
     5.5 +libimago - a multi-format image file input/output library.
     5.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     5.7 +
     5.8 +This program is free software: you can redistribute it and/or modify
     5.9 +it under the terms of the GNU Lesser General Public License as published
    5.10 +by the Free Software Foundation, either version 3 of the License, or
    5.11 +(at your option) any later version.
    5.12 +
    5.13 +This program is distributed in the hope that it will be useful,
    5.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    5.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    5.16 +GNU Lesser General Public License for more details.
    5.17 +
    5.18 +You should have received a copy of the GNU Lesser General Public License
    5.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    5.20 +*/
    5.21 +
    5.22 +/* -- PNG module -- */
    5.23 +
    5.24 +#include <stdlib.h>
    5.25 +#include "png.h"
    5.26 +#include "imago2.h"
    5.27 +#include "ftype_module.h"
    5.28 +
    5.29 +static int check_file(struct img_io *io);
    5.30 +static int read_file(struct img_pixmap *img, struct img_io *io);
    5.31 +static int write_file(struct img_pixmap *img, struct img_io *io);
    5.32 +
    5.33 +static void read_func(png_struct *png, unsigned char *data, size_t len);
    5.34 +static void write_func(png_struct *png, unsigned char *data, size_t len);
    5.35 +static void flush_func(png_struct *png);
    5.36 +
    5.37 +static int png_type_to_fmt(int color_type, int channel_bits);
    5.38 +static int fmt_to_png_type(enum img_fmt fmt);
    5.39 +
    5.40 +
    5.41 +int img_register_png(void)
    5.42 +{
    5.43 +	static struct ftype_module mod = {".png", check_file, read_file, write_file};
    5.44 +	return img_register_module(&mod);
    5.45 +}
    5.46 +
    5.47 +static int check_file(struct img_io *io)
    5.48 +{
    5.49 +	unsigned char sig[8];
    5.50 +	int res;
    5.51 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    5.52 +
    5.53 +	if(io->read(sig, 8, io->uptr) < 8) {
    5.54 +		io->seek(pos, SEEK_SET, io->uptr);
    5.55 +		return -1;
    5.56 +	}
    5.57 +
    5.58 +	res = png_sig_cmp(sig, 0, 8) == 0 ? 0 : -1;
    5.59 +	io->seek(pos, SEEK_SET, io->uptr);
    5.60 +	return res;
    5.61 +}
    5.62 +
    5.63 +static int read_file(struct img_pixmap *img, struct img_io *io)
    5.64 +{
    5.65 +	png_struct *png;
    5.66 +	png_info *info;
    5.67 +	int channel_bits, color_type, ilace_type, compression, filtering, fmt;
    5.68 +	png_uint_32 xsz, ysz;
    5.69 +
    5.70 +	if(!(png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
    5.71 +		return -1;
    5.72 +	}
    5.73 +
    5.74 +	if(!(info = png_create_info_struct(png))) {
    5.75 +		png_destroy_read_struct(&png, 0, 0);
    5.76 +		return -1;
    5.77 +	}
    5.78 +
    5.79 +	if(setjmp(png_jmpbuf(png))) {
    5.80 +		png_destroy_read_struct(&png, &info, 0);
    5.81 +		return -1;
    5.82 +	}
    5.83 +
    5.84 +	png_set_read_fn(png, io, read_func);
    5.85 +	png_set_sig_bytes(png, 0);
    5.86 +	png_read_png(png, info, 0, 0);
    5.87 +
    5.88 +	png_get_IHDR(png, info, &xsz, &ysz, &channel_bits, &color_type, &ilace_type,
    5.89 +			&compression, &filtering);
    5.90 +	if((fmt = png_type_to_fmt(color_type, channel_bits)) == -1) {
    5.91 +		png_destroy_read_struct(&png, &info, 0);
    5.92 +		return -1;
    5.93 +	}
    5.94 +
    5.95 +	if(img_set_pixels(img, xsz, ysz, fmt, 0) == -1) {
    5.96 +		png_destroy_read_struct(&png, &info, 0);
    5.97 +		return -1;
    5.98 +	}
    5.99 +
   5.100 +
   5.101 +	if(channel_bits == 8) {
   5.102 +		unsigned int i;
   5.103 +		unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
   5.104 +		unsigned char *dest = img->pixels;
   5.105 +
   5.106 +		for(i=0; i<ysz; i++) {
   5.107 +			memcpy(dest, lineptr[i], xsz * img->pixelsz);
   5.108 +			dest += xsz * img->pixelsz;
   5.109 +		}
   5.110 +	} else {
   5.111 +		unsigned int i, j, num_elem;
   5.112 +		unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
   5.113 +		float *dest = img->pixels;
   5.114 +
   5.115 +		num_elem = img->pixelsz / sizeof(float);
   5.116 +		for(i=0; i<ysz; i++) {
   5.117 +			for(j=0; j<xsz * num_elem; j++) {
   5.118 +				unsigned short val = (lineptr[i][j * 2] << 8) | lineptr[i][j * 2 + 1];
   5.119 +				*dest++ = (float)val / 65535.0;
   5.120 +			}
   5.121 +		}
   5.122 +	}
   5.123 +
   5.124 +
   5.125 +	png_destroy_read_struct(&png, &info, 0);
   5.126 +	return 0;
   5.127 +}
   5.128 +
   5.129 +
   5.130 +static int write_file(struct img_pixmap *img, struct img_io *io)
   5.131 +{
   5.132 +	png_struct *png;
   5.133 +	png_info *info;
   5.134 +	png_text txt;
   5.135 +	struct img_pixmap tmpimg;
   5.136 +	unsigned char **rows;
   5.137 +	unsigned char *pixptr;
   5.138 +	int i, coltype;
   5.139 +
   5.140 +	img_init(&tmpimg);
   5.141 +
   5.142 +	if(!(png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
   5.143 +		return -1;
   5.144 +	}
   5.145 +	if(!(info = png_create_info_struct(png))) {
   5.146 +		png_destroy_write_struct(&png, 0);
   5.147 +		return -1;
   5.148 +	}
   5.149 +
   5.150 +	/* if the input image is floating-point, we need to convert it to integer */
   5.151 +	if(img_is_float(img)) {
   5.152 +		if(img_copy(&tmpimg, img) == -1) {
   5.153 +			return -1;
   5.154 +		}
   5.155 +		if(img_to_integer(&tmpimg) == -1) {
   5.156 +			img_destroy(&tmpimg);
   5.157 +			return -1;
   5.158 +		}
   5.159 +		img = &tmpimg;
   5.160 +	}
   5.161 +
   5.162 +	txt.compression = PNG_TEXT_COMPRESSION_NONE;
   5.163 +	txt.key = "Software";
   5.164 +	txt.text = "libimago2";
   5.165 +	txt.text_length = 0;
   5.166 +
   5.167 +	if(setjmp(png_jmpbuf(png))) {
   5.168 +		png_destroy_write_struct(&png, &info);
   5.169 +		img_destroy(&tmpimg);
   5.170 +		return -1;
   5.171 +	}
   5.172 +	png_set_write_fn(png, io, write_func, flush_func);
   5.173 +
   5.174 +	coltype = fmt_to_png_type(img->fmt);
   5.175 +	png_set_IHDR(png, info, img->width, img->height, 8, coltype, PNG_INTERLACE_NONE,
   5.176 +			PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
   5.177 +	png_set_text(png, info, &txt, 1);
   5.178 +
   5.179 +	if(!(rows = malloc(img->height * sizeof *rows))) {
   5.180 +		png_destroy_write_struct(&png, &info);
   5.181 +		img_destroy(&tmpimg);
   5.182 +		return -1;
   5.183 +	}
   5.184 +
   5.185 +	pixptr = img->pixels;
   5.186 +	for(i=0; i<img->height; i++) {
   5.187 +		rows[i] = pixptr;
   5.188 +		pixptr += img->width * img->pixelsz;
   5.189 +	}
   5.190 +	png_set_rows(png, info, rows);
   5.191 +
   5.192 +	png_write_png(png, info, 0, 0);
   5.193 +	png_write_end(png, info);
   5.194 +	png_destroy_write_struct(&png, &info);
   5.195 +
   5.196 +	free(rows);
   5.197 +
   5.198 +	img_destroy(&tmpimg);
   5.199 +	return 0;
   5.200 +}
   5.201 +
   5.202 +static void read_func(png_struct *png, unsigned char *data, size_t len)
   5.203 +{
   5.204 +	struct img_io *io = (struct img_io*)png_get_io_ptr(png);
   5.205 +
   5.206 +	if(io->read(data, len, io->uptr) == -1) {
   5.207 +		longjmp(png_jmpbuf(png), 1);
   5.208 +	}
   5.209 +}
   5.210 +
   5.211 +static void write_func(png_struct *png, unsigned char *data, size_t len)
   5.212 +{
   5.213 +	struct img_io *io = (struct img_io*)png_get_io_ptr(png);
   5.214 +
   5.215 +	if(io->write(data, len, io->uptr) == -1) {
   5.216 +		longjmp(png_jmpbuf(png), 1);
   5.217 +	}
   5.218 +}
   5.219 +
   5.220 +static void flush_func(png_struct *png)
   5.221 +{
   5.222 +	/* XXX does it matter that we can't flush? */
   5.223 +}
   5.224 +
   5.225 +static int png_type_to_fmt(int color_type, int channel_bits)
   5.226 +{
   5.227 +	/* only 8 and 16 bits per channel ar supported at the moment */
   5.228 +	if(channel_bits != 8 && channel_bits != 16) {
   5.229 +		return -1;
   5.230 +	}
   5.231 +
   5.232 +	switch(color_type) {
   5.233 +	case PNG_COLOR_TYPE_RGB:
   5.234 +		return channel_bits == 16 ? IMG_FMT_RGBF : IMG_FMT_RGB24;
   5.235 +
   5.236 +	case PNG_COLOR_TYPE_RGB_ALPHA:
   5.237 +		return channel_bits == 16 ? IMG_FMT_RGBAF : IMG_FMT_RGBA32;
   5.238 +
   5.239 +	case PNG_COLOR_TYPE_GRAY:
   5.240 +		return channel_bits == 16 ? IMG_FMT_GREYF : IMG_FMT_GREY8;
   5.241 +
   5.242 +	default:
   5.243 +		break;
   5.244 +	}
   5.245 +	return -1;
   5.246 +}
   5.247 +
   5.248 +static int fmt_to_png_type(enum img_fmt fmt)
   5.249 +{
   5.250 +	switch(fmt) {
   5.251 +	case IMG_FMT_GREY8:
   5.252 +		return PNG_COLOR_TYPE_GRAY;
   5.253 +
   5.254 +	case IMG_FMT_RGB24:
   5.255 +		return PNG_COLOR_TYPE_RGB;
   5.256 +
   5.257 +	case IMG_FMT_RGBA32:
   5.258 +		return PNG_COLOR_TYPE_RGBA;
   5.259 +
   5.260 +	default:
   5.261 +		break;
   5.262 +	}
   5.263 +	return -1;
   5.264 +}

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/libs/imago/file_ppm.c	Sun Nov 01 00:36:56 2015 +0200
     6.3 @@ -0,0 +1,155 @@
     6.4 +/*
     6.5 +libimago - a multi-format image file input/output library.
     6.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     6.7 +
     6.8 +This program is free software: you can redistribute it and/or modify
     6.9 +it under the terms of the GNU Lesser General Public License as published
    6.10 +by the Free Software Foundation, either version 3 of the License, or
    6.11 +(at your option) any later version.
    6.12 +
    6.13 +This program is distributed in the hope that it will be useful,
    6.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    6.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    6.16 +GNU Lesser General Public License for more details.
    6.17 +
    6.18 +You should have received a copy of the GNU Lesser General Public License
    6.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    6.20 +*/
    6.21 +
    6.22 +/* -- Portable Pixmap (PPM) module -- */
    6.23 +
    6.24 +#include <string.h>
    6.25 +#include "imago2.h"
    6.26 +#include "ftype_module.h"
    6.27 +
    6.28 +static int check(struct img_io *io);
    6.29 +static int readbuf(struct img_pixmap *img, struct img_io *io);
    6.30 +/*static int writebuf(struct img_pixmap *img, struct img_io *io);*/
    6.31 +
    6.32 +int img_register_ppm(void)
    6.33 +{
    6.34 +	static struct ftype_module mod = {".ppm", check, readbuf, 0};
    6.35 +	return img_register_module(&mod);
    6.36 +}
    6.37 +
    6.38 +
    6.39 +static int check(struct img_io *io)
    6.40 +{
    6.41 +	char id[2];
    6.42 +	int res = -1;
    6.43 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    6.44 +
    6.45 +	if(io->read(id, 2, io->uptr) < 2) {
    6.46 +		io->seek(pos, SEEK_SET, io->uptr);
    6.47 +		return -1;
    6.48 +	}
    6.49 +
    6.50 +	if(id[0] == 'P' && (id[1] == '6' || id[1] == '3')) {
    6.51 +		res = 0;
    6.52 +	}
    6.53 +	io->seek(pos, SEEK_SET, io->uptr);
    6.54 +	return res;
    6.55 +}
    6.56 +
    6.57 +static int iofgetc(struct img_io *io)
    6.58 +{
    6.59 +	char c;
    6.60 +	return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
    6.61 +}
    6.62 +
    6.63 +static char *iofgets(char *buf, int size, struct img_io *io)
    6.64 +{
    6.65 +	int c;
    6.66 +	char *ptr = buf;
    6.67 +
    6.68 +	while(--size > 0 && (c = iofgetc(io)) != -1) {
    6.69 +		*ptr++ = c;
    6.70 +		if(c == '\n') break;
    6.71 +	}
    6.72 +	*ptr = 0;
    6.73 +
    6.74 +	return ptr == buf ? 0 : buf;
    6.75 +}
    6.76 +
    6.77 +/* TODO: implement P3 reading */
    6.78 +static int readbuf(struct img_pixmap *img, struct img_io *io)
    6.79 +{
    6.80 +	char buf[256];
    6.81 +	int xsz = 0, ysz = 0, maxval = 0, got_hdrlines = 1;
    6.82 +
    6.83 +	if(!iofgets(buf, sizeof buf, io)) {
    6.84 +		return -1;
    6.85 +	}
    6.86 +	if(!(buf[0] == 'P' && (buf[1] == '6' || buf[1] == '3'))) {
    6.87 +		return -1;
    6.88 +	}
    6.89 +
    6.90 +	while(got_hdrlines < 3 && iofgets(buf, sizeof buf, io)) {
    6.91 +		if(buf[0] == '#') continue;
    6.92 +
    6.93 +		switch(got_hdrlines) {
    6.94 +		case 1:
    6.95 +			if(sscanf(buf, "%d %d\n", &xsz, &ysz) < 2) {
    6.96 +				return -1;
    6.97 +			}
    6.98 +			break;
    6.99 +
   6.100 +		case 2:
   6.101 +			if(sscanf(buf, "%d\n", &maxval) < 1) {
   6.102 +				return -1;
   6.103 +			}
   6.104 +		default:
   6.105 +			break;
   6.106 +		}
   6.107 +		got_hdrlines++;
   6.108 +	}
   6.109 +
   6.110 +	if(xsz < 1 || ysz < 1 || maxval != 255) {
   6.111 +		return -1;
   6.112 +	}
   6.113 +
   6.114 +	if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGB24, 0) == -1) {
   6.115 +		return -1;
   6.116 +	}
   6.117 +
   6.118 +	if((int)io->read(img->pixels, xsz * ysz * 3, io->uptr) < xsz * ysz * 3) {
   6.119 +		return -1;
   6.120 +	}
   6.121 +	return 0;
   6.122 +}
   6.123 +
   6.124 +/*
   6.125 +static int writebuf(struct img_pixmap *img, struct img_io *io)
   6.126 +{
   6.127 +	int sz;
   6.128 +	char buf[256];
   6.129 +	struct img_pixmap tmpimg;
   6.130 +
   6.131 +	img_init(&tmpimg);
   6.132 +
   6.133 +	if(img->fmt != IMG_FMT_RGB24) {
   6.134 +		if(img_copy(&tmpimg, img) == -1) {
   6.135 +			return -1;
   6.136 +		}
   6.137 +		if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
   6.138 +			return -1;
   6.139 +		}
   6.140 +		img = &tmpimg;
   6.141 +	}
   6.142 +
   6.143 +	sprintf(buf, "P6\n#written by libimago2\n%d %d\n255\n", img->width, img->height);
   6.144 +	if(io->write(buf, strlen(buf), io->uptr) < strlen(buf)) {
   6.145 +		img_destroy(&tmpimg);
   6.146 +		return -1;
   6.147 +	}
   6.148 +
   6.149 +	sz = img->width * img->height * 3;
   6.150 +	if((int)io->write(img->pixels, sz, io->uptr) < sz) {
   6.151 +		img_destroy(&tmpimg);
   6.152 +		return -1;
   6.153 +	}
   6.154 +
   6.155 +	img_destroy(&tmpimg);
   6.156 +	return 0;
   6.157 +}
   6.158 +*/

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/libs/imago/file_rgbe.c	Sun Nov 01 00:36:56 2015 +0200
     7.3 @@ -0,0 +1,501 @@
     7.4 +/* This file contains code to read and write four byte rgbe file format
     7.5 + * developed by Greg Ward.  It handles the conversions between rgbe and
     7.6 + * pixels consisting of floats.  The data is assumed to be an array of floats.
     7.7 + * By default there are three floats per pixel in the order red, green, blue.
     7.8 + * (RGBE_DATA_??? values control this.)
     7.9 + *
    7.10 + * written by Bruce Walter  (bjw@graphics.cornell.edu)  5/26/95
    7.11 + * based on code written by Greg Ward
    7.12 + * minor modifications by John Tsiombikas (nuclear@member.fsf.org) apr.9 2007
    7.13 + */
    7.14 +
    7.15 +#include <stdio.h>
    7.16 +#include <stdlib.h>
    7.17 +#include <string.h>
    7.18 +#include <math.h>
    7.19 +#include <ctype.h>
    7.20 +#include <errno.h>
    7.21 +#include "imago2.h"
    7.22 +#include "ftype_module.h"
    7.23 +
    7.24 +
    7.25 +typedef struct {
    7.26 +	int valid;				/* indicate which fields are valid */
    7.27 +	char programtype[16];	/* listed at beginning of file to identify it
    7.28 +							 * after "#?".  defaults to "RGBE" */
    7.29 +	float gamma;			/* image has already been gamma corrected with
    7.30 +							 * given gamma.  defaults to 1.0 (no correction) */
    7.31 +	float exposure;			/* a value of 1.0 in an image corresponds to
    7.32 +							 * <exposure> watts/steradian/m^2.
    7.33 +							 * defaults to 1.0 */
    7.34 +} rgbe_header_info;
    7.35 +
    7.36 +
    7.37 +static int check(struct img_io *io);
    7.38 +static int readbuf(struct img_pixmap *img, struct img_io *io);
    7.39 +static int writebuf(struct img_pixmap *img, struct img_io *io);
    7.40 +
    7.41 +static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info);
    7.42 +static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines);
    7.43 +
    7.44 +
    7.45 +int img_register_rgbe(void)
    7.46 +{
    7.47 +	static struct ftype_module mod = {".rgbe", check, readbuf, writebuf};
    7.48 +	return img_register_module(&mod);
    7.49 +}
    7.50 +
    7.51 +
    7.52 +static int check(struct img_io *io)
    7.53 +{
    7.54 +	int xsz, ysz, res;
    7.55 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    7.56 +
    7.57 +	rgbe_header_info hdr;
    7.58 +	res = rgbe_read_header(io, &xsz, &ysz, &hdr);
    7.59 +
    7.60 +	io->seek(pos, SEEK_SET, io->uptr);
    7.61 +	return res;
    7.62 +}
    7.63 +
    7.64 +static int readbuf(struct img_pixmap *img, struct img_io *io)
    7.65 +{
    7.66 +	int xsz, ysz;
    7.67 +	rgbe_header_info hdr;
    7.68 +
    7.69 +	if(rgbe_read_header(io, &xsz, &ysz, &hdr) == -1) {
    7.70 +		return -1;
    7.71 +	}
    7.72 +
    7.73 +	if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGBF, 0) == -1) {
    7.74 +		return -1;
    7.75 +	}
    7.76 +	if(rgbe_read_pixels_rle(io, img->pixels, xsz, ysz) == -1) {
    7.77 +		return -1;
    7.78 +	}
    7.79 +	return 0;
    7.80 +}
    7.81 +
    7.82 +static int writebuf(struct img_pixmap *img, struct img_io *io)
    7.83 +{
    7.84 +	return -1;	/* TODO */
    7.85 +}
    7.86 +
    7.87 +
    7.88 +static int iofgetc(struct img_io *io)
    7.89 +{
    7.90 +	char c;
    7.91 +	return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
    7.92 +}
    7.93 +
    7.94 +static char *iofgets(char *buf, int size, struct img_io *io)
    7.95 +{
    7.96 +	int c;
    7.97 +	char *ptr = buf;
    7.98 +
    7.99 +	while(--size > 0 && (c = iofgetc(io)) != -1) {
   7.100 +		*ptr++ = c;
   7.101 +		if(c == '\n') break;
   7.102 +	}
   7.103 +	*ptr = 0;
   7.104 +
   7.105 +	return ptr == buf ? 0 : buf;
   7.106 +}
   7.107 +
   7.108 +
   7.109 +/* flags indicating which fields in an rgbe_header_info are valid */
   7.110 +#define RGBE_VALID_PROGRAMTYPE 0x01
   7.111 +#define RGBE_VALID_GAMMA       0x02
   7.112 +#define RGBE_VALID_EXPOSURE    0x04
   7.113 +
   7.114 +/* return codes for rgbe routines */
   7.115 +#define RGBE_RETURN_SUCCESS 0
   7.116 +#define RGBE_RETURN_FAILURE -1
   7.117 +
   7.118 +
   7.119 +#if defined(__cplusplus) || defined(GNUC) || __STDC_VERSION >= 199901L
   7.120 +#define INLINE inline
   7.121 +#else
   7.122 +#define INLINE
   7.123 +#endif
   7.124 +
   7.125 +/* offsets to red, green, and blue components in a data (float) pixel */
   7.126 +#define RGBE_DATA_RED	0
   7.127 +#define RGBE_DATA_GREEN  1
   7.128 +#define RGBE_DATA_BLUE   2
   7.129 +
   7.130 +/* number of floats per pixel */
   7.131 +#define RGBE_DATA_SIZE   3
   7.132 +
   7.133 +enum rgbe_error_codes {
   7.134 +	rgbe_read_error,
   7.135 +	rgbe_write_error,
   7.136 +	rgbe_format_error,
   7.137 +	rgbe_memory_error
   7.138 +};
   7.139 +
   7.140 +
   7.141 +/* default error routine.  change this to change error handling */
   7.142 +static int rgbe_error(int rgbe_error_code, char *msg)
   7.143 +{
   7.144 +	switch (rgbe_error_code) {
   7.145 +	case rgbe_read_error:
   7.146 +		fprintf(stderr, "RGBE read error: %s\n", strerror(errno));
   7.147 +		break;
   7.148 +
   7.149 +	case rgbe_write_error:
   7.150 +		fprintf(stderr, "RGBE write error: %s\n", strerror(errno));
   7.151 +		break;
   7.152 +
   7.153 +	case rgbe_format_error:
   7.154 +		fprintf(stderr, "RGBE bad file format: %s\n", msg);
   7.155 +		break;
   7.156 +
   7.157 +	default:
   7.158 +	case rgbe_memory_error:
   7.159 +		fprintf(stderr, "RGBE error: %s\n", msg);
   7.160 +	}
   7.161 +	return RGBE_RETURN_FAILURE;
   7.162 +}
   7.163 +
   7.164 +/* standard conversion from float pixels to rgbe pixels */
   7.165 +/*static INLINE void float2rgbe(unsigned char rgbe[4], float red, float green, float blue)
   7.166 +{
   7.167 +	float v;
   7.168 +	int e;
   7.169 +
   7.170 +	v = red;
   7.171 +	if(green > v)
   7.172 +		v = green;
   7.173 +	if(blue > v)
   7.174 +		v = blue;
   7.175 +	if(v < 1e-32) {
   7.176 +		rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
   7.177 +	} else {
   7.178 +		v = frexp(v, &e) * 256.0 / v;
   7.179 +		rgbe[0] = (unsigned char)(red * v);
   7.180 +		rgbe[1] = (unsigned char)(green * v);
   7.181 +		rgbe[2] = (unsigned char)(blue * v);
   7.182 +		rgbe[3] = (unsigned char)(e + 128);
   7.183 +	}
   7.184 +}*/
   7.185 +
   7.186 +/* standard conversion from rgbe to float pixels */
   7.187 +/* note: Ward uses ldexp(col+0.5,exp-(128+8)). However we wanted pixels */
   7.188 +/*       in the range [0,1] to map back into the range [0,1]. */
   7.189 +static INLINE void rgbe2float(float *red, float *green, float *blue, unsigned char rgbe[4])
   7.190 +{
   7.191 +	float f;
   7.192 +
   7.193 +	if(rgbe[3]) {				/*nonzero pixel */
   7.194 +		f = ldexp(1.0, rgbe[3] - (int)(128 + 8));
   7.195 +		*red = rgbe[0] * f;
   7.196 +		*green = rgbe[1] * f;
   7.197 +		*blue = rgbe[2] * f;
   7.198 +	} else
   7.199 +		*red = *green = *blue = 0.0;
   7.200 +}
   7.201 +
   7.202 +#if 0
   7.203 +/* default minimal header. modify if you want more information in header */
   7.204 +static int rgbe_write_header(FILE * fp, int width, int height, rgbe_header_info * info)
   7.205 +{
   7.206 +	char *programtype = "RGBE";
   7.207 +
   7.208 +	if(info && (info->valid & RGBE_VALID_PROGRAMTYPE))
   7.209 +		programtype = info->programtype;
   7.210 +	if(fprintf(fp, "#?%s\n", programtype) < 0)
   7.211 +		return rgbe_error(rgbe_write_error, NULL);
   7.212 +	/* The #? is to identify file type, the programtype is optional. */
   7.213 +	if(info && (info->valid & RGBE_VALID_GAMMA)) {
   7.214 +		if(fprintf(fp, "GAMMA=%g\n", info->gamma) < 0)
   7.215 +			return rgbe_error(rgbe_write_error, NULL);
   7.216 +	}
   7.217 +	if(info && (info->valid & RGBE_VALID_EXPOSURE)) {
   7.218 +		if(fprintf(fp, "EXPOSURE=%g\n", info->exposure) < 0)
   7.219 +			return rgbe_error(rgbe_write_error, NULL);
   7.220 +	}
   7.221 +	if(fprintf(fp, "FORMAT=32-bit_rle_rgbe\n\n") < 0)
   7.222 +		return rgbe_error(rgbe_write_error, NULL);
   7.223 +	if(fprintf(fp, "-Y %d +X %d\n", height, width) < 0)
   7.224 +		return rgbe_error(rgbe_write_error, NULL);
   7.225 +	return RGBE_RETURN_SUCCESS;
   7.226 +}
   7.227 +#endif
   7.228 +
   7.229 +/* minimal header reading.  modify if you want to parse more information */
   7.230 +static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info)
   7.231 +{
   7.232 +	char buf[128];
   7.233 +	float tempf;
   7.234 +	int i;
   7.235 +
   7.236 +	if(info) {
   7.237 +		info->valid = 0;
   7.238 +		info->programtype[0] = 0;
   7.239 +		info->gamma = info->exposure = 1.0;
   7.240 +	}
   7.241 +	if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == NULL)
   7.242 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   7.243 +	if((buf[0] != '#') || (buf[1] != '?')) {
   7.244 +		/* if you want to require the magic token then uncomment the next line */
   7.245 +		/*return rgbe_error(rgbe_format_error,"bad initial token"); */
   7.246 +	} else if(info) {
   7.247 +		info->valid |= RGBE_VALID_PROGRAMTYPE;
   7.248 +		for(i = 0; i < sizeof(info->programtype) - 1; i++) {
   7.249 +			if((buf[i + 2] == 0) || isspace(buf[i + 2]))
   7.250 +				break;
   7.251 +			info->programtype[i] = buf[i + 2];
   7.252 +		}
   7.253 +		info->programtype[i] = 0;
   7.254 +		if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   7.255 +			return rgbe_error(rgbe_read_error, NULL);
   7.256 +	}
   7.257 +	for(;;) {
   7.258 +		if((buf[0] == 0) || (buf[0] == '\n'))
   7.259 +			return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "no FORMAT specifier found");*/
   7.260 +		else if(strcmp(buf, "FORMAT=32-bit_rle_rgbe\n") == 0)
   7.261 +			break;				/* format found so break out of loop */
   7.262 +		else if(info && (sscanf(buf, "GAMMA=%g", &tempf) == 1)) {
   7.263 +			info->gamma = tempf;
   7.264 +			info->valid |= RGBE_VALID_GAMMA;
   7.265 +		} else if(info && (sscanf(buf, "EXPOSURE=%g", &tempf) == 1)) {
   7.266 +			info->exposure = tempf;
   7.267 +			info->valid |= RGBE_VALID_EXPOSURE;
   7.268 +		}
   7.269 +		if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   7.270 +			return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   7.271 +	}
   7.272 +	if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   7.273 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   7.274 +	if(strcmp(buf, "\n") != 0)
   7.275 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing blank line after FORMAT specifier");*/
   7.276 +	if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   7.277 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   7.278 +	if(sscanf(buf, "-Y %d +X %d", height, width) < 2)
   7.279 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing image size specifier");*/
   7.280 +	return RGBE_RETURN_SUCCESS;
   7.281 +}
   7.282 +
   7.283 +#if 0
   7.284 +/* simple write routine that does not use run length encoding */
   7.285 +
   7.286 +/* These routines can be made faster by allocating a larger buffer and
   7.287 +   fread-ing and fwrite-ing the data in larger chunks */
   7.288 +static int rgbe_write_pixels(FILE * fp, float *data, int numpixels)
   7.289 +{
   7.290 +	unsigned char rgbe[4];
   7.291 +
   7.292 +	while(numpixels-- > 0) {
   7.293 +		float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
   7.294 +		data += RGBE_DATA_SIZE;
   7.295 +		if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1)
   7.296 +			return rgbe_error(rgbe_write_error, NULL);
   7.297 +	}
   7.298 +	return RGBE_RETURN_SUCCESS;
   7.299 +}
   7.300 +#endif
   7.301 +
   7.302 +/* simple read routine.  will not correctly handle run length encoding */
   7.303 +static int rgbe_read_pixels(struct img_io *io, float *data, int numpixels)
   7.304 +{
   7.305 +	unsigned char rgbe[4];
   7.306 +
   7.307 +	while(numpixels-- > 0) {
   7.308 +		if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1)
   7.309 +			return rgbe_error(rgbe_read_error, NULL);
   7.310 +		rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
   7.311 +		data += RGBE_DATA_SIZE;
   7.312 +	}
   7.313 +	return RGBE_RETURN_SUCCESS;
   7.314 +}
   7.315 +
   7.316 +#if 0
   7.317 +/* The code below is only needed for the run-length encoded files. */
   7.318 +
   7.319 +/* Run length encoding adds considerable complexity but does */
   7.320 +
   7.321 +/* save some space.  For each scanline, each channel (r,g,b,e) is */
   7.322 +
   7.323 +/* encoded separately for better compression. */
   7.324 +
   7.325 +static int rgbe_write_bytes_rle(struct img_io *io, unsigned char *data, int numbytes)
   7.326 +{
   7.327 +#define MINRUNLENGTH 4
   7.328 +	int cur, beg_run, run_count, old_run_count, nonrun_count;
   7.329 +	unsigned char buf[2];
   7.330 +
   7.331 +	cur = 0;
   7.332 +	while(cur < numbytes) {
   7.333 +		beg_run = cur;
   7.334 +		/* find next run of length at least 4 if one exists */
   7.335 +		run_count = old_run_count = 0;
   7.336 +		while((run_count < MINRUNLENGTH) && (beg_run < numbytes)) {
   7.337 +			beg_run += run_count;
   7.338 +			old_run_count = run_count;
   7.339 +			run_count = 1;
   7.340 +			while((beg_run + run_count < numbytes) && (run_count < 127)
   7.341 +				  && (data[beg_run] == data[beg_run + run_count]))
   7.342 +				run_count++;
   7.343 +		}
   7.344 +		/* if data before next big run is a short run then write it as such */
   7.345 +		if((old_run_count > 1) && (old_run_count == beg_run - cur)) {
   7.346 +			buf[0] = 128 + old_run_count;	/*write short run */
   7.347 +			buf[1] = data[cur];
   7.348 +			if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
   7.349 +				return rgbe_error(rgbe_write_error, NULL);
   7.350 +			cur = beg_run;
   7.351 +		}
   7.352 +		/* write out bytes until we reach the start of the next run */
   7.353 +		while(cur < beg_run) {
   7.354 +			nonrun_count = beg_run - cur;
   7.355 +			if(nonrun_count > 128)
   7.356 +				nonrun_count = 128;
   7.357 +			buf[0] = nonrun_count;
   7.358 +			if(fwrite(buf, sizeof(buf[0]), 1, fp) < 1)
   7.359 +				return rgbe_error(rgbe_write_error, NULL);
   7.360 +			if(fwrite(&data[cur], sizeof(data[0]) * nonrun_count, 1, fp) < 1)
   7.361 +				return rgbe_error(rgbe_write_error, NULL);
   7.362 +			cur += nonrun_count;
   7.363 +		}
   7.364 +		/* write out next run if one was found */
   7.365 +		if(run_count >= MINRUNLENGTH) {
   7.366 +			buf[0] = 128 + run_count;
   7.367 +			buf[1] = data[beg_run];
   7.368 +			if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
   7.369 +				return rgbe_error(rgbe_write_error, NULL);
   7.370 +			cur += run_count;
   7.371 +		}
   7.372 +	}
   7.373 +	return RGBE_RETURN_SUCCESS;
   7.374 +#undef MINRUNLENGTH
   7.375 +}
   7.376 +
   7.377 +static int rgbe_write_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
   7.378 +{
   7.379 +	unsigned char rgbe[4];
   7.380 +	unsigned char *buffer;
   7.381 +	int i, err;
   7.382 +
   7.383 +	if((scanline_width < 8) || (scanline_width > 0x7fff))
   7.384 +		/* run length encoding is not allowed so write flat */
   7.385 +		return rgbe_write_pixels(io, data, scanline_width * num_scanlines);
   7.386 +	buffer = (unsigned char *)malloc(sizeof(unsigned char) * 4 * scanline_width);
   7.387 +	if(buffer == NULL)
   7.388 +		/* no buffer space so write flat */
   7.389 +		return rgbe_write_pixels(fp, data, scanline_width * num_scanlines);
   7.390 +	while(num_scanlines-- > 0) {
   7.391 +		rgbe[0] = 2;
   7.392 +		rgbe[1] = 2;
   7.393 +		rgbe[2] = scanline_width >> 8;
   7.394 +		rgbe[3] = scanline_width & 0xFF;
   7.395 +		if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1) {
   7.396 +			free(buffer);
   7.397 +			return rgbe_error(rgbe_write_error, NULL);
   7.398 +		}
   7.399 +		for(i = 0; i < scanline_width; i++) {
   7.400 +			float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
   7.401 +			buffer[i] = rgbe[0];
   7.402 +			buffer[i + scanline_width] = rgbe[1];
   7.403 +			buffer[i + 2 * scanline_width] = rgbe[2];
   7.404 +			buffer[i + 3 * scanline_width] = rgbe[3];
   7.405 +			data += RGBE_DATA_SIZE;
   7.406 +		}
   7.407 +		/* write out each of the four channels separately run length encoded */
   7.408 +		/* first red, then green, then blue, then exponent */
   7.409 +		for(i = 0; i < 4; i++) {
   7.410 +			if((err = rgbe_write_bytes_rle(fp, &buffer[i * scanline_width],
   7.411 +										  scanline_width)) != RGBE_RETURN_SUCCESS) {
   7.412 +				free(buffer);
   7.413 +				return err;
   7.414 +			}
   7.415 +		}
   7.416 +	}
   7.417 +	free(buffer);
   7.418 +	return RGBE_RETURN_SUCCESS;
   7.419 +}
   7.420 +#endif
   7.421 +
   7.422 +static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
   7.423 +{
   7.424 +	unsigned char rgbe[4], *scanline_buffer, *ptr, *ptr_end;
   7.425 +	int i, count;
   7.426 +	unsigned char buf[2];
   7.427 +
   7.428 +	if((scanline_width < 8) || (scanline_width > 0x7fff))
   7.429 +		/* run length encoding is not allowed so read flat */
   7.430 +		return rgbe_read_pixels(io, data, scanline_width * num_scanlines);
   7.431 +	scanline_buffer = NULL;
   7.432 +	/* read in each successive scanline */
   7.433 +	while(num_scanlines > 0) {
   7.434 +		if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1) {
   7.435 +			free(scanline_buffer);
   7.436 +			return rgbe_error(rgbe_read_error, NULL);
   7.437 +		}
   7.438 +		if((rgbe[0] != 2) || (rgbe[1] != 2) || (rgbe[2] & 0x80)) {
   7.439 +			/* this file is not run length encoded */
   7.440 +			rgbe2float(&data[0], &data[1], &data[2], rgbe);
   7.441 +			data += RGBE_DATA_SIZE;
   7.442 +			free(scanline_buffer);
   7.443 +			return rgbe_read_pixels(io, data, scanline_width * num_scanlines - 1);
   7.444 +		}
   7.445 +		if((((int)rgbe[2]) << 8 | rgbe[3]) != scanline_width) {
   7.446 +			free(scanline_buffer);
   7.447 +			return rgbe_error(rgbe_format_error, "wrong scanline width");
   7.448 +		}
   7.449 +		if(scanline_buffer == NULL)
   7.450 +			scanline_buffer = (unsigned char *)
   7.451 +				malloc(sizeof(unsigned char) * 4 * scanline_width);
   7.452 +		if(scanline_buffer == NULL)
   7.453 +			return rgbe_error(rgbe_memory_error, "unable to allocate buffer space");
   7.454 +
   7.455 +		ptr = &scanline_buffer[0];
   7.456 +		/* read each of the four channels for the scanline into the buffer */
   7.457 +		for(i = 0; i < 4; i++) {
   7.458 +			ptr_end = &scanline_buffer[(i + 1) * scanline_width];
   7.459 +			while(ptr < ptr_end) {
   7.460 +				if(io->read(buf, sizeof(buf[0]) * 2, io->uptr) < 1) {
   7.461 +					free(scanline_buffer);
   7.462 +					return rgbe_error(rgbe_read_error, NULL);
   7.463 +				}
   7.464 +				if(buf[0] > 128) {
   7.465 +					/* a run of the same value */
   7.466 +					count = buf[0] - 128;
   7.467 +					if((count == 0) || (count > ptr_end - ptr)) {
   7.468 +						free(scanline_buffer);
   7.469 +						return rgbe_error(rgbe_format_error, "bad scanline data");
   7.470 +					}
   7.471 +					while(count-- > 0)
   7.472 +						*ptr++ = buf[1];
   7.473 +				} else {
   7.474 +					/* a non-run */
   7.475 +					count = buf[0];
   7.476 +					if((count == 0) || (count > ptr_end - ptr)) {
   7.477 +						free(scanline_buffer);
   7.478 +						return rgbe_error(rgbe_format_error, "bad scanline data");
   7.479 +					}
   7.480 +					*ptr++ = buf[1];
   7.481 +					if(--count > 0) {
   7.482 +						if(io->read(ptr, sizeof(*ptr) * count, io->uptr) < 1) {
   7.483 +							free(scanline_buffer);
   7.484 +							return rgbe_error(rgbe_read_error, NULL);
   7.485 +						}
   7.486 +						ptr += count;
   7.487 +					}
   7.488 +				}
   7.489 +			}
   7.490 +		}
   7.491 +		/* now convert data from buffer into floats */
   7.492 +		for(i = 0; i < scanline_width; i++) {
   7.493 +			rgbe[0] = scanline_buffer[i];
   7.494 +			rgbe[1] = scanline_buffer[i + scanline_width];
   7.495 +			rgbe[2] = scanline_buffer[i + 2 * scanline_width];
   7.496 +			rgbe[3] = scanline_buffer[i + 3 * scanline_width];
   7.497 +			rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
   7.498 +			data += RGBE_DATA_SIZE;
   7.499 +		}
   7.500 +		num_scanlines--;
   7.501 +	}
   7.502 +	free(scanline_buffer);
   7.503 +	return RGBE_RETURN_SUCCESS;
   7.504 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/libs/imago/ftype_module.c	Sun Nov 01 00:36:56 2015 +0200
     8.3 @@ -0,0 +1,118 @@
     8.4 +/*
     8.5 +libimago - a multi-format image file input/output library.
     8.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     8.7 +
     8.8 +This program is free software: you can redistribute it and/or modify
     8.9 +it under the terms of the GNU Lesser General Public License as published
    8.10 +by the Free Software Foundation, either version 3 of the License, or
    8.11 +(at your option) any later version.
    8.12 +
    8.13 +This program is distributed in the hope that it will be useful,
    8.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    8.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    8.16 +GNU Lesser General Public License for more details.
    8.17 +
    8.18 +You should have received a copy of the GNU Lesser General Public License
    8.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    8.20 +*/
    8.21 +
    8.22 +#include <stdlib.h>
    8.23 +#include <string.h>
    8.24 +#include "ftype_module.h"
    8.25 +
    8.26 +static struct list_node {
    8.27 +	struct ftype_module *module;
    8.28 +	struct list_node *next;
    8.29 +} *modules;
    8.30 +
    8.31 +/* defined in modules.c which is generated by configure */
    8.32 +void img_modules_init();
    8.33 +
    8.34 +static int done_init;
    8.35 +
    8.36 +int img_register_module(struct ftype_module *mod)
    8.37 +{
    8.38 +	struct list_node *node;
    8.39 +
    8.40 +	if(!(node = malloc(sizeof *node))) {
    8.41 +		return -1;
    8.42 +	}
    8.43 +
    8.44 +	node->module = mod;
    8.45 +	node->next = modules;
    8.46 +	modules = node;
    8.47 +	return 0;
    8.48 +}
    8.49 +
    8.50 +struct ftype_module *img_find_format_module(struct img_io *io)
    8.51 +{
    8.52 +	struct list_node *node;
    8.53 +
    8.54 +	if(!done_init) {
    8.55 +		img_modules_init();
    8.56 +		done_init = 1;
    8.57 +	}
    8.58 +
    8.59 +	node = modules;
    8.60 +	while(node) {
    8.61 +		if(node->module->check(io) != -1) {
    8.62 +			return node->module;
    8.63 +		}
    8.64 +		node = node->next;
    8.65 +	}
    8.66 +	return 0;
    8.67 +}
    8.68 +
    8.69 +struct ftype_module *img_guess_format(const char *fname)
    8.70 +{
    8.71 +	struct list_node *node;
    8.72 +	char *suffix;
    8.73 +	int suffix_len;
    8.74 +
    8.75 +	if(!done_init) {
    8.76 +		img_modules_init();
    8.77 +		done_init = 1;
    8.78 +	}
    8.79 +
    8.80 +	if(!(suffix = strrchr(fname, '.'))) {
    8.81 +		return 0;	/* no suffix, can't guess ... */
    8.82 +	}
    8.83 +	suffix_len = strlen(suffix);
    8.84 +
    8.85 +	node = modules;
    8.86 +	while(node) {
    8.87 +		char *suflist = node->module->suffix;
    8.88 +		char *start, *end;
    8.89 +
    8.90 +		while(*suflist) {
    8.91 +			if(!(start = strstr(suflist, suffix))) {
    8.92 +				break;
    8.93 +			}
    8.94 +			end = start + suffix_len;
    8.95 +
    8.96 +			if(*end == ':' || *end == 0) {
    8.97 +				return node->module;	/* found it */
    8.98 +			}
    8.99 +			suflist = end;
   8.100 +		}
   8.101 +
   8.102 +		node = node->next;
   8.103 +	}
   8.104 +	return 0;
   8.105 +}
   8.106 +
   8.107 +struct ftype_module *img_get_module(int idx)
   8.108 +{
   8.109 +	struct list_node *node;
   8.110 +
   8.111 +	if(!done_init) {
   8.112 +		img_modules_init();
   8.113 +		done_init = 1;
   8.114 +	}
   8.115 +
   8.116 +	node = modules;
   8.117 +	while(node && idx--) {
   8.118 +		node = node->next;
   8.119 +	}
   8.120 +	return node ? node->module : 0;
   8.121 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/libs/imago/ftype_module.h	Sun Nov 01 00:36:56 2015 +0200
     9.3 @@ -0,0 +1,39 @@
     9.4 +/*
     9.5 +libimago - a multi-format image file input/output library.
     9.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     9.7 +
     9.8 +This program is free software: you can redistribute it and/or modify
     9.9 +it under the terms of the GNU Lesser General Public License as published
    9.10 +by the Free Software Foundation, either version 3 of the License, or
    9.11 +(at your option) any later version.
    9.12 +
    9.13 +This program is distributed in the hope that it will be useful,
    9.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    9.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9.16 +GNU Lesser General Public License for more details.
    9.17 +
    9.18 +You should have received a copy of the GNU Lesser General Public License
    9.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    9.20 +*/
    9.21 +
    9.22 +#ifndef FTYPE_MODULE_H_
    9.23 +#define FTYPE_MODULE_H_
    9.24 +
    9.25 +#include "imago2.h"
    9.26 +
    9.27 +struct ftype_module {
    9.28 +	char *suffix;	/* used for format autodetection during saving only */
    9.29 +
    9.30 +	int (*check)(struct img_io *io);
    9.31 +	int (*read)(struct img_pixmap *img, struct img_io *io);
    9.32 +	int (*write)(struct img_pixmap *img, struct img_io *io);
    9.33 +};
    9.34 +
    9.35 +int img_register_module(struct ftype_module *mod);
    9.36 +
    9.37 +struct ftype_module *img_find_format_module(struct img_io *io);
    9.38 +struct ftype_module *img_guess_format(const char *fname);
    9.39 +struct ftype_module *img_get_module(int idx);
    9.40 +
    9.41 +
    9.42 +#endif	/* FTYPE_MODULE_H_ */

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/libs/imago/imago2.c	Sun Nov 01 00:36:56 2015 +0200
    10.3 @@ -0,0 +1,449 @@
    10.4 +/*
    10.5 +libimago - a multi-format image file input/output library.
    10.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
    10.7 +
    10.8 +This program is free software: you can redistribute it and/or modify
    10.9 +it under the terms of the GNU Lesser General Public License as published
   10.10 +by the Free Software Foundation, either version 3 of the License, or
   10.11 +(at your option) any later version.
   10.12 +
   10.13 +This program is distributed in the hope that it will be useful,
   10.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   10.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   10.16 +GNU Lesser General Public License for more details.
   10.17 +
   10.18 +You should have received a copy of the GNU Lesser General Public License
   10.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   10.20 +*/
   10.21 +
   10.22 +#include <stdio.h>
   10.23 +#include <stdlib.h>
   10.24 +#include <string.h>
   10.25 +#include "imago2.h"
   10.26 +#include "ftype_module.h"
   10.27 +
   10.28 +static int pixel_size(enum img_fmt fmt);
   10.29 +static size_t def_read(void *buf, size_t bytes, void *uptr);
   10.30 +static size_t def_write(void *buf, size_t bytes, void *uptr);
   10.31 +static long def_seek(long offset, int whence, void *uptr);
   10.32 +
   10.33 +
   10.34 +void img_init(struct img_pixmap *img)
   10.35 +{
   10.36 +	img->pixels = 0;
   10.37 +	img->width = img->height = 0;
   10.38 +	img->fmt = IMG_FMT_RGBA32;
   10.39 +	img->pixelsz = pixel_size(img->fmt);
   10.40 +	img->name = 0;
   10.41 +}
   10.42 +
   10.43 +
   10.44 +void img_destroy(struct img_pixmap *img)
   10.45 +{
   10.46 +	free(img->pixels);
   10.47 +	img->pixels = 0;	/* just in case... */
   10.48 +	img->width = img->height = 0xbadbeef;
   10.49 +	free(img->name);
   10.50 +}
   10.51 +
   10.52 +struct img_pixmap *img_create(void)
   10.53 +{
   10.54 +	struct img_pixmap *p;
   10.55 +
   10.56 +	if(!(p = malloc(sizeof *p))) {
   10.57 +		return 0;
   10.58 +	}
   10.59 +	img_init(p);
   10.60 +	return p;
   10.61 +}
   10.62 +
   10.63 +void img_free(struct img_pixmap *img)
   10.64 +{
   10.65 +	img_destroy(img);
   10.66 +	free(img);
   10.67 +}
   10.68 +
   10.69 +int img_set_name(struct img_pixmap *img, const char *name)
   10.70 +{
   10.71 +	char *tmp;
   10.72 +
   10.73 +	if(!(tmp = malloc(strlen(name) + 1))) {
   10.74 +		return -1;
   10.75 +	}
   10.76 +	strcpy(tmp, name);
   10.77 +	img->name = tmp;
   10.78 +	return 0;
   10.79 +}
   10.80 +
   10.81 +int img_set_format(struct img_pixmap *img, enum img_fmt fmt)
   10.82 +{
   10.83 +	if(img->pixels) {
   10.84 +		return img_convert(img, fmt);
   10.85 +	}
   10.86 +	img->fmt = fmt;
   10.87 +	return 0;
   10.88 +}
   10.89 +
   10.90 +int img_copy(struct img_pixmap *dest, struct img_pixmap *src)
   10.91 +{
   10.92 +	return img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels);
   10.93 +}
   10.94 +
   10.95 +int img_set_pixels(struct img_pixmap *img, int w, int h, enum img_fmt fmt, void *pix)
   10.96 +{
   10.97 +	void *newpix;
   10.98 +	int pixsz = pixel_size(fmt);
   10.99 +
  10.100 +	if(!(newpix = malloc(w * h * pixsz))) {
  10.101 +		return -1;
  10.102 +	}
  10.103 +
  10.104 +	if(pix) {
  10.105 +		memcpy(newpix, pix, w * h * pixsz);
  10.106 +	} else {
  10.107 +		memset(newpix, 0, w * h * pixsz);
  10.108 +	}
  10.109 +
  10.110 +	free(img->pixels);
  10.111 +	img->pixels = newpix;
  10.112 +	img->width = w;
  10.113 +	img->height = h;
  10.114 +	img->pixelsz = pixsz;
  10.115 +	img->fmt = fmt;
  10.116 +	return 0;
  10.117 +}
  10.118 +
  10.119 +void *img_load_pixels(const char *fname, int *xsz, int *ysz, enum img_fmt fmt)
  10.120 +{
  10.121 +	struct img_pixmap img;
  10.122 +
  10.123 +	img_init(&img);
  10.124 +
  10.125 +	if(img_load(&img, fname) == -1) {
  10.126 +		return 0;
  10.127 +	}
  10.128 +	if(img.fmt != fmt) {
  10.129 +		if(img_convert(&img, fmt) == -1) {
  10.130 +			img_destroy(&img);
  10.131 +			return 0;
  10.132 +		}
  10.133 +	}
  10.134 +
  10.135 +	*xsz = img.width;
  10.136 +	*ysz = img.height;
  10.137 +	return img.pixels;
  10.138 +}
  10.139 +
  10.140 +int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, enum img_fmt fmt)
  10.141 +{
  10.142 +	struct img_pixmap img;
  10.143 +
  10.144 +	img_init(&img);
  10.145 +	img.fmt = fmt;
  10.146 +	img.name = (char*)fname;
  10.147 +	img.width = xsz;
  10.148 +	img.height = ysz;
  10.149 +	img.pixels = pix;
  10.150 +
  10.151 +	return img_save(&img, fname);
  10.152 +}
  10.153 +
  10.154 +void img_free_pixels(void *pix)
  10.155 +{
  10.156 +	free(pix);
  10.157 +}
  10.158 +
  10.159 +int img_load(struct img_pixmap *img, const char *fname)
  10.160 +{
  10.161 +	int res;
  10.162 +	FILE *fp;
  10.163 +
  10.164 +	if(!(fp = fopen(fname, "rb"))) {
  10.165 +		return -1;
  10.166 +	}
  10.167 +	res = img_read_file(img, fp);
  10.168 +	fclose(fp);
  10.169 +	return res;
  10.170 +}
  10.171 +
  10.172 +/* TODO implement filetype selection */
  10.173 +int img_save(struct img_pixmap *img, const char *fname)
  10.174 +{
  10.175 +	int res;
  10.176 +	FILE *fp;
  10.177 +
  10.178 +	img_set_name(img, fname);
  10.179 +
  10.180 +	if(!(fp = fopen(fname, "wb"))) {
  10.181 +		return -1;
  10.182 +	}
  10.183 +	res = img_write_file(img, fp);
  10.184 +	fclose(fp);
  10.185 +	return res;
  10.186 +}
  10.187 +
  10.188 +int img_read_file(struct img_pixmap *img, FILE *fp)
  10.189 +{
  10.190 +	struct img_io io = {0, def_read, def_write, def_seek};
  10.191 +
  10.192 +	io.uptr = fp;
  10.193 +	return img_read(img, &io);
  10.194 +}
  10.195 +
  10.196 +int img_write_file(struct img_pixmap *img, FILE *fp)
  10.197 +{
  10.198 +	struct img_io io = {0, def_read, def_write, def_seek};
  10.199 +
  10.200 +	io.uptr = fp;
  10.201 +	return img_write(img, &io);
  10.202 +}
  10.203 +
  10.204 +int img_read(struct img_pixmap *img, struct img_io *io)
  10.205 +{
  10.206 +	struct ftype_module *mod;
  10.207 +
  10.208 +	if((mod = img_find_format_module(io))) {
  10.209 +		return mod->read(img, io);
  10.210 +	}
  10.211 +	return -1;
  10.212 +}
  10.213 +
  10.214 +int img_write(struct img_pixmap *img, struct img_io *io)
  10.215 +{
  10.216 +	struct ftype_module *mod;
  10.217 +
  10.218 +	if(!img->name || !(mod = img_guess_format(img->name))) {
  10.219 +		/* TODO throw some sort of warning? */
  10.220 +		/* TODO implement some sort of module priority or let the user specify? */
  10.221 +		if(!(mod = img_get_module(0))) {
  10.222 +			return -1;
  10.223 +		}
  10.224 +	}
  10.225 +
  10.226 +	return mod->write(img, io);
  10.227 +}
  10.228 +
  10.229 +int img_to_float(struct img_pixmap *img)
  10.230 +{
  10.231 +	enum img_fmt targ_fmt;
  10.232 +
  10.233 +	switch(img->fmt) {
  10.234 +	case IMG_FMT_GREY8:
  10.235 +		targ_fmt = IMG_FMT_GREYF;
  10.236 +		break;
  10.237 +
  10.238 +	case IMG_FMT_RGB24:
  10.239 +		targ_fmt = IMG_FMT_RGBF;
  10.240 +		break;
  10.241 +
  10.242 +	case IMG_FMT_RGBA32:
  10.243 +		targ_fmt = IMG_FMT_RGBAF;
  10.244 +		break;
  10.245 +
  10.246 +	default:
  10.247 +		return 0;	/* already float */
  10.248 +	}
  10.249 +
  10.250 +	return img_convert(img, targ_fmt);
  10.251 +}
  10.252 +
  10.253 +int img_to_integer(struct img_pixmap *img)
  10.254 +{
  10.255 +	enum img_fmt targ_fmt;
  10.256 +
  10.257 +	switch(img->fmt) {
  10.258 +	case IMG_FMT_GREYF:
  10.259 +		targ_fmt = IMG_FMT_GREY8;
  10.260 +		break;
  10.261 +
  10.262 +	case IMG_FMT_RGBF:
  10.263 +		targ_fmt = IMG_FMT_RGB24;
  10.264 +		break;
  10.265 +
  10.266 +	case IMG_FMT_RGBAF:
  10.267 +		targ_fmt = IMG_FMT_RGBA32;
  10.268 +		break;
  10.269 +
  10.270 +	default:
  10.271 +		return 0;	/* already integer */
  10.272 +	}
  10.273 +
  10.274 +	return img_convert(img, targ_fmt);
  10.275 +}
  10.276 +
  10.277 +int img_is_float(struct img_pixmap *img)
  10.278 +{
  10.279 +	return img->fmt >= IMG_FMT_GREYF && img->fmt <= IMG_FMT_RGBAF;
  10.280 +}
  10.281 +
  10.282 +int img_has_alpha(struct img_pixmap *img)
  10.283 +{
  10.284 +	if(img->fmt == IMG_FMT_RGBA32 || img->fmt == IMG_FMT_RGBAF) {
  10.285 +		return 1;
  10.286 +	}
  10.287 +	return 0;
  10.288 +}
  10.289 +
  10.290 +
  10.291 +void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel)
  10.292 +{
  10.293 +	char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
  10.294 +	memcpy(dest, pixel, img->pixelsz);
  10.295 +}
  10.296 +
  10.297 +void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel)
  10.298 +{
  10.299 +	char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
  10.300 +	memcpy(pixel, dest, img->pixelsz);
  10.301 +}
  10.302 +
  10.303 +void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix)
  10.304 +{
  10.305 +	img_setpixel4i(img, x, y, pix, pix, pix, pix);
  10.306 +}
  10.307 +
  10.308 +void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix)
  10.309 +{
  10.310 +	img_setpixel4f(img, x, y, pix, pix, pix, pix);
  10.311 +}
  10.312 +
  10.313 +void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a)
  10.314 +{
  10.315 +	if(img_is_float(img)) {
  10.316 +		img_setpixel4f(img, x, y, r / 255.0, g / 255.0, b / 255.0, a / 255.0);
  10.317 +	} else {
  10.318 +		unsigned char pixel[4];
  10.319 +		pixel[0] = r;
  10.320 +		pixel[1] = g;
  10.321 +		pixel[2] = b;
  10.322 +		pixel[3] = a;
  10.323 +
  10.324 +		img_setpixel(img, x, y, pixel);
  10.325 +	}
  10.326 +}
  10.327 +
  10.328 +void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a)
  10.329 +{
  10.330 +	if(img_is_float(img)) {
  10.331 +		float pixel[4];
  10.332 +		pixel[0] = r;
  10.333 +		pixel[1] = g;
  10.334 +		pixel[2] = b;
  10.335 +		pixel[3] = a;
  10.336 +
  10.337 +		img_setpixel(img, x, y, pixel);
  10.338 +	} else {
  10.339 +		img_setpixel4i(img, x, y, (int)(r * 255.0), (int)(g * 255.0), (int)(b * 255.0), (int)(a * 255.0));
  10.340 +	}
  10.341 +}
  10.342 +
  10.343 +void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix)
  10.344 +{
  10.345 +	int junk[3];
  10.346 +	img_getpixel4i(img, x, y, pix, junk, junk + 1, junk + 2);
  10.347 +}
  10.348 +
  10.349 +void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix)
  10.350 +{
  10.351 +	float junk[3];
  10.352 +	img_getpixel4f(img, x, y, pix, junk, junk + 1, junk + 2);
  10.353 +}
  10.354 +
  10.355 +void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a)
  10.356 +{
  10.357 +	if(img_is_float(img)) {
  10.358 +		float pixel[4] = {0, 0, 0, 0};
  10.359 +		img_getpixel(img, x, y, pixel);
  10.360 +		*r = pixel[0] * 255.0;
  10.361 +		*g = pixel[1] * 255.0;
  10.362 +		*b = pixel[2] * 255.0;
  10.363 +		*a = pixel[3] * 255.0;
  10.364 +	} else {
  10.365 +		unsigned char pixel[4];
  10.366 +		img_getpixel(img, x, y, pixel);
  10.367 +		*r = pixel[0];
  10.368 +		*g = pixel[1];
  10.369 +		*b = pixel[2];
  10.370 +		*a = pixel[3];
  10.371 +	}
  10.372 +}
  10.373 +
  10.374 +void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a)
  10.375 +{
  10.376 +	if(img_is_float(img)) {
  10.377 +		float pixel[4] = {0, 0, 0, 0};
  10.378 +		img_getpixel(img, x, y, pixel);
  10.379 +		*r = pixel[0];
  10.380 +		*g = pixel[1];
  10.381 +		*b = pixel[2];
  10.382 +		*a = pixel[3];
  10.383 +	} else {
  10.384 +		unsigned char pixel[4];
  10.385 +		img_getpixel(img, x, y, pixel);
  10.386 +		*r = pixel[0] / 255.0;
  10.387 +		*g = pixel[1] / 255.0;
  10.388 +		*b = pixel[2] / 255.0;
  10.389 +		*a = pixel[3] / 255.0;
  10.390 +	}
  10.391 +}
  10.392 +
  10.393 +void img_io_set_user_data(struct img_io *io, void *uptr)
  10.394 +{
  10.395 +	io->uptr = uptr;
  10.396 +}
  10.397 +
  10.398 +void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*))
  10.399 +{
  10.400 +	io->read = read;
  10.401 +}
  10.402 +
  10.403 +void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*))
  10.404 +{
  10.405 +	io->write = write;
  10.406 +}
  10.407 +
  10.408 +void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*))
  10.409 +{
  10.410 +	io->seek = seek;
  10.411 +}
  10.412 +
  10.413 +
  10.414 +static int pixel_size(enum img_fmt fmt)
  10.415 +{
  10.416 +	switch(fmt) {
  10.417 +	case IMG_FMT_GREY8:
  10.418 +		return 1;
  10.419 +	case IMG_FMT_RGB24:
  10.420 +		return 3;
  10.421 +	case IMG_FMT_RGBA32:
  10.422 +		return 4;
  10.423 +	case IMG_FMT_GREYF:
  10.424 +		return sizeof(float);
  10.425 +	case IMG_FMT_RGBF:
  10.426 +		return 3 * sizeof(float);
  10.427 +	case IMG_FMT_RGBAF:
  10.428 +		return 4 * sizeof(float);
  10.429 +	default:
  10.430 +		break;
  10.431 +	}
  10.432 +	return 0;
  10.433 +}
  10.434 +
  10.435 +static size_t def_read(void *buf, size_t bytes, void *uptr)
  10.436 +{
  10.437 +	return uptr ? fread(buf, 1, bytes, uptr) : 0;
  10.438 +}
  10.439 +
  10.440 +static size_t def_write(void *buf, size_t bytes, void *uptr)
  10.441 +{
  10.442 +	return uptr ? fwrite(buf, 1, bytes, uptr) : 0;
  10.443 +}
  10.444 +
  10.445 +static long def_seek(long offset, int whence, void *uptr)
  10.446 +{
  10.447 +	if(!uptr || fseek(uptr, offset, whence) == -1) {
  10.448 +		return -1;
  10.449 +	}
  10.450 +	return ftell(uptr);
  10.451 +}
  10.452 +

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/libs/imago/imago2.h	Sun Nov 01 00:36:56 2015 +0200
    11.3 @@ -0,0 +1,222 @@
    11.4 +/*
    11.5 +libimago - a multi-format image file input/output library.
    11.6 +Copyright (C) 2010-2012 John Tsiombikas <nuclear@member.fsf.org>
    11.7 +
    11.8 +This program is free software: you can redistribute it and/or modify
    11.9 +it under the terms of the GNU Lesser General Public License as published
   11.10 +by the Free Software Foundation, either version 3 of the License, or
   11.11 +(at your option) any later version.
   11.12 +
   11.13 +This program is distributed in the hope that it will be useful,
   11.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   11.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   11.16 +GNU Lesser General Public License for more details.
   11.17 +
   11.18 +You should have received a copy of the GNU Lesser General Public License
   11.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   11.20 +*/
   11.21 +
   11.22 +#ifndef IMAGO2_H_
   11.23 +#define IMAGO2_H_
   11.24 +
   11.25 +#include <stdio.h>
   11.26 +
   11.27 +#ifdef __cplusplus
   11.28 +#define IMG_OPTARG(arg, val)	arg = val
   11.29 +#else
   11.30 +#define IMG_OPTARG(arg, val)	arg
   11.31 +#endif
   11.32 +
   11.33 +/* XXX if you change this make sure to also change pack/unpack arrays in conv.c */
   11.34 +enum img_fmt {
   11.35 +	IMG_FMT_GREY8,
   11.36 +	IMG_FMT_RGB24,
   11.37 +	IMG_FMT_RGBA32,
   11.38 +	IMG_FMT_GREYF,
   11.39 +	IMG_FMT_RGBF,
   11.40 +	IMG_FMT_RGBAF,
   11.41 +
   11.42 +	NUM_IMG_FMT
   11.43 +};
   11.44 +
   11.45 +struct img_pixmap {
   11.46 +	void *pixels;
   11.47 +	int width, height;
   11.48 +	enum img_fmt fmt;
   11.49 +	int pixelsz;
   11.50 +	char *name;
   11.51 +};
   11.52 +
   11.53 +struct img_io {
   11.54 +	void *uptr;	/* user-data */
   11.55 +
   11.56 +	size_t (*read)(void *buf, size_t bytes, void *uptr);
   11.57 +	size_t (*write)(void *buf, size_t bytes, void *uptr);
   11.58 +	long (*seek)(long offs, int whence, void *uptr);
   11.59 +};
   11.60 +
   11.61 +#ifdef __cplusplus
   11.62 +extern "C" {
   11.63 +#endif
   11.64 +
   11.65 +/* initialize the img_pixmap structure */
   11.66 +void img_init(struct img_pixmap *img);
   11.67 +/* destroys the img_pixmap structure, freeing the pixel buffer (if available)
   11.68 + * and any other memory held by the pixmap.
   11.69 + */
   11.70 +void img_destroy(struct img_pixmap *img);
   11.71 +
   11.72 +/* convenience function that allocates an img_pixmap struct and then initializes it.
   11.73 + * returns null if the malloc fails.
   11.74 + */
   11.75 +struct img_pixmap *img_create(void);
   11.76 +/* frees a pixmap previously allocated with img_create (free followed by img_destroy) */
   11.77 +void img_free(struct img_pixmap *img);
   11.78 +
   11.79 +int img_set_name(struct img_pixmap *img, const char *name);
   11.80 +
   11.81 +/* set the image pixel format */
   11.82 +int img_set_format(struct img_pixmap *img, enum img_fmt fmt);
   11.83 +
   11.84 +/* copies one pixmap to another.
   11.85 + * equivalent to: img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels)
   11.86 + */
   11.87 +int img_copy(struct img_pixmap *dest, struct img_pixmap *src);
   11.88 +
   11.89 +/* allocates a pixel buffer of the specified dimensions and format, and copies the
   11.90 + * pixels given through the pix pointer into it.
   11.91 + * the pix pointer can be null, in which case there's no copy, just allocation.
   11.92 + *
   11.93 + * C++: fmt and pix have default parameters IMG_FMT_RGBA32 and null respectively.
   11.94 + */
   11.95 +int img_set_pixels(struct img_pixmap *img, int w, int h, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32), IMG_OPTARG(void *pix, 0));
   11.96 +
   11.97 +/* Simplified image loading
   11.98 + * Loads the specified file, and returns a pointer to an array of pixels of the
   11.99 + * requested pixel format. The width and height of the image are returned through
  11.100 + * the xsz and ysz pointers.
  11.101 + * If the image cannot be loaded, the function returns null.
  11.102 + *
  11.103 + * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
  11.104 + */
  11.105 +void *img_load_pixels(const char *fname, int *xsz, int *ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
  11.106 +
  11.107 +/* Simplified image saving
  11.108 + * Reads an array of pixels supplied through the pix pointer, of dimensions xsz
  11.109 + * and ysz, and pixel-format fmt, and saves it to a file.
  11.110 + * The output filetype is guessed by the filename suffix.
  11.111 + *
  11.112 + * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
  11.113 + */
  11.114 +int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
  11.115 +
  11.116 +/* Frees the memory allocated by img_load_pixels */
  11.117 +void img_free_pixels(void *pix);
  11.118 +
  11.119 +/* Loads an image file into the supplied pixmap */
  11.120 +int img_load(struct img_pixmap *img, const char *fname);
  11.121 +/* Saves the supplied pixmap to a file. The output filetype is guessed by the filename suffix */
  11.122 +int img_save(struct img_pixmap *img, const char *fname);
  11.123 +
  11.124 +/* Reads an image from an open FILE* into the supplied pixmap */
  11.125 +int img_read_file(struct img_pixmap *img, FILE *fp);
  11.126 +/* Writes the supplied pixmap to an open FILE* */
  11.127 +int img_write_file(struct img_pixmap *img, FILE *fp);
  11.128 +
  11.129 +/* Reads an image using user-defined file-i/o functions (see img_io_set_*) */
  11.130 +int img_read(struct img_pixmap *img, struct img_io *io);
  11.131 +/* Writes an image using user-defined file-i/o functions (see img_io_set_*) */
  11.132 +int img_write(struct img_pixmap *img, struct img_io *io);
  11.133 +
  11.134 +/* Converts an image to the specified pixel format */
  11.135 +int img_convert(struct img_pixmap *img, enum img_fmt tofmt);
  11.136 +
  11.137 +/* Converts an image from an integer pixel format to the corresponding floating point one */
  11.138 +int img_to_float(struct img_pixmap *img);
  11.139 +/* Converts an image from a floating point pixel format to the corresponding integer one */
  11.140 +int img_to_integer(struct img_pixmap *img);
  11.141 +
  11.142 +/* Returns non-zero (true) if the supplied image is in a floating point pixel format */
  11.143 +int img_is_float(struct img_pixmap *img);
  11.144 +/* Returns non-zero (true) if the supplied image has an alpha channel */
  11.145 +int img_has_alpha(struct img_pixmap *img);
  11.146 +
  11.147 +
  11.148 +/* don't use these for anything performance-critical */
  11.149 +void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel);
  11.150 +void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel);
  11.151 +
  11.152 +void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix);
  11.153 +void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix);
  11.154 +void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a);
  11.155 +void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a);
  11.156 +
  11.157 +void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix);
  11.158 +void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix);
  11.159 +void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a);
  11.160 +void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a);
  11.161 +
  11.162 +
  11.163 +/* OpenGL helper functions */
  11.164 +
  11.165 +/* Returns the equivalent OpenGL "format" as expected by the 7th argument of glTexImage2D */
  11.166 +unsigned int img_fmt_glfmt(enum img_fmt fmt);
  11.167 +/* Returns the equivalent OpenGL "type" as expected by the 8th argument of glTexImage2D */
  11.168 +unsigned int img_fmt_gltype(enum img_fmt fmt);
  11.169 +/* Returns the equivalent OpenGL "internal format" as expected by the 3rd argument of glTexImage2D */
  11.170 +unsigned int img_fmt_glintfmt(enum img_fmt fmt);
  11.171 +
  11.172 +/* Same as above, based on the pixel format of the supplied image */
  11.173 +unsigned int img_glfmt(struct img_pixmap *img);
  11.174 +unsigned int img_gltype(struct img_pixmap *img);
  11.175 +unsigned int img_glintfmt(struct img_pixmap *img);
  11.176 +
  11.177 +/* Creates an OpenGL texture from the image, and returns the texture id, or 0 for failure */
  11.178 +unsigned int img_gltexture(struct img_pixmap *img);
  11.179 +
  11.180 +/* Load an image and create an OpenGL texture out of it */
  11.181 +unsigned int img_gltexture_load(const char *fname);
  11.182 +unsigned int img_gltexture_read_file(FILE *fp);
  11.183 +unsigned int img_gltexture_read(struct img_io *io);
  11.184 +
  11.185 +/* These functions can be used to fill an img_io struct before it's passed to
  11.186 + * one of the user-defined i/o image reading/writing functions (img_read/img_write).
  11.187 + *
  11.188 + * User-defined i/o functions:
  11.189 + *
  11.190 + * - size_t read_func(void *buffer, size_t bytes, void *user_ptr)
  11.191 + * Must try to fill the buffer with the specified number of bytes, and return
  11.192 + * the number of bytes actually read.
  11.193 + *
  11.194 + * - size_t write_func(void *buffer, size_t bytes, void *user_ptr)
  11.195 + * Must write the specified number of bytes from the supplied buffer and return
  11.196 + * the number of bytes actually written.
  11.197 + *
  11.198 + * - long seek_func(long offset, int whence, void *user_ptr)
  11.199 + * Must seek offset bytes from: the beginning of the file if whence is SEEK_SET,
  11.200 + * the current position if whence is SEEK_CUR, or the end of the file if whence is
  11.201 + * SEEK_END, and return the resulting file offset from the beginning of the file.
  11.202 + * (i.e. seek_func(0, SEEK_CUR, user_ptr); must be equivalent to an ftell).
  11.203 + *
  11.204 + * All three functions get the user-data pointer set through img_io_set_user_data
  11.205 + * as their last argument.
  11.206 + *
  11.207 + * Note: obviously you don't need to set a write function if you're only going
  11.208 + * to call img_read, or the read and seek function if you're only going to call
  11.209 + * img_write.
  11.210 + *
  11.211 + * Note: if the user-supplied write function is buffered, make sure to flush
  11.212 + * (or close the file) after img_write returns.
  11.213 + */
  11.214 +void img_io_set_user_data(struct img_io *io, void *uptr);
  11.215 +void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*));
  11.216 +void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*));
  11.217 +void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*));
  11.218 +
  11.219 +
  11.220 +#ifdef __cplusplus
  11.221 +}
  11.222 +#endif
  11.223 +
  11.224 +
  11.225 +#endif	/* IMAGO_H_ */

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/libs/imago/imago_gl.c	Sun Nov 01 00:36:56 2015 +0200
    12.3 @@ -0,0 +1,223 @@
    12.4 +#include "imago2.h"
    12.5 +
    12.6 +
    12.7 +/* to avoid dependency to OpenGL, I'll define all the relevant GL macros manually */
    12.8 +#define GL_UNSIGNED_BYTE		0x1401
    12.9 +#define GL_FLOAT				0x1406
   12.10 +
   12.11 +#define GL_LUMINANCE			0x1909
   12.12 +#define GL_RGB					0x1907
   12.13 +#define GL_RGBA					0x1908
   12.14 +
   12.15 +#define GL_RGBA32F				0x8814
   12.16 +#define GL_RGB32F				0x8815
   12.17 +#define GL_LUMINANCE32F			0x8818
   12.18 +
   12.19 +#define GL_TEXTURE_2D			0x0de1
   12.20 +#define GL_TEXTURE_WRAP_S		0x2802
   12.21 +#define GL_TEXTURE_WRAP_T		0x2803
   12.22 +#define GL_TEXTURE_MAG_FILTER	0x2800
   12.23 +#define GL_TEXTURE_MIN_FILTER	0x2801
   12.24 +#define GL_LINEAR				0x2601
   12.25 +#define GL_REPEAT				0x2901
   12.26 +
   12.27 +
   12.28 +typedef unsigned int GLenum;
   12.29 +typedef unsigned int GLuint;
   12.30 +typedef int GLint;
   12.31 +typedef int GLsizei;
   12.32 +typedef void GLvoid;
   12.33 +
   12.34 +/* for the same reason I'll load GL functions dynamically */
   12.35 +typedef void (*gl_gen_textures_func)(GLsizei, GLuint*);
   12.36 +typedef void (*gl_bind_texture_func)(GLenum, GLuint);
   12.37 +typedef void (*gl_tex_parameteri_func)(GLenum, GLenum, GLint);
   12.38 +typedef void (*gl_tex_image2d_func)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
   12.39 +
   12.40 +static gl_gen_textures_func gl_gen_textures;
   12.41 +static gl_bind_texture_func gl_bind_texture;
   12.42 +static gl_tex_parameteri_func gl_tex_parameteri;
   12.43 +static gl_tex_image2d_func gl_tex_image2d;
   12.44 +
   12.45 +static int load_glfunc(void);
   12.46 +
   12.47 +unsigned int img_fmt_glfmt(enum img_fmt fmt)
   12.48 +{
   12.49 +	switch(fmt) {
   12.50 +	case IMG_FMT_GREY8:
   12.51 +	case IMG_FMT_GREYF:
   12.52 +		return GL_LUMINANCE;
   12.53 +
   12.54 +	case IMG_FMT_RGB24:
   12.55 +	case IMG_FMT_RGBF:
   12.56 +		return GL_RGB;
   12.57 +
   12.58 +	case IMG_FMT_RGBA32:
   12.59 +	case IMG_FMT_RGBAF:
   12.60 +		return GL_RGBA;
   12.61 +
   12.62 +	default:
   12.63 +		break;
   12.64 +	}
   12.65 +	return 0;
   12.66 +}
   12.67 +
   12.68 +unsigned int img_fmt_gltype(enum img_fmt fmt)
   12.69 +{
   12.70 +	switch(fmt) {
   12.71 +	case IMG_FMT_GREY8:
   12.72 +	case IMG_FMT_RGB24:
   12.73 +	case IMG_FMT_RGBA32:
   12.74 +		return GL_UNSIGNED_BYTE;
   12.75 +
   12.76 +	case IMG_FMT_GREYF:
   12.77 +	case IMG_FMT_RGBF:
   12.78 +	case IMG_FMT_RGBAF:
   12.79 +		return GL_FLOAT;
   12.80 +
   12.81 +	default:
   12.82 +		break;
   12.83 +	}
   12.84 +	return 0;
   12.85 +}
   12.86 +
   12.87 +unsigned int img_fmt_glintfmt(enum img_fmt fmt)
   12.88 +{
   12.89 +	switch(fmt) {
   12.90 +	case IMG_FMT_GREY8:
   12.91 +		return GL_LUMINANCE;
   12.92 +	case IMG_FMT_RGB24:
   12.93 +		return GL_RGB;
   12.94 +	case IMG_FMT_RGBA32:
   12.95 +		return GL_RGBA;
   12.96 +	case IMG_FMT_GREYF:
   12.97 +		return GL_LUMINANCE32F;
   12.98 +	case IMG_FMT_RGBF:
   12.99 +		return GL_RGB32F;
  12.100 +	case IMG_FMT_RGBAF:
  12.101 +		return GL_RGBA32F;
  12.102 +	default:
  12.103 +		break;
  12.104 +	}
  12.105 +	return 0;
  12.106 +}
  12.107 +
  12.108 +unsigned int img_glfmt(struct img_pixmap *img)
  12.109 +{
  12.110 +	return img_fmt_glfmt(img->fmt);
  12.111 +}
  12.112 +
  12.113 +unsigned int img_gltype(struct img_pixmap *img)
  12.114 +{
  12.115 +	return img_fmt_gltype(img->fmt);
  12.116 +}
  12.117 +
  12.118 +unsigned int img_glintfmt(struct img_pixmap *img)
  12.119 +{
  12.120 +	return img_fmt_glintfmt(img->fmt);
  12.121 +}
  12.122 +
  12.123 +unsigned int img_gltexture(struct img_pixmap *img)
  12.124 +{
  12.125 +	unsigned int tex;
  12.126 +	unsigned int intfmt, fmt, type;
  12.127 +
  12.128 +	if(!gl_gen_textures) {
  12.129 +		if(load_glfunc() == -1) {
  12.130 +			fprintf(stderr, "imago: failed to initialize the OpenGL helpers\n");
  12.131 +			return 0;
  12.132 +		}
  12.133 +	}
  12.134 +
  12.135 +	intfmt = img_glintfmt(img);
  12.136 +	fmt = img_glfmt(img);
  12.137 +	type = img_gltype(img);
  12.138 +
  12.139 +	gl_gen_textures(1, &tex);
  12.140 +	gl_bind_texture(GL_TEXTURE_2D, tex);
  12.141 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  12.142 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  12.143 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  12.144 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  12.145 +	gl_tex_image2d(GL_TEXTURE_2D, 0, intfmt, img->width, img->height, 0, fmt, type, img->pixels);
  12.146 +	return tex;
  12.147 +}
  12.148 +
  12.149 +unsigned int img_gltexture_load(const char *fname)
  12.150 +{
  12.151 +	struct img_pixmap img;
  12.152 +	unsigned int tex;
  12.153 +
  12.154 +	img_init(&img);
  12.155 +	if(img_load(&img, fname) == -1) {
  12.156 +		img_destroy(&img);
  12.157 +		return 0;
  12.158 +	}
  12.159 +
  12.160 +	tex = img_gltexture(&img);
  12.161 +	img_destroy(&img);
  12.162 +	return tex;
  12.163 +}
  12.164 +
  12.165 +unsigned int img_gltexture_read_file(FILE *fp)
  12.166 +{
  12.167 +	struct img_pixmap img;
  12.168 +	unsigned int tex;
  12.169 +
  12.170 +	img_init(&img);
  12.171 +	if(img_read_file(&img, fp) == -1) {
  12.172 +		img_destroy(&img);
  12.173 +		return 0;
  12.174 +	}
  12.175 +
  12.176 +	tex = img_gltexture(&img);
  12.177 +	img_destroy(&img);
  12.178 +	return tex;
  12.179 +}
  12.180 +
  12.181 +unsigned int img_gltexture_read(struct img_io *io)
  12.182 +{
  12.183 +	struct img_pixmap img;
  12.184 +	unsigned int tex;
  12.185 +
  12.186 +	img_init(&img);
  12.187 +	if(img_read(&img, io) == -1) {
  12.188 +		img_destroy(&img);
  12.189 +		return 0;
  12.190 +	}
  12.191 +
  12.192 +	tex = img_gltexture(&img);
  12.193 +	img_destroy(&img);
  12.194 +	return tex;
  12.195 +}
  12.196 +
  12.197 +#if defined(__unix__) || defined(__APPLE__)
  12.198 +#ifndef __USE_GNU
  12.199 +#define __USE_GNU
  12.200 +#endif
  12.201 +
  12.202 +#include <dlfcn.h>
  12.203 +#endif
  12.204 +#ifdef WIN32
  12.205 +#include <windows.h>
  12.206 +#endif
  12.207 +
  12.208 +static int load_glfunc(void)
  12.209 +{
  12.210 +#if defined(__unix__) || defined(__APPLE__)
  12.211 +	gl_gen_textures = (gl_gen_textures_func)dlsym(RTLD_DEFAULT, "glGenTextures");
  12.212 +	gl_bind_texture = (gl_bind_texture_func)dlsym(RTLD_DEFAULT, "glBindTexture");
  12.213 +	gl_tex_parameteri = (gl_tex_parameteri_func)dlsym(RTLD_DEFAULT, "glTexParameteri");
  12.214 +	gl_tex_image2d = (gl_tex_image2d_func)dlsym(RTLD_DEFAULT, "glTexImage2D");
  12.215 +#endif
  12.216 +
  12.217 +#ifdef WIN32
  12.218 +	HMODULE handle = GetModuleHandle(0);
  12.219 +	gl_gen_textures = (gl_gen_textures_func)GetProcAddress(handle, "glGenTextures");
  12.220 +	gl_bind_texture = (gl_bind_texture_func)GetProcAddress(handle, "glBindTexture");
  12.221 +	gl_tex_parameteri = (gl_tex_parameteri_func)GetProcAddress(handle, "glTexParameteri");
  12.222 +	gl_tex_image2d = (gl_tex_image2d_func)GetProcAddress(handle, "glTexImage2D");
  12.223 +#endif
  12.224 +
  12.225 +	return (gl_gen_textures && gl_bind_texture && gl_tex_parameteri && gl_tex_image2d) ? 0 : -1;
  12.226 +}

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/libs/imago/modules.c	Sun Nov 01 00:36:56 2015 +0200
    13.3 @@ -0,0 +1,13 @@
    13.4 +/* this file is generated by ./configure, do not edit */
    13.5 +int img_register_jpeg();
    13.6 +int img_register_png();
    13.7 +int img_register_ppm();
    13.8 +int img_register_rgbe();
    13.9 +
   13.10 +void img_modules_init(void)
   13.11 +{
   13.12 +	img_register_jpeg();
   13.13 +	img_register_png();
   13.14 +	img_register_ppm();
   13.15 +	img_register_rgbe();
   13.16 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/libs/libjpeg/README	Sun Nov 01 00:36:56 2015 +0200
    14.3 @@ -0,0 +1,326 @@
    14.4 +The Independent JPEG Group's JPEG software
    14.5 +==========================================
    14.6 +
    14.7 +README for release 8c of 16-Jan-2011
    14.8 +====================================
    14.9 +
   14.10 +This distribution contains the eighth public release of the Independent JPEG
   14.11 +Group's free JPEG software.  You are welcome to redistribute this software and
   14.12 +to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
   14.13 +
   14.14 +This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
   14.15 +Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
   14.16 +Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
   14.17 +and other members of the Independent JPEG Group.
   14.18 +
   14.19 +IJG is not affiliated with the official ISO JPEG standards committee.
   14.20 +
   14.21 +
   14.22 +DOCUMENTATION ROADMAP
   14.23 +=====================
   14.24 +
   14.25 +This file contains the following sections:
   14.26 +
   14.27 +OVERVIEW            General description of JPEG and the IJG software.
   14.28 +LEGAL ISSUES        Copyright, lack of warranty, terms of distribution.
   14.29 +REFERENCES          Where to learn more about JPEG.
   14.30 +ARCHIVE LOCATIONS   Where to find newer versions of this software.
   14.31 +ACKNOWLEDGMENTS     Special thanks.
   14.32 +FILE FORMAT WARS    Software *not* to get.
   14.33 +TO DO               Plans for future IJG releases.
   14.34 +
   14.35 +Other documentation files in the distribution are:
   14.36 +
   14.37 +User documentation:
   14.38 +  install.txt       How to configure and install the IJG software.
   14.39 +  usage.txt         Usage instructions for cjpeg, djpeg, jpegtran,
   14.40 +                    rdjpgcom, and wrjpgcom.
   14.41 +  *.1               Unix-style man pages for programs (same info as usage.txt).
   14.42 +  wizard.txt        Advanced usage instructions for JPEG wizards only.
   14.43 +  change.log        Version-to-version change highlights.
   14.44 +Programmer and internal documentation:
   14.45 +  libjpeg.txt       How to use the JPEG library in your own programs.
   14.46 +  example.c         Sample code for calling the JPEG library.
   14.47 +  structure.txt     Overview of the JPEG library's internal structure.
   14.48 +  filelist.txt      Road map of IJG files.
   14.49 +  coderules.txt     Coding style rules --- please read if you contribute code.
   14.50 +
   14.51 +Please read at least the files install.txt and usage.txt.  Some information
   14.52 +can also be found in the JPEG FAQ (Frequently Asked Questions) article.  See
   14.53 +ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.
   14.54 +
   14.55 +If you want to understand how the JPEG code works, we suggest reading one or
   14.56 +more of the REFERENCES, then looking at the documentation files (in roughly
   14.57 +the order listed) before diving into the code.
   14.58 +
   14.59 +
   14.60 +OVERVIEW
   14.61 +========
   14.62 +
   14.63 +This package contains C software to implement JPEG image encoding, decoding,
   14.64 +and transcoding.  JPEG (pronounced "jay-peg") is a standardized compression
   14.65 +method for full-color and gray-scale images.
   14.66 +
   14.67 +This software implements JPEG baseline, extended-sequential, and progressive
   14.68 +compression processes.  Provision is made for supporting all variants of these
   14.69 +processes, although some uncommon parameter settings aren't implemented yet.
   14.70 +We have made no provision for supporting the hierarchical or lossless
   14.71 +processes defined in the standard.
   14.72 +
   14.73 +We provide a set of library routines for reading and writing JPEG image files,
   14.74 +plus two sample applications "cjpeg" and "djpeg", which use the library to
   14.75 +perform conversion between JPEG and some other popular image file formats.
   14.76 +The library is intended to be reused in other applications.
   14.77 +
   14.78 +In order to support file conversion and viewing software, we have included
   14.79 +considerable functionality beyond the bare JPEG coding/decoding capability;
   14.80 +for example, the color quantization modules are not strictly part of JPEG
   14.81 +decoding, but they are essential for output to colormapped file formats or
   14.82 +colormapped displays.  These extra functions can be compiled out of the
   14.83 +library if not required for a particular application.
   14.84 +
   14.85 +We have also included "jpegtran", a utility for lossless transcoding between
   14.86 +different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple
   14.87 +applications for inserting and extracting textual comments in JFIF files.
   14.88 +
   14.89 +The emphasis in designing this software has been on achieving portability and
   14.90 +flexibility, while also making it fast enough to be useful.  In particular,
   14.91 +the software is not intended to be read as a tutorial on JPEG.  (See the
   14.92 +REFERENCES section for introductory material.)  Rather, it is intended to
   14.93 +be reliable, portable, industrial-strength code.  We do not claim to have
   14.94 +achieved that goal in every aspect of the software, but we strive for it.
   14.95 +
   14.96 +We welcome the use of this software as a component of commercial products.
   14.97 +No royalty is required, but we do ask for an acknowledgement in product
   14.98 +documentation, as described under LEGAL ISSUES.
   14.99 +
  14.100 +
  14.101 +LEGAL ISSUES
  14.102 +============
  14.103 +
  14.104 +In plain English:
  14.105 +
  14.106 +1. We don't promise that this software works.  (But if you find any bugs,
  14.107 +   please let us know!)
  14.108 +2. You can use this software for whatever you want.  You don't have to pay us.
  14.109 +3. You may not pretend that you wrote this software.  If you use it in a
  14.110 +   program, you must acknowledge somewhere in your documentation that
  14.111 +   you've used the IJG code.
  14.112 +
  14.113 +In legalese:
  14.114 +
  14.115 +The authors make NO WARRANTY or representation, either express or implied,
  14.116 +with respect to this software, its quality, accuracy, merchantability, or
  14.117 +fitness for a particular purpose.  This software is provided "AS IS", and you,
  14.118 +its user, assume the entire risk as to its quality and accuracy.
  14.119 +
  14.120 +This software is copyright (C) 1991-2011, Thomas G. Lane, Guido Vollbeding.
  14.121 +All Rights Reserved except as specified below.
  14.122 +
  14.123 +Permission is hereby granted to use, copy, modify, and distribute this
  14.124 +software (or portions thereof) for any purpose, without fee, subject to these
  14.125 +conditions:
  14.126 +(1) If any part of the source code for this software is distributed, then this
  14.127 +README file must be included, with this copyright and no-warranty notice
  14.128 +unaltered; and any additions, deletions, or changes to the original files
  14.129 +must be clearly indicated in accompanying documentation.
  14.130 +(2) If only executable code is distributed, then the accompanying
  14.131 +documentation must state that "this software is based in part on the work of
  14.132 +the Independent JPEG Group".
  14.133 +(3) Permission for use of this software is granted only if the user accepts
  14.134 +full responsibility for any undesirable consequences; the authors accept
  14.135 +NO LIABILITY for damages of any kind.
  14.136 +
  14.137 +These conditions apply to any software derived from or based on the IJG code,
  14.138 +not just to the unmodified library.  If you use our work, you ought to
  14.139 +acknowledge us.
  14.140 +
  14.141 +Permission is NOT granted for the use of any IJG author's name or company name
  14.142 +in advertising or publicity relating to this software or products derived from
  14.143 +it.  This software may be referred to only as "the Independent JPEG Group's
  14.144 +software".
  14.145 +
  14.146 +We specifically permit and encourage the use of this software as the basis of
  14.147 +commercial products, provided that all warranty or liability claims are
  14.148 +assumed by the product vendor.
  14.149 +
  14.150 +
  14.151 +ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
  14.152 +sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
  14.153 +ansi2knr.c is NOT covered by the above copyright and conditions, but instead
  14.154 +by the usual distribution terms of the Free Software Foundation; principally,
  14.155 +that you must include source code if you redistribute it.  (See the file
  14.156 +ansi2knr.c for full details.)  However, since ansi2knr.c is not needed as part
  14.157 +of any program generated from the IJG code, this does not limit you more than
  14.158 +the foregoing paragraphs do.
  14.159 +
  14.160 +The Unix configuration script "configure" was produced with GNU Autoconf.
  14.161 +It is copyright by the Free Software Foundation but is freely distributable.
  14.162 +The same holds for its supporting scripts (config.guess, config.sub,
  14.163 +ltmain.sh).  Another support script, install-sh, is copyright by X Consortium
  14.164 +but is also freely distributable.
  14.165 +
  14.166 +The IJG distribution formerly included code to read and write GIF files.
  14.167 +To avoid entanglement with the Unisys LZW patent, GIF reading support has
  14.168 +been removed altogether, and the GIF writer has been simplified to produce
  14.169 +"uncompressed GIFs".  This technique does not use the LZW algorithm; the
  14.170 +resulting GIF files are larger than usual, but are readable by all standard
  14.171 +GIF decoders.
  14.172 +
  14.173 +We are required to state that
  14.174 +    "The Graphics Interchange Format(c) is the Copyright property of
  14.175 +    CompuServe Incorporated.  GIF(sm) is a Service Mark property of
  14.176 +    CompuServe Incorporated."
  14.177 +
  14.178 +
  14.179 +REFERENCES
  14.180 +==========
  14.181 +
  14.182 +We recommend reading one or more of these references before trying to
  14.183 +understand the innards of the JPEG software.
  14.184 +
  14.185 +The best short technical introduction to the JPEG compression algorithm is
  14.186 +	Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
  14.187 +	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
  14.188 +(Adjacent articles in that issue discuss MPEG motion picture compression,
  14.189 +applications of JPEG, and related topics.)  If you don't have the CACM issue
  14.190 +handy, a PostScript file containing a revised version of Wallace's article is
  14.191 +available at http://www.ijg.org/files/wallace.ps.gz.  The file (actually
  14.192 +a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
  14.193 +omits the sample images that appeared in CACM, but it includes corrections
  14.194 +and some added material.  Note: the Wallace article is copyright ACM and IEEE,
  14.195 +and it may not be used for commercial purposes.
  14.196 +
  14.197 +A somewhat less technical, more leisurely introduction to JPEG can be found in
  14.198 +"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
  14.199 +M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1.  This book provides
  14.200 +good explanations and example C code for a multitude of compression methods
  14.201 +including JPEG.  It is an excellent source if you are comfortable reading C
  14.202 +code but don't know much about data compression in general.  The book's JPEG
  14.203 +sample code is far from industrial-strength, but when you are ready to look
  14.204 +at a full implementation, you've got one here...
  14.205 +
  14.206 +The best currently available description of JPEG is the textbook "JPEG Still
  14.207 +Image Data Compression Standard" by William B. Pennebaker and Joan L.
  14.208 +Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
  14.209 +Price US$59.95, 638 pp.  The book includes the complete text of the ISO JPEG
  14.210 +standards (DIS 10918-1 and draft DIS 10918-2).
  14.211 +Although this is by far the most detailed and comprehensive exposition of
  14.212 +JPEG publicly available, we point out that it is still missing an explanation
  14.213 +of the most essential properties and algorithms of the underlying DCT
  14.214 +technology.
  14.215 +If you think that you know about DCT-based JPEG after reading this book,
  14.216 +then you are in delusion.  The real fundamentals and corresponding potential
  14.217 +of DCT-based JPEG are not publicly known so far, and that is the reason for
  14.218 +all the mistaken developments taking place in the image coding domain.
  14.219 +
  14.220 +The original JPEG standard is divided into two parts, Part 1 being the actual
  14.221 +specification, while Part 2 covers compliance testing methods.  Part 1 is
  14.222 +titled "Digital Compression and Coding of Continuous-tone Still Images,
  14.223 +Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
  14.224 +10918-1, ITU-T T.81.  Part 2 is titled "Digital Compression and Coding of
  14.225 +Continuous-tone Still Images, Part 2: Compliance testing" and has document
  14.226 +numbers ISO/IEC IS 10918-2, ITU-T T.83.
  14.227 +IJG JPEG 8 introduces an implementation of the JPEG SmartScale extension
  14.228 +which is specified in a contributed document at ITU and ISO with title "ITU-T
  14.229 +JPEG-Plus Proposal for Extending ITU-T T.81 for Advanced Image Coding", April
  14.230 +2006, Geneva, Switzerland.  The latest version of the document is Revision 3.
  14.231 +
  14.232 +The JPEG standard does not specify all details of an interchangeable file
  14.233 +format.  For the omitted details we follow the "JFIF" conventions, revision
  14.234 +1.02.  JFIF 1.02 has been adopted as an Ecma International Technical Report
  14.235 +and thus received a formal publication status.  It is available as a free
  14.236 +download in PDF format from
  14.237 +http://www.ecma-international.org/publications/techreports/E-TR-098.htm.
  14.238 +A PostScript version of the JFIF document is available at
  14.239 +http://www.ijg.org/files/jfif.ps.gz.  There is also a plain text version at
  14.240 +http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.
  14.241 +
  14.242 +The TIFF 6.0 file format specification can be obtained by FTP from
  14.243 +ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz.  The JPEG incorporation scheme
  14.244 +found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
  14.245 +IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
  14.246 +Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
  14.247 +(Compression tag 7).  Copies of this Note can be obtained from
  14.248 +http://www.ijg.org/files/.  It is expected that the next revision
  14.249 +of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
  14.250 +Although IJG's own code does not support TIFF/JPEG, the free libtiff library
  14.251 +uses our library to implement TIFF/JPEG per the Note.
  14.252 +
  14.253 +
  14.254 +ARCHIVE LOCATIONS
  14.255 +=================
  14.256 +
  14.257 +The "official" archive site for this software is www.ijg.org.
  14.258 +The most recent released version can always be found there in
  14.259 +directory "files".  This particular version will be archived as
  14.260 +http://www.ijg.org/files/jpegsrc.v8c.tar.gz, and in Windows-compatible
  14.261 +"zip" archive format as http://www.ijg.org/files/jpegsr8c.zip.
  14.262 +
  14.263 +The JPEG FAQ (Frequently Asked Questions) article is a source of some
  14.264 +general information about JPEG.
  14.265 +It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/
  14.266 +and other news.answers archive sites, including the official news.answers
  14.267 +archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.
  14.268 +If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu
  14.269 +with body
  14.270 +	send usenet/news.answers/jpeg-faq/part1
  14.271 +	send usenet/news.answers/jpeg-faq/part2
  14.272 +
  14.273 +
  14.274 +ACKNOWLEDGMENTS
  14.275 +===============
  14.276 +
  14.277 +Thank to Juergen Bruder for providing me with a copy of the common DCT
  14.278 +algorithm article, only to find out that I had come to the same result
  14.279 +in a more direct and comprehensible way with a more generative approach.
  14.280 +
  14.281 +Thank to Istvan Sebestyen and Joan L. Mitchell for inviting me to the
  14.282 +ITU JPEG (Study Group 16) meeting in Geneva, Switzerland.
  14.283 +
  14.284 +Thank to Thomas Wiegand and Gary Sullivan for inviting me to the
  14.285 +Joint Video Team (MPEG & ITU) meeting in Geneva, Switzerland.
  14.286 +
  14.287 +Thank to John Korejwa and Massimo Ballerini for inviting me to
  14.288 +fruitful consultations in Boston, MA and Milan, Italy.
  14.289 +
  14.290 +Thank to Hendrik Elstner, Roland Fassauer, Simone Zuck, Guenther
  14.291 +Maier-Gerber, Walter Stoeber, Fred Schmitz, and Norbert Braunagel
  14.292 +for corresponding business development.
  14.293 +
  14.294 +Thank to Nico Zschach and Dirk Stelling of the technical support team
  14.295 +at the Digital Images company in Halle for providing me with extra
  14.296 +equipment for configuration tests.
  14.297 +
  14.298 +Thank to Richard F. Lyon (then of Foveon Inc.) for fruitful
  14.299 +communication about JPEG configuration in Sigma Photo Pro software.
  14.300 +
  14.301 +Thank to Andrew Finkenstadt for hosting the ijg.org site.
  14.302 +
  14.303 +Last but not least special thank to Thomas G. Lane for the original
  14.304 +design and development of this singular software package.
  14.305 +
  14.306 +
  14.307 +FILE FORMAT WARS
  14.308 +================
  14.309 +
  14.310 +The ISO JPEG standards committee actually promotes different formats like
  14.311 +"JPEG 2000" or "JPEG XR" which are incompatible with original DCT-based
  14.312 +JPEG and which are based on faulty technologies.  IJG therefore does not
  14.313 +and will not support such momentary mistakes (see REFERENCES).
  14.314 +We have little or no sympathy for the promotion of these formats.  Indeed,
  14.315 +one of the original reasons for developing this free software was to help
  14.316 +force convergence on common, interoperable format standards for JPEG files.
  14.317 +Don't use an incompatible file format!
  14.318 +(In any case, our decoder will remain capable of reading existing JPEG
  14.319 +image files indefinitely.)
  14.320 +
  14.321 +
  14.322 +TO DO
  14.323 +=====
  14.324 +
  14.325 +Version 8 is the first release of a new generation JPEG standard
  14.326 +to overcome the limitations of the original JPEG specification.
  14.327 +More features are being prepared for coming releases...
  14.328 +
  14.329 +Please send bug reports, offers of help, etc. to jpeg-info@uc.ag.

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/libs/libjpeg/cderror.h	Sun Nov 01 00:36:56 2015 +0200
    15.3 @@ -0,0 +1,132 @@
    15.4 +/*
    15.5 + * cderror.h
    15.6 + *
    15.7 + * Copyright (C) 1994-1997, Thomas G. Lane.
    15.8 + * This file is part of the Independent JPEG Group's software.
    15.9 + * For conditions of distribution and use, see the accompanying README file.
   15.10 + *
   15.11 + * This file defines the error and message codes for the cjpeg/djpeg
   15.12 + * applications.  These strings are not needed as part of the JPEG library
   15.13 + * proper.
   15.14 + * Edit this file to add new codes, or to translate the message strings to
   15.15 + * some other language.
   15.16 + */
   15.17 +
   15.18 +/*
   15.19 + * To define the enum list of message codes, include this file without
   15.20 + * defining macro JMESSAGE.  To create a message string table, include it
   15.21 + * again with a suitable JMESSAGE definition (see jerror.c for an example).
   15.22 + */
   15.23 +#ifndef JMESSAGE
   15.24 +#ifndef CDERROR_H
   15.25 +#define CDERROR_H
   15.26 +/* First time through, define the enum list */
   15.27 +#define JMAKE_ENUM_LIST
   15.28 +#else
   15.29 +/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
   15.30 +#define JMESSAGE(code,string)
   15.31 +#endif /* CDERROR_H */
   15.32 +#endif /* JMESSAGE */
   15.33 +
   15.34 +#ifdef JMAKE_ENUM_LIST
   15.35 +
   15.36 +typedef enum {
   15.37 +
   15.38 +#define JMESSAGE(code,string)	code ,
   15.39 +
   15.40 +#endif /* JMAKE_ENUM_LIST */
   15.41 +
   15.42 +JMESSAGE(JMSG_FIRSTADDONCODE=1000, NULL) /* Must be first entry! */
   15.43 +
   15.44 +#ifdef BMP_SUPPORTED
   15.45 +JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format")
   15.46 +JMESSAGE(JERR_BMP_BADDEPTH, "Only 8- and 24-bit BMP files are supported")
   15.47 +JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length")
   15.48 +JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1")
   15.49 +JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB")
   15.50 +JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported")
   15.51 +JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM")
   15.52 +JMESSAGE(JTRC_BMP, "%ux%u 24-bit BMP image")
   15.53 +JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image")
   15.54 +JMESSAGE(JTRC_BMP_OS2, "%ux%u 24-bit OS2 BMP image")
   15.55 +JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image")
   15.56 +#endif /* BMP_SUPPORTED */
   15.57 +
   15.58 +#ifdef GIF_SUPPORTED
   15.59 +JMESSAGE(JERR_GIF_BUG, "GIF output got confused")
   15.60 +JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d")
   15.61 +JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB")
   15.62 +JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file")
   15.63 +JMESSAGE(JERR_GIF_NOT, "Not a GIF file")
   15.64 +JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image")
   15.65 +JMESSAGE(JTRC_GIF_BADVERSION,
   15.66 +	 "Warning: unexpected GIF version number '%c%c%c'")
   15.67 +JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x")
   15.68 +JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input")
   15.69 +JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file")
   15.70 +JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring")
   15.71 +JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image")
   15.72 +JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits")
   15.73 +#endif /* GIF_SUPPORTED */
   15.74 +
   15.75 +#ifdef PPM_SUPPORTED
   15.76 +JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB")
   15.77 +JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file")
   15.78 +JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file")
   15.79 +JMESSAGE(JTRC_PGM, "%ux%u PGM image")
   15.80 +JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image")
   15.81 +JMESSAGE(JTRC_PPM, "%ux%u PPM image")
   15.82 +JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image")
   15.83 +#endif /* PPM_SUPPORTED */
   15.84 +
   15.85 +#ifdef RLE_SUPPORTED
   15.86 +JMESSAGE(JERR_RLE_BADERROR, "Bogus error code from RLE library")
   15.87 +JMESSAGE(JERR_RLE_COLORSPACE, "RLE output must be grayscale or RGB")
   15.88 +JMESSAGE(JERR_RLE_DIMENSIONS, "Image dimensions (%ux%u) too large for RLE")
   15.89 +JMESSAGE(JERR_RLE_EMPTY, "Empty RLE file")
   15.90 +JMESSAGE(JERR_RLE_EOF, "Premature EOF in RLE header")
   15.91 +JMESSAGE(JERR_RLE_MEM, "Insufficient memory for RLE header")
   15.92 +JMESSAGE(JERR_RLE_NOT, "Not an RLE file")
   15.93 +JMESSAGE(JERR_RLE_TOOMANYCHANNELS, "Cannot handle %d output channels for RLE")
   15.94 +JMESSAGE(JERR_RLE_UNSUPPORTED, "Cannot handle this RLE setup")
   15.95 +JMESSAGE(JTRC_RLE, "%ux%u full-color RLE file")
   15.96 +JMESSAGE(JTRC_RLE_FULLMAP, "%ux%u full-color RLE file with map of length %d")
   15.97 +JMESSAGE(JTRC_RLE_GRAY, "%ux%u grayscale RLE file")
   15.98 +JMESSAGE(JTRC_RLE_MAPGRAY, "%ux%u grayscale RLE file with map of length %d")
   15.99 +JMESSAGE(JTRC_RLE_MAPPED, "%ux%u colormapped RLE file with map of length %d")
  15.100 +#endif /* RLE_SUPPORTED */
  15.101 +
  15.102 +#ifdef TARGA_SUPPORTED
  15.103 +JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format")
  15.104 +JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file")
  15.105 +JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB")
  15.106 +JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image")
  15.107 +JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image")
  15.108 +JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image")
  15.109 +#else
  15.110 +JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled")
  15.111 +#endif /* TARGA_SUPPORTED */
  15.112 +
  15.113 +JMESSAGE(JERR_BAD_CMAP_FILE,
  15.114 +	 "Color map file is invalid or of unsupported format")
  15.115 +JMESSAGE(JERR_TOO_MANY_COLORS,
  15.116 +	 "Output file format cannot handle %d colormap entries")
  15.117 +JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed")
  15.118 +#ifdef TARGA_SUPPORTED
  15.119 +JMESSAGE(JERR_UNKNOWN_FORMAT,
  15.120 +	 "Unrecognized input file format --- perhaps you need -targa")
  15.121 +#else
  15.122 +JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format")
  15.123 +#endif
  15.124 +JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format")
  15.125 +
  15.126 +#ifdef JMAKE_ENUM_LIST
  15.127 +
  15.128 +  JMSG_LASTADDONCODE
  15.129 +} ADDON_MESSAGE_CODE;
  15.130 +
  15.131 +#undef JMAKE_ENUM_LIST
  15.132 +#endif /* JMAKE_ENUM_LIST */
  15.133 +
  15.134 +/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
  15.135 +#undef JMESSAGE