1.1 --- a/Makefile	Thu Sep 08 04:23:56 2011 +0300
     1.2 +++ b/Makefile	Thu Sep 08 06:28:38 2011 +0300
     1.3 @@ -1,14 +1,28 @@
     1.4  src = $(wildcard src/*.c)
     1.5 +
     1.6  obj = $(src:.c=.o)
     1.7 +dep = $(obj:.o=.d)
     1.8  bin = test
     1.9  
    1.10  CC = gcc
    1.11 -CFLAGS = -pedantic -Wall -g
    1.12 +CFLAGS = -pedantic -Wall -g $(incdir)
    1.13  LDFLAGS = -lGL -lGLU -lglut -lGLEW -lm
    1.14  
    1.15 +include libs/Makefile
    1.16 +
    1.17  $(bin): $(obj)
    1.18  	$(CC) -o $@ $(obj) $(LDFLAGS)
    1.19  
    1.20 +-include $(dep)
    1.21 +
    1.22 +%.d: %.c
    1.23 +	@$(CPP) $(CFLAGS) -MM -MT $(@:.d=.o) $< >$@
    1.24 +
    1.25 +
    1.26  .PHONY: clean
    1.27  clean:
    1.28  	rm -f $(obj) $(bin)
    1.29 +
    1.30 +.PHONY: cleandep
    1.31 +cleandep:
    1.32 +	rm -f $(dep)

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/libs/Makefile	Thu Sep 08 06:28:38 2011 +0300
     2.3 @@ -0,0 +1,6 @@
     2.4 +src += $(wildcard libs/zlib/*.c) \
     2.5 +	   $(wildcard libs/libpng/*.c) \
     2.6 +	   $(wildcard libs/libjpeg/*.c) \
     2.7 +	   $(wildcard libs/imago2/*.c)
     2.8 +
     2.9 +incdir += -Ilibs/imago2 -Ilibs/zlib -Ilibs/libpng -Ilibs/libjpeg

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/libs/imago2/conv.c	Thu Sep 08 06:28:38 2011 +0300
     3.3 @@ -0,0 +1,251 @@
     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 +	memcpy(unp, pptr, count * sizeof *unp);
   3.135 +}
   3.136 +
   3.137 +static void unpack_greyf(struct pixel *unp, void *pptr, int count)
   3.138 +{
   3.139 +	int i;
   3.140 +	float *pix = pptr;
   3.141 +
   3.142 +	for(i=0; i<count; i++) {
   3.143 +		unp->r = unp->g = unp->b = *pix++;
   3.144 +		unp->a = 1.0;
   3.145 +		unp++;
   3.146 +	}
   3.147 +}
   3.148 +
   3.149 +static void unpack_rgbf(struct pixel *unp, void *pptr, int count)
   3.150 +{
   3.151 +	int i;
   3.152 +	float *pix = pptr;
   3.153 +
   3.154 +	for(i=0; i<count; i++) {
   3.155 +		unp->r = *pix++;
   3.156 +		unp->g = *pix++;
   3.157 +		unp->b = *pix++;
   3.158 +		unp->a = 1.0;
   3.159 +		unp++;
   3.160 +	}
   3.161 +}
   3.162 +
   3.163 +static void unpack_rgbaf(struct pixel *unp, void *pptr, int count)
   3.164 +{
   3.165 +	int i;
   3.166 +	float *pix = pptr;
   3.167 +
   3.168 +	for(i=0; i<count; i++) {
   3.169 +		unp->r = *pix++;
   3.170 +		unp->g = *pix++;
   3.171 +		unp->b = *pix++;
   3.172 +		unp->a = *pix++;
   3.173 +		unp++;
   3.174 +	}
   3.175 +}
   3.176 +
   3.177 +
   3.178 +static void pack_grey8(void *pptr, struct pixel *unp, int count)
   3.179 +{
   3.180 +	int i;
   3.181 +	unsigned char *pix = pptr;
   3.182 +
   3.183 +	for(i=0; i<count; i++) {
   3.184 +		int lum = (int)(255.0 * (unp->r + unp->g + unp->b) / 3.0);
   3.185 +		*pix++ = CLAMP(lum, 0, 255);
   3.186 +		unp++;
   3.187 +	}
   3.188 +}
   3.189 +
   3.190 +static void pack_rgb24(void *pptr, struct pixel *unp, int count)
   3.191 +{
   3.192 +	int i;
   3.193 +	unsigned char *pix = pptr;
   3.194 +
   3.195 +	for(i=0; i<count; i++) {
   3.196 +		int r = (int)(unp->r * 255.0);
   3.197 +		int g = (int)(unp->g * 255.0);
   3.198 +		int b = (int)(unp->b * 255.0);
   3.199 +
   3.200 +		*pix++ = CLAMP(r, 0, 255);
   3.201 +		*pix++ = CLAMP(g, 0, 255);
   3.202 +		*pix++ = CLAMP(b, 0, 255);
   3.203 +		unp++;
   3.204 +	}
   3.205 +}
   3.206 +
   3.207 +static void pack_rgba32(void *pptr, struct pixel *unp, int count)
   3.208 +{
   3.209 +	int i;
   3.210 +	unsigned char *pix = pptr;
   3.211 +
   3.212 +	for(i=0; i<count; i++) {
   3.213 +		int r = (int)(unp->r * 255.0);
   3.214 +		int g = (int)(unp->g * 255.0);
   3.215 +		int b = (int)(unp->b * 255.0);
   3.216 +		int a = (int)(unp->a * 255.0);
   3.217 +
   3.218 +		*pix++ = CLAMP(r, 0, 255);
   3.219 +		*pix++ = CLAMP(g, 0, 255);
   3.220 +		*pix++ = CLAMP(b, 0, 255);
   3.221 +		*pix++ = CLAMP(a, 0, 255);
   3.222 +		unp++;
   3.223 +	}
   3.224 +}
   3.225 +
   3.226 +static void pack_greyf(void *pptr, struct pixel *unp, int count)
   3.227 +{
   3.228 +	int i;
   3.229 +	float *pix = pptr;
   3.230 +
   3.231 +	for(i=0; i<count; i++) {
   3.232 +		*pix++ = (unp->r + unp->g + unp->b) / 3.0;
   3.233 +		unp++;
   3.234 +	}
   3.235 +}
   3.236 +
   3.237 +static void pack_rgbf(void *pptr, struct pixel *unp, int count)
   3.238 +{
   3.239 +	int i;
   3.240 +	float *pix = pptr;
   3.241 +
   3.242 +	for(i=0; i<count; i++) {
   3.243 +		*pix++ = unp->r;
   3.244 +		*pix++ = unp->g;
   3.245 +		*pix++ = unp->b;
   3.246 +		unp++;
   3.247 +	}
   3.248 +}
   3.249 +
   3.250 +static void pack_rgbaf(void *pptr, struct pixel *unp, int count)
   3.251 +{
   3.252 +	memcpy(pptr, unp, count * sizeof *unp);
   3.253 +}
   3.254 +

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/libs/imago2/file_jpeg.c	Thu Sep 08 06:28:38 2011 +0300
     4.3 @@ -0,0 +1,291 @@
     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 read(struct img_pixmap *img, struct img_io *io);
    4.59 +static int write(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 int 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 int 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, read, write};
    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 + 6, "JFIF", 4) != 0) {
    4.91 +		io->seek(pos, SEEK_SET, io->uptr);
    4.92 +		return -1;
    4.93 +	}
    4.94 +	io->seek(pos, SEEK_SET, io->uptr);
    4.95 +	return 0;
    4.96 +}
    4.97 +
    4.98 +static int read(struct img_pixmap *img, struct img_io *io)
    4.99 +{
   4.100 +	int i, nlines = 0;
   4.101 +	struct jpeg_decompress_struct cinfo;
   4.102 +	struct jpeg_error_mgr jerr;
   4.103 +	struct src_mgr src;
   4.104 +	unsigned char **scanlines;
   4.105 +
   4.106 +	cinfo.err = jpeg_std_error(&jerr);	/* XXX change... */
   4.107 +	jpeg_create_decompress(&cinfo);
   4.108 +
   4.109 +	src.pub.init_source = init_source;
   4.110 +	src.pub.fill_input_buffer = fill_input_buffer;
   4.111 +	src.pub.skip_input_data = skip_input_data;
   4.112 +	src.pub.resync_to_restart = jpeg_resync_to_restart;
   4.113 +	src.pub.term_source = term_source;
   4.114 +	src.pub.next_input_byte = 0;
   4.115 +	src.pub.bytes_in_buffer = 0;
   4.116 +	src.io = io;
   4.117 +	cinfo.src = (struct jpeg_source_mgr*)&src;
   4.118 +
   4.119 +	jpeg_read_header(&cinfo, 1);
   4.120 +	cinfo.out_color_space = JCS_RGB;
   4.121 +
   4.122 +	if(img_set_pixels(img, cinfo.image_width, cinfo.image_height, IMG_FMT_RGB24, 0) == -1) {
   4.123 +		jpeg_destroy_decompress(&cinfo);
   4.124 +		return -1;
   4.125 +	}
   4.126 +
   4.127 +	if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
   4.128 +		jpeg_destroy_decompress(&cinfo);
   4.129 +		return -1;
   4.130 +	}
   4.131 +	scanlines[0] = img->pixels;
   4.132 +	for(i=1; i<img->height; i++) {
   4.133 +		scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
   4.134 +	}
   4.135 +
   4.136 +	jpeg_start_decompress(&cinfo);
   4.137 +	while(nlines < img->height) {
   4.138 +		int res = jpeg_read_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
   4.139 +		nlines += res;
   4.140 +	}
   4.141 +	jpeg_finish_decompress(&cinfo);
   4.142 +	jpeg_destroy_decompress(&cinfo);
   4.143 +
   4.144 +	free(scanlines);
   4.145 +	return 0;
   4.146 +}
   4.147 +
   4.148 +static int write(struct img_pixmap *img, struct img_io *io)
   4.149 +{
   4.150 +	int i, nlines = 0;
   4.151 +	struct jpeg_compress_struct cinfo;
   4.152 +	struct jpeg_error_mgr jerr;
   4.153 +	struct dst_mgr dest;
   4.154 +	struct img_pixmap tmpimg;
   4.155 +	unsigned char **scanlines;
   4.156 +
   4.157 +	img_init(&tmpimg);
   4.158 +
   4.159 +	if(img->fmt != IMG_FMT_RGB24) {
   4.160 +		if(img_copy(&tmpimg, img) == -1) {
   4.161 +			return -1;
   4.162 +		}
   4.163 +		if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
   4.164 +			img_destroy(&tmpimg);
   4.165 +			return -1;
   4.166 +		}
   4.167 +		img = &tmpimg;
   4.168 +	}
   4.169 +
   4.170 +	if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
   4.171 +		img_destroy(&tmpimg);
   4.172 +		return -1;
   4.173 +	}
   4.174 +	scanlines[0] = img->pixels;
   4.175 +	for(i=1; i<img->height; i++) {
   4.176 +		scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
   4.177 +	}
   4.178 +
   4.179 +	cinfo.err = jpeg_std_error(&jerr);	/* XXX */
   4.180 +	jpeg_create_compress(&cinfo);
   4.181 +
   4.182 +	dest.pub.init_destination = init_destination;
   4.183 +	dest.pub.empty_output_buffer = empty_output_buffer;
   4.184 +	dest.pub.term_destination = term_destination;
   4.185 +	dest.io = io;
   4.186 +	cinfo.dest = (struct jpeg_destination_mgr*)&dest;
   4.187 +
   4.188 +	cinfo.image_width = img->width;
   4.189 +	cinfo.image_height = img->height;
   4.190 +	cinfo.input_components = 3;
   4.191 +	cinfo.in_color_space = JCS_RGB;
   4.192 +
   4.193 +	jpeg_set_defaults(&cinfo);
   4.194 +
   4.195 +	jpeg_start_compress(&cinfo, 1);
   4.196 +	while(nlines < img->height) {
   4.197 +		int res = jpeg_write_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
   4.198 +		nlines += res;
   4.199 +	}
   4.200 +	jpeg_finish_compress(&cinfo);
   4.201 +	jpeg_destroy_compress(&cinfo);
   4.202 +
   4.203 +	free(scanlines);
   4.204 +	img_destroy(&tmpimg);
   4.205 +	return 0;
   4.206 +}
   4.207 +
   4.208 +/* -- read source functions --
   4.209 + * the following functions are adapted from jdatasrc.c in jpeglib
   4.210 + */
   4.211 +static void init_source(j_decompress_ptr jd)
   4.212 +{
   4.213 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   4.214 +	src->start_of_file = 1;
   4.215 +}
   4.216 +
   4.217 +static int fill_input_buffer(j_decompress_ptr jd)
   4.218 +{
   4.219 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   4.220 +	size_t nbytes;
   4.221 +
   4.222 +	nbytes = src->io->read(src->buffer, INPUT_BUF_SIZE, src->io->uptr);
   4.223 +
   4.224 +	if(nbytes <= 0) {
   4.225 +		if(src->start_of_file) {
   4.226 +			return 0;
   4.227 +		}
   4.228 +		/* insert a fake EOI marker */
   4.229 +		src->buffer[0] = 0xff;
   4.230 +		src->buffer[1] = JPEG_EOI;
   4.231 +		nbytes = 2;
   4.232 +	}
   4.233 +
   4.234 +	src->pub.next_input_byte = src->buffer;
   4.235 +	src->pub.bytes_in_buffer = nbytes;
   4.236 +	src->start_of_file = 0;
   4.237 +	return 1;
   4.238 +}
   4.239 +
   4.240 +static void skip_input_data(j_decompress_ptr jd, long num_bytes)
   4.241 +{
   4.242 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   4.243 +
   4.244 +	if(num_bytes > 0) {
   4.245 +		while(num_bytes > (long)src->pub.bytes_in_buffer) {
   4.246 +			num_bytes -= (long)src->pub.bytes_in_buffer;
   4.247 +			fill_input_buffer(jd);
   4.248 +		}
   4.249 +		src->pub.next_input_byte += (size_t)num_bytes;
   4.250 +		src->pub.bytes_in_buffer -= (size_t)num_bytes;
   4.251 +	}
   4.252 +}
   4.253 +
   4.254 +static void term_source(j_decompress_ptr jd)
   4.255 +{
   4.256 +	/* nothing to see here, move along */
   4.257 +}
   4.258 +
   4.259 +
   4.260 +/* -- write destination functions --
   4.261 + * the following functions are adapted from jdatadst.c in jpeglib
   4.262 + */
   4.263 +static void init_destination(j_compress_ptr jc)
   4.264 +{
   4.265 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   4.266 +
   4.267 +	dest->pub.next_output_byte = dest->buffer;
   4.268 +	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
   4.269 +}
   4.270 +
   4.271 +static int empty_output_buffer(j_compress_ptr jc)
   4.272 +{
   4.273 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   4.274 +
   4.275 +	if(dest->io->write(dest->buffer, OUTPUT_BUF_SIZE, dest->io->uptr) != OUTPUT_BUF_SIZE) {
   4.276 +		return 0;
   4.277 +	}
   4.278 +
   4.279 +	dest->pub.next_output_byte = dest->buffer;
   4.280 +	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
   4.281 +	return 1;
   4.282 +}
   4.283 +
   4.284 +static void term_destination(j_compress_ptr jc)
   4.285 +{
   4.286 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   4.287 +	size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
   4.288 +
   4.289 +	/* write any remaining data in the buffer */
   4.290 +	if(datacount > 0) {
   4.291 +		dest->io->write(dest->buffer, datacount, dest->io->uptr);
   4.292 +	}
   4.293 +	/* XXX flush? ... */
   4.294 +}

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/libs/imago2/file_png.c	Thu Sep 08 06:28:38 2011 +0300
     5.3 @@ -0,0 +1,244 @@
     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 +	unsigned char **lineptr, *dest;
    5.68 +	int i, channel_bits, color_type, ilace_type, compression, filtering, fmt;
    5.69 +	unsigned long xsz, ysz;
    5.70 +
    5.71 +	if(!(png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
    5.72 +		return -1;
    5.73 +	}
    5.74 +
    5.75 +	if(!(info = png_create_info_struct(png))) {
    5.76 +		png_destroy_read_struct(&png, 0, 0);
    5.77 +		return -1;
    5.78 +	}
    5.79 +
    5.80 +	if(setjmp(png_jmpbuf(png))) {
    5.81 +		png_destroy_read_struct(&png, &info, 0);
    5.82 +		return -1;
    5.83 +	}
    5.84 +
    5.85 +	png_set_read_fn(png, io, read_func);
    5.86 +	png_set_sig_bytes(png, 0);
    5.87 +	png_read_png(png, info, 0, 0);
    5.88 +
    5.89 +	png_get_IHDR(png, info, &xsz, &ysz, &channel_bits, &color_type, &ilace_type,
    5.90 +			&compression, &filtering);
    5.91 +	if((fmt = png_type_to_fmt(color_type, channel_bits)) == -1) {
    5.92 +		png_destroy_read_struct(&png, &info, 0);
    5.93 +		return -1;
    5.94 +	}
    5.95 +
    5.96 +	if(img_set_pixels(img, xsz, ysz, fmt, 0) == -1) {
    5.97 +		png_destroy_read_struct(&png, &info, 0);
    5.98 +		return -1;
    5.99 +	}
   5.100 +
   5.101 +	lineptr = (unsigned char**)png_get_rows(png, info);
   5.102 +
   5.103 +	dest = img->pixels;
   5.104 +	for(i=0; i<ysz; i++) {
   5.105 +		memcpy(dest, lineptr[i], xsz * img->pixelsz);
   5.106 +		dest += xsz * img->pixelsz;
   5.107 +	}
   5.108 +	png_destroy_read_struct(&png, &info, 0);
   5.109 +	return 0;
   5.110 +}
   5.111 +
   5.112 +
   5.113 +static int write_file(struct img_pixmap *img, struct img_io *io)
   5.114 +{
   5.115 +	png_struct *png;
   5.116 +	png_info *info;
   5.117 +	png_text txt;
   5.118 +	struct img_pixmap tmpimg;
   5.119 +	unsigned char **rows;
   5.120 +	unsigned char *pixptr;
   5.121 +	int i, coltype;
   5.122 +
   5.123 +	img_init(&tmpimg);
   5.124 +
   5.125 +	if(!(png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
   5.126 +		return -1;
   5.127 +	}
   5.128 +	if(!(info = png_create_info_struct(png))) {
   5.129 +		png_destroy_write_struct(&png, 0);
   5.130 +		return -1;
   5.131 +	}
   5.132 +
   5.133 +	/* if the input image is floating-point, we need to convert it to integer */
   5.134 +	if(img_is_float(img)) {
   5.135 +		if(img_copy(&tmpimg, img) == -1) {
   5.136 +			return -1;
   5.137 +		}
   5.138 +		if(img_to_integer(&tmpimg) == -1) {
   5.139 +			img_destroy(&tmpimg);
   5.140 +			return -1;
   5.141 +		}
   5.142 +		img = &tmpimg;
   5.143 +	}
   5.144 +
   5.145 +	txt.compression = PNG_TEXT_COMPRESSION_NONE;
   5.146 +	txt.key = "Software";
   5.147 +	txt.text = "libimago2";
   5.148 +	txt.text_length = 0;
   5.149 +
   5.150 +	if(setjmp(png_jmpbuf(png))) {
   5.151 +		png_destroy_write_struct(&png, &info);
   5.152 +		img_destroy(&tmpimg);
   5.153 +		return -1;
   5.154 +	}
   5.155 +	png_set_write_fn(png, io, write_func, flush_func);
   5.156 +
   5.157 +	coltype = fmt_to_png_type(img->fmt);
   5.158 +	png_set_IHDR(png, info, img->width, img->height, 8, coltype, PNG_INTERLACE_NONE,
   5.159 +			PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
   5.160 +	png_set_text(png, info, &txt, 1);
   5.161 +
   5.162 +	if(!(rows = malloc(img->height * sizeof *rows))) {
   5.163 +		png_destroy_write_struct(&png, &info);
   5.164 +		img_destroy(&tmpimg);
   5.165 +		return -1;
   5.166 +	}
   5.167 +
   5.168 +	pixptr = img->pixels;
   5.169 +	for(i=0; i<img->height; i++) {
   5.170 +		rows[i] = pixptr;
   5.171 +		pixptr += img->width * img->pixelsz;
   5.172 +	}
   5.173 +	png_set_rows(png, info, rows);
   5.174 +
   5.175 +	png_write_png(png, info, 0, 0);
   5.176 +	png_write_end(png, info);
   5.177 +	png_destroy_write_struct(&png, &info);
   5.178 +
   5.179 +	free(rows);
   5.180 +
   5.181 +	img_destroy(&tmpimg);
   5.182 +	return 0;
   5.183 +}
   5.184 +
   5.185 +static void read_func(png_struct *png, unsigned char *data, size_t len)
   5.186 +{
   5.187 +	struct img_io *io = (struct img_io*)png_get_io_ptr(png);
   5.188 +
   5.189 +	if(io->read(data, len, io->uptr) == -1) {
   5.190 +		longjmp(png_jmpbuf(png), 1);
   5.191 +	}
   5.192 +}
   5.193 +
   5.194 +static void write_func(png_struct *png, unsigned char *data, size_t len)
   5.195 +{
   5.196 +	struct img_io *io = (struct img_io*)png_get_io_ptr(png);
   5.197 +
   5.198 +	if(io->write(data, len, io->uptr) == -1) {
   5.199 +		longjmp(png_jmpbuf(png), 1);
   5.200 +	}
   5.201 +}
   5.202 +
   5.203 +static void flush_func(png_struct *png)
   5.204 +{
   5.205 +	/* XXX does it matter that we can't flush? */
   5.206 +}
   5.207 +
   5.208 +static int png_type_to_fmt(int color_type, int channel_bits)
   5.209 +{
   5.210 +	/* we don't support non-8bit-per-channel images yet */
   5.211 +	if(channel_bits > 8) {
   5.212 +		return -1;
   5.213 +	}
   5.214 +
   5.215 +	switch(color_type) {
   5.216 +	case PNG_COLOR_TYPE_RGB:
   5.217 +		return IMG_FMT_RGB24;
   5.218 +
   5.219 +	case PNG_COLOR_TYPE_RGB_ALPHA:
   5.220 +		return IMG_FMT_RGBA32;
   5.221 +
   5.222 +	case PNG_COLOR_TYPE_GRAY:
   5.223 +		return IMG_FMT_GREY8;
   5.224 +
   5.225 +	default:
   5.226 +		break;
   5.227 +	}
   5.228 +	return -1;
   5.229 +}
   5.230 +
   5.231 +static int fmt_to_png_type(enum img_fmt fmt)
   5.232 +{
   5.233 +	switch(fmt) {
   5.234 +	case IMG_FMT_GREY8:
   5.235 +		return PNG_COLOR_TYPE_GRAY;
   5.236 +
   5.237 +	case IMG_FMT_RGB24:
   5.238 +		return PNG_COLOR_TYPE_RGB;
   5.239 +
   5.240 +	case IMG_FMT_RGBA32:
   5.241 +		return PNG_COLOR_TYPE_RGBA;
   5.242 +
   5.243 +	default:
   5.244 +		break;
   5.245 +	}
   5.246 +	return -1;
   5.247 +}

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/libs/imago2/file_ppm.c	Thu Sep 08 06:28:38 2011 +0300
     6.3 @@ -0,0 +1,153 @@
     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 read(struct img_pixmap *img, struct img_io *io);
    6.30 +static int write(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, read, write};
    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 read(struct img_pixmap *img, struct img_io *io)
    6.79 +{
    6.80 +	char buf[256];
    6.81 +	int xsz, ysz, maxval, 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(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 +static int write(struct img_pixmap *img, struct img_io *io)
   6.125 +{
   6.126 +	int sz;
   6.127 +	char buf[256];
   6.128 +	struct img_pixmap tmpimg;
   6.129 +
   6.130 +	img_init(&tmpimg);
   6.131 +
   6.132 +	if(img->fmt != IMG_FMT_RGB24) {
   6.133 +		if(img_copy(&tmpimg, img) == -1) {
   6.134 +			return -1;
   6.135 +		}
   6.136 +		if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
   6.137 +			return -1;
   6.138 +		}
   6.139 +		img = &tmpimg;
   6.140 +	}
   6.141 +
   6.142 +	sprintf(buf, "P6\n#written by libimago2\n%d %d\n255\n", img->width, img->height);
   6.143 +	if(io->write(buf, strlen(buf), io->uptr) < strlen(buf)) {
   6.144 +		img_destroy(&tmpimg);
   6.145 +		return -1;
   6.146 +	}
   6.147 +
   6.148 +	sz = img->width * img->height * 3;
   6.149 +	if(io->write(img->pixels, sz, io->uptr) < sz) {
   6.150 +		img_destroy(&tmpimg);
   6.151 +		return -1;
   6.152 +	}
   6.153 +
   6.154 +	img_destroy(&tmpimg);
   6.155 +	return 0;
   6.156 +}

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/libs/imago2/ftype_module.c	Thu Sep 08 06:28:38 2011 +0300
     7.3 @@ -0,0 +1,118 @@
     7.4 +/*
     7.5 +libimago - a multi-format image file input/output library.
     7.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     7.7 +
     7.8 +This program is free software: you can redistribute it and/or modify
     7.9 +it under the terms of the GNU Lesser General Public License as published
    7.10 +by the Free Software Foundation, either version 3 of the License, or
    7.11 +(at your option) any later version.
    7.12 +
    7.13 +This program is distributed in the hope that it will be useful,
    7.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    7.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    7.16 +GNU Lesser General Public License for more details.
    7.17 +
    7.18 +You should have received a copy of the GNU Lesser General Public License
    7.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    7.20 +*/
    7.21 +
    7.22 +#include <stdlib.h>
    7.23 +#include <string.h>
    7.24 +#include "ftype_module.h"
    7.25 +
    7.26 +static struct list_node {
    7.27 +	struct ftype_module *module;
    7.28 +	struct list_node *next;
    7.29 +} *modules;
    7.30 +
    7.31 +/* defined in modules.c which is generated by configure */
    7.32 +void img_modules_init();
    7.33 +
    7.34 +static int done_init;
    7.35 +
    7.36 +int img_register_module(struct ftype_module *mod)
    7.37 +{
    7.38 +	struct list_node *node;
    7.39 +
    7.40 +	if(!(node = malloc(sizeof *node))) {
    7.41 +		return -1;
    7.42 +	}
    7.43 +
    7.44 +	node->module = mod;
    7.45 +	node->next = modules;
    7.46 +	modules = node;
    7.47 +	return 0;
    7.48 +}
    7.49 +
    7.50 +struct ftype_module *img_find_format_module(struct img_io *io)
    7.51 +{
    7.52 +	struct list_node *node;
    7.53 +
    7.54 +	if(!done_init) {
    7.55 +		img_modules_init();
    7.56 +		done_init = 1;
    7.57 +	}
    7.58 +
    7.59 +	node = modules;
    7.60 +	while(node) {
    7.61 +		if(node->module->check(io) != -1) {
    7.62 +			return node->module;
    7.63 +		}
    7.64 +		node = node->next;
    7.65 +	}
    7.66 +	return 0;
    7.67 +}
    7.68 +
    7.69 +struct ftype_module *img_guess_format(const char *fname)
    7.70 +{
    7.71 +	struct list_node *node;
    7.72 +	char *suffix;
    7.73 +	int suffix_len;
    7.74 +
    7.75 +	if(!done_init) {
    7.76 +		img_modules_init();
    7.77 +		done_init = 1;
    7.78 +	}
    7.79 +
    7.80 +	if(!(suffix = strrchr(fname, '.'))) {
    7.81 +		return 0;	/* no suffix, can't guess ... */
    7.82 +	}
    7.83 +	suffix_len = strlen(suffix);
    7.84 +
    7.85 +	node = modules;
    7.86 +	while(node) {
    7.87 +		char *suflist = node->module->suffix;
    7.88 +		char *start, *end;
    7.89 +
    7.90 +		while(*suflist) {
    7.91 +			if(!(start = strstr(suflist, suffix))) {
    7.92 +				break;
    7.93 +			}
    7.94 +			end = start + suffix_len;
    7.95 +
    7.96 +			if(*end == ':' || *end == 0) {
    7.97 +				return node->module;	/* found it */
    7.98 +			}
    7.99 +			suflist = end;
   7.100 +		}
   7.101 +
   7.102 +		node = node->next;
   7.103 +	}
   7.104 +	return 0;
   7.105 +}
   7.106 +
   7.107 +struct ftype_module *img_get_module(int idx)
   7.108 +{
   7.109 +	struct list_node *node;
   7.110 +
   7.111 +	if(!done_init) {
   7.112 +		img_modules_init();
   7.113 +		done_init = 1;
   7.114 +	}
   7.115 +
   7.116 +	node = modules;
   7.117 +	while(node && idx--) {
   7.118 +		node = node->next;
   7.119 +	}
   7.120 +	return node->module;
   7.121 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/libs/imago2/ftype_module.h	Thu Sep 08 06:28:38 2011 +0300
     8.3 @@ -0,0 +1,39 @@
     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 +#ifndef FTYPE_MODULE_H_
    8.23 +#define FTYPE_MODULE_H_
    8.24 +
    8.25 +#include "imago2.h"
    8.26 +
    8.27 +struct ftype_module {
    8.28 +	char *suffix;	/* used for format autodetection during saving only */
    8.29 +
    8.30 +	int (*check)(struct img_io *io);
    8.31 +	int (*read)(struct img_pixmap *img, struct img_io *io);
    8.32 +	int (*write)(struct img_pixmap *img, struct img_io *io);
    8.33 +};
    8.34 +
    8.35 +int img_register_module(struct ftype_module *mod);
    8.36 +
    8.37 +struct ftype_module *img_find_format_module(struct img_io *io);
    8.38 +struct ftype_module *img_guess_format(const char *fname);
    8.39 +struct ftype_module *img_get_module(int idx);
    8.40 +
    8.41 +
    8.42 +#endif	/* FTYPE_MODULE_H_ */

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/libs/imago2/imago2.c	Thu Sep 08 06:28:38 2011 +0300
     9.3 @@ -0,0 +1,343 @@
     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 +#include <stdio.h>
    9.23 +#include <stdlib.h>
    9.24 +#include <string.h>
    9.25 +#include "imago2.h"
    9.26 +#include "ftype_module.h"
    9.27 +
    9.28 +static int pixel_size(enum img_fmt fmt);
    9.29 +static size_t def_read(void *buf, size_t bytes, void *uptr);
    9.30 +static size_t def_write(void *buf, size_t bytes, void *uptr);
    9.31 +static long def_seek(long offset, int whence, void *uptr);
    9.32 +
    9.33 +
    9.34 +void img_init(struct img_pixmap *img)
    9.35 +{
    9.36 +	img->pixels = 0;
    9.37 +	img->width = img->height = 0;
    9.38 +	img->fmt = IMG_FMT_RGBA32;
    9.39 +	img->pixelsz = pixel_size(img->fmt);
    9.40 +	img->name = 0;
    9.41 +}
    9.42 +
    9.43 +
    9.44 +void img_destroy(struct img_pixmap *img)
    9.45 +{
    9.46 +	free(img->pixels);
    9.47 +	img->pixels = 0;	/* just in case... */
    9.48 +	img->width = img->height = 0xbadbeef;
    9.49 +	free(img->name);
    9.50 +}
    9.51 +
    9.52 +struct img_pixmap *img_create(void)
    9.53 +{
    9.54 +	struct img_pixmap *p;
    9.55 +
    9.56 +	if(!(p = malloc(sizeof *p))) {
    9.57 +		return 0;
    9.58 +	}
    9.59 +	img_init(p);
    9.60 +	return p;
    9.61 +}
    9.62 +
    9.63 +void img_free(struct img_pixmap *img)
    9.64 +{
    9.65 +	img_destroy(img);
    9.66 +	free(img);
    9.67 +}
    9.68 +
    9.69 +int img_set_name(struct img_pixmap *img, const char *name)
    9.70 +{
    9.71 +	char *tmp;
    9.72 +
    9.73 +	if(!(tmp = malloc(strlen(name) + 1))) {
    9.74 +		return -1;
    9.75 +	}
    9.76 +	strcpy(tmp, name);
    9.77 +	img->name = tmp;
    9.78 +	return 0;
    9.79 +}
    9.80 +
    9.81 +int img_set_format(struct img_pixmap *img, enum img_fmt fmt)
    9.82 +{
    9.83 +	if(img->pixels) {
    9.84 +		return img_convert(img, fmt);
    9.85 +	}
    9.86 +	img->fmt = fmt;
    9.87 +	return 0;
    9.88 +}
    9.89 +
    9.90 +int img_copy(struct img_pixmap *dest, struct img_pixmap *src)
    9.91 +{
    9.92 +	return img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels);
    9.93 +}
    9.94 +
    9.95 +int img_set_pixels(struct img_pixmap *img, int w, int h, enum img_fmt fmt, void *pix)
    9.96 +{
    9.97 +	void *newpix;
    9.98 +	int pixsz = pixel_size(fmt);
    9.99 +
   9.100 +	if(!(newpix = malloc(w * h * pixsz))) {
   9.101 +		return -1;
   9.102 +	}
   9.103 +
   9.104 +	if(pix) {
   9.105 +		memcpy(newpix, pix, w * h * pixsz);
   9.106 +	} else {
   9.107 +		memset(newpix, 0, w * h * pixsz);
   9.108 +	}
   9.109 +
   9.110 +	free(img->pixels);
   9.111 +	img->pixels = newpix;
   9.112 +	img->width = w;
   9.113 +	img->height = h;
   9.114 +	img->pixelsz = pixsz;
   9.115 +	img->fmt = fmt;
   9.116 +	return 0;
   9.117 +}
   9.118 +
   9.119 +void *img_load_pixels(const char *fname, int *xsz, int *ysz, enum img_fmt fmt)
   9.120 +{
   9.121 +	struct img_pixmap img;
   9.122 +
   9.123 +	img_init(&img);
   9.124 +
   9.125 +	if(img_load(&img, fname) == -1) {
   9.126 +		return 0;
   9.127 +	}
   9.128 +	if(img.fmt != fmt) {
   9.129 +		if(img_convert(&img, fmt) == -1) {
   9.130 +			img_destroy(&img);
   9.131 +			return 0;
   9.132 +		}
   9.133 +	}
   9.134 +
   9.135 +	*xsz = img.width;
   9.136 +	*ysz = img.height;
   9.137 +	return img.pixels;
   9.138 +}
   9.139 +
   9.140 +int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, enum img_fmt fmt)
   9.141 +{
   9.142 +	struct img_pixmap img;
   9.143 +
   9.144 +	img_init(&img);
   9.145 +	img.fmt = fmt;
   9.146 +	img.name = (char*)fname;
   9.147 +	img.width = xsz;
   9.148 +	img.height = ysz;
   9.149 +	img.pixels = pix;
   9.150 +
   9.151 +	return img_save(&img, fname);
   9.152 +}
   9.153 +
   9.154 +void img_free_pixels(void *pix)
   9.155 +{
   9.156 +	free(pix);
   9.157 +}
   9.158 +
   9.159 +int img_load(struct img_pixmap *img, const char *fname)
   9.160 +{
   9.161 +	int res;
   9.162 +	FILE *fp;
   9.163 +
   9.164 +	if(!(fp = fopen(fname, "rb"))) {
   9.165 +		return -1;
   9.166 +	}
   9.167 +	res = img_read_file(img, fp);
   9.168 +	fclose(fp);
   9.169 +	return res;
   9.170 +}
   9.171 +
   9.172 +/* TODO implement filetype selection */
   9.173 +int img_save(struct img_pixmap *img, const char *fname)
   9.174 +{
   9.175 +	int res;
   9.176 +	FILE *fp;
   9.177 +
   9.178 +	img_set_name(img, fname);
   9.179 +
   9.180 +	if(!(fp = fopen(fname, "wb"))) {
   9.181 +		return -1;
   9.182 +	}
   9.183 +	res = img_write_file(img, fp);
   9.184 +	fclose(fp);
   9.185 +	return res;
   9.186 +}
   9.187 +
   9.188 +int img_read_file(struct img_pixmap *img, FILE *fp)
   9.189 +{
   9.190 +	struct img_io io = {0, def_read, def_write, def_seek};
   9.191 +
   9.192 +	io.uptr = fp;
   9.193 +	return img_read(img, &io);
   9.194 +}
   9.195 +
   9.196 +int img_write_file(struct img_pixmap *img, FILE *fp)
   9.197 +{
   9.198 +	struct img_io io = {0, def_read, def_write, def_seek};
   9.199 +
   9.200 +	io.uptr = fp;
   9.201 +	return img_write(img, &io);
   9.202 +}
   9.203 +
   9.204 +int img_read(struct img_pixmap *img, struct img_io *io)
   9.205 +{
   9.206 +	struct ftype_module *mod;
   9.207 +
   9.208 +	if((mod = img_find_format_module(io))) {
   9.209 +		return mod->read(img, io);
   9.210 +	}
   9.211 +	return -1;
   9.212 +}
   9.213 +
   9.214 +int img_write(struct img_pixmap *img, struct img_io *io)
   9.215 +{
   9.216 +	struct ftype_module *mod;
   9.217 +
   9.218 +	if(!img->name || !(mod = img_guess_format(img->name))) {
   9.219 +		/* TODO throw some sort of warning? */
   9.220 +		/* TODO implement some sort of module priority or let the user specify? */
   9.221 +		if(!(mod = img_get_module(0))) {
   9.222 +			return -1;
   9.223 +		}
   9.224 +	}
   9.225 +
   9.226 +	return mod->write(img, io);
   9.227 +}
   9.228 +
   9.229 +int img_to_float(struct img_pixmap *img)
   9.230 +{
   9.231 +	enum img_fmt targ_fmt;
   9.232 +
   9.233 +	switch(img->fmt) {
   9.234 +	case IMG_FMT_GREY8:
   9.235 +		targ_fmt = IMG_FMT_GREYF;
   9.236 +		break;
   9.237 +
   9.238 +	case IMG_FMT_RGB24:
   9.239 +		targ_fmt = IMG_FMT_RGBF;
   9.240 +		break;
   9.241 +
   9.242 +	case IMG_FMT_RGBA32:
   9.243 +		targ_fmt = IMG_FMT_RGBAF;
   9.244 +		break;
   9.245 +
   9.246 +	default:
   9.247 +		return 0;	/* already float */
   9.248 +	}
   9.249 +
   9.250 +	return img_convert(img, targ_fmt);
   9.251 +}
   9.252 +
   9.253 +int img_to_integer(struct img_pixmap *img)
   9.254 +{
   9.255 +	enum img_fmt targ_fmt;
   9.256 +
   9.257 +	switch(img->fmt) {
   9.258 +	case IMG_FMT_GREYF:
   9.259 +		targ_fmt = IMG_FMT_GREY8;
   9.260 +		break;
   9.261 +
   9.262 +	case IMG_FMT_RGBF:
   9.263 +		targ_fmt = IMG_FMT_RGB24;
   9.264 +		break;
   9.265 +
   9.266 +	case IMG_FMT_RGBAF:
   9.267 +		targ_fmt = IMG_FMT_RGBA32;
   9.268 +		break;
   9.269 +
   9.270 +	default:
   9.271 +		return 0;	/* already integer */
   9.272 +	}
   9.273 +
   9.274 +	return img_convert(img, targ_fmt);
   9.275 +}
   9.276 +
   9.277 +int img_is_float(struct img_pixmap *img)
   9.278 +{
   9.279 +	return img->fmt >= IMG_FMT_GREYF && img->fmt <= IMG_FMT_RGBAF;
   9.280 +}
   9.281 +
   9.282 +int img_has_alpha(struct img_pixmap *img)
   9.283 +{
   9.284 +	return img->fmt >= IMG_FMT_GREY8 && img->fmt <= IMG_FMT_RGBA32;
   9.285 +}
   9.286 +
   9.287 +void img_io_set_user_data(struct img_io *io, void *uptr)
   9.288 +{
   9.289 +	io->uptr = uptr;
   9.290 +}
   9.291 +
   9.292 +void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*))
   9.293 +{
   9.294 +	io->read = read;
   9.295 +}
   9.296 +
   9.297 +void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*))
   9.298 +{
   9.299 +	io->write = write;
   9.300 +}
   9.301 +
   9.302 +void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*))
   9.303 +{
   9.304 +	io->seek = seek;
   9.305 +}
   9.306 +
   9.307 +
   9.308 +static int pixel_size(enum img_fmt fmt)
   9.309 +{
   9.310 +	switch(fmt) {
   9.311 +	case IMG_FMT_GREY8:
   9.312 +		return 1;
   9.313 +	case IMG_FMT_RGB24:
   9.314 +		return 3;
   9.315 +	case IMG_FMT_RGBA32:
   9.316 +		return 4;
   9.317 +	case IMG_FMT_GREYF:
   9.318 +		return sizeof(float);
   9.319 +	case IMG_FMT_RGBF:
   9.320 +		return 3 * sizeof(float);
   9.321 +	case IMG_FMT_RGBAF:
   9.322 +		return 4 * sizeof(float);
   9.323 +	default:
   9.324 +		break;
   9.325 +	}
   9.326 +	return 0;
   9.327 +}
   9.328 +
   9.329 +static size_t def_read(void *buf, size_t bytes, void *uptr)
   9.330 +{
   9.331 +	return uptr ? fread(buf, 1, bytes, uptr) : 0;
   9.332 +}
   9.333 +
   9.334 +static size_t def_write(void *buf, size_t bytes, void *uptr)
   9.335 +{
   9.336 +	return uptr ? fwrite(buf, 1, bytes, uptr) : 0;
   9.337 +}
   9.338 +
   9.339 +static long def_seek(long offset, int whence, void *uptr)
   9.340 +{
   9.341 +	if(!uptr || fseek(uptr, offset, whence) == -1) {
   9.342 +		return -1;
   9.343 +	}
   9.344 +	return ftell(uptr);
   9.345 +}
   9.346 +

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/libs/imago2/imago2.h	Thu Sep 08 06:28:38 2011 +0300
    10.3 @@ -0,0 +1,185 @@
    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 +#ifndef IMAGO2_H_
   10.23 +#define IMAGO2_H_
   10.24 +
   10.25 +#include <stdio.h>
   10.26 +
   10.27 +#ifdef __cplusplus
   10.28 +#define IMG_OPTARG(arg, val)	arg = val
   10.29 +#else
   10.30 +#define IMG_OPTARG(arg, val)	arg
   10.31 +#endif
   10.32 +
   10.33 +/* XXX if you change this make sure to also change pack/unpack arrays in conv.c */
   10.34 +enum img_fmt {
   10.35 +	IMG_FMT_GREY8,
   10.36 +	IMG_FMT_RGB24,
   10.37 +	IMG_FMT_RGBA32,
   10.38 +	IMG_FMT_GREYF,
   10.39 +	IMG_FMT_RGBF,
   10.40 +	IMG_FMT_RGBAF,
   10.41 +
   10.42 +	NUM_IMG_FMT
   10.43 +};
   10.44 +
   10.45 +struct img_pixmap {
   10.46 +	void *pixels;
   10.47 +	int width, height;
   10.48 +	enum img_fmt fmt;
   10.49 +	int pixelsz;
   10.50 +	char *name;
   10.51 +};
   10.52 +
   10.53 +struct img_io {
   10.54 +	void *uptr;	/* user-data */
   10.55 +
   10.56 +	size_t (*read)(void *buf, size_t bytes, void *uptr);
   10.57 +	size_t (*write)(void *buf, size_t bytes, void *uptr);
   10.58 +	long (*seek)(long offs, int whence, void *uptr);
   10.59 +};
   10.60 +
   10.61 +#ifdef __cplusplus
   10.62 +extern "C" {
   10.63 +#endif
   10.64 +
   10.65 +/* initialize the img_pixmap structure */
   10.66 +void img_init(struct img_pixmap *img);
   10.67 +/* destroys the img_pixmap structure, freeing the pixel buffer (if available)
   10.68 + * and any other memory held by the pixmap.
   10.69 + */
   10.70 +void img_destroy(struct img_pixmap *img);
   10.71 +
   10.72 +/* convenience function that allocates an img_pixmap struct and then initializes it.
   10.73 + * returns null if the malloc fails.
   10.74 + */
   10.75 +struct img_pixmap *img_create(void);
   10.76 +/* frees a pixmap previously allocated with img_create (free followed by img_destroy) */
   10.77 +void img_free(struct img_pixmap *img);
   10.78 +
   10.79 +int img_set_name(struct img_pixmap *img, const char *name);
   10.80 +
   10.81 +/* set the image pixel format */
   10.82 +int img_set_format(struct img_pixmap *img, enum img_fmt fmt);
   10.83 +
   10.84 +/* copies one pixmap to another.
   10.85 + * equivalent to: img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels)
   10.86 + */
   10.87 +int img_copy(struct img_pixmap *dest, struct img_pixmap *src);
   10.88 +
   10.89 +/* allocates a pixel buffer of the specified dimensions and format, and copies the
   10.90 + * pixels given through the pix pointer into it.
   10.91 + * the pix pointer can be null, in which case there's no copy, just allocation.
   10.92 + *
   10.93 + * C++: fmt and pix have default parameters IMG_FMT_RGBA32 and null respectively.
   10.94 + */
   10.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));
   10.96 +
   10.97 +/* Simplified image loading
   10.98 + * Loads the specified file, and returns a pointer to an array of pixels of the
   10.99 + * requested pixel format. The width and height of the image are returned through
  10.100 + * the xsz and ysz pointers.
  10.101 + * If the image cannot be loaded, the function returns null.
  10.102 + *
  10.103 + * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
  10.104 + */
  10.105 +void *img_load_pixels(const char *fname, int *xsz, int *ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
  10.106 +
  10.107 +/* Simplified image saving
  10.108 + * Reads an array of pixels supplied through the pix pointer, of dimensions xsz
  10.109 + * and ysz, and pixel-format fmt, and saves it to a file.
  10.110 + * The output filetype is guessed by the filename suffix.
  10.111 + *
  10.112 + * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
  10.113 + */
  10.114 +int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
  10.115 +
  10.116 +/* Frees the memory allocated by img_load_pixels */
  10.117 +void img_free_pixels(void *pix);
  10.118 +
  10.119 +/* Loads an image file into the supplied pixmap */
  10.120 +int img_load(struct img_pixmap *img, const char *fname);
  10.121 +/* Saves the supplied pixmap to a file. The output filetype is guessed by the filename suffix */
  10.122 +int img_save(struct img_pixmap *img, const char *fname);
  10.123 +
  10.124 +/* Reads an image from an open FILE* into the supplied pixmap */
  10.125 +int img_read_file(struct img_pixmap *img, FILE *fp);
  10.126 +/* Writes the supplied pixmap to an open FILE* */
  10.127 +int img_write_file(struct img_pixmap *img, FILE *fp);
  10.128 +
  10.129 +/* Reads an image using user-defined file-i/o functions (see img_io_set_*) */
  10.130 +int img_read(struct img_pixmap *img, struct img_io *io);
  10.131 +/* Writes an image using user-defined file-i/o functions (see img_io_set_*) */
  10.132 +int img_write(struct img_pixmap *img, struct img_io *io);
  10.133 +
  10.134 +/* Converts an image to the specified pixel format */
  10.135 +int img_convert(struct img_pixmap *img, enum img_fmt tofmt);
  10.136 +
  10.137 +/* Converts an image from an integer pixel format to the corresponding floating point one */
  10.138 +int img_to_float(struct img_pixmap *img);
  10.139 +/* Converts an image from a floating point pixel format to the corresponding integer one */
  10.140 +int img_to_integer(struct img_pixmap *img);
  10.141 +
  10.142 +/* Returns non-zero (true) if the supplied image is in a floating point pixel format */
  10.143 +int img_is_float(struct img_pixmap *img);
  10.144 +/* Returns non-zero (true) if the supplied image has an alpha channel */
  10.145 +int img_has_alpha(struct img_pixmap *img);
  10.146 +
  10.147 +
  10.148 +/* These functions can be used to fill an img_io struct before it's passed to
  10.149 + * one of the user-defined i/o image reading/writing functions (img_read/img_write).
  10.150 + *
  10.151 + * User-defined i/o functions:
  10.152 + *
  10.153 + * - size_t read_func(void *buffer, size_t bytes, void *user_ptr)
  10.154 + * Must try to fill the buffer with the specified number of bytes, and return
  10.155 + * the number of bytes actually read.
  10.156 + *
  10.157 + * - size_t write_func(void *buffer, size_t bytes, void *user_ptr)
  10.158 + * Must write the specified number of bytes from the supplied buffer and return
  10.159 + * the number of bytes actually written.
  10.160 + *
  10.161 + * - long seek_func(long offset, int whence, void *user_ptr)
  10.162 + * Must seek offset bytes from: the beginning of the file if whence is SEEK_SET,
  10.163 + * the current position if whence is SEEK_CUR, or the end of the file if whence is
  10.164 + * SEEK_END, and return the resulting file offset from the beginning of the file.
  10.165 + * (i.e. seek_func(0, SEEK_CUR, user_ptr); must be equivalent to an ftell).
  10.166 + *
  10.167 + * All three functions get the user-data pointer set through img_io_set_user_data
  10.168 + * as their last argument.
  10.169 + *
  10.170 + * Note: obviously you don't need to set a write function if you're only going
  10.171 + * to call img_read, or the read and seek function if you're only going to call
  10.172 + * img_write.
  10.173 + *
  10.174 + * Note: if the user-supplied write function is buffered, make sure to flush
  10.175 + * (or close the file) after img_write returns.
  10.176 + */
  10.177 +void img_io_set_user_data(struct img_io *io, void *uptr);
  10.178 +void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*));
  10.179 +void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*));
  10.180 +void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*));
  10.181 +
  10.182 +
  10.183 +#ifdef __cplusplus
  10.184 +}
  10.185 +#endif
  10.186 +
  10.187 +
  10.188 +#endif	/* IMAGO_H_ */

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/libs/imago2/modules.c	Thu Sep 08 06:28:38 2011 +0300
    11.3 @@ -0,0 +1,11 @@
    11.4 +/* this file is generated by ./configure, do not edit */
    11.5 +int img_register_jpeg();
    11.6 +int img_register_png();
    11.7 +int img_register_ppm();
    11.8 +
    11.9 +void img_modules_init(void)
   11.10 +{
   11.11 +	img_register_jpeg();
   11.12 +	img_register_png();
   11.13 +	img_register_ppm();
   11.14 +}

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/libs/libjpeg/cderror.h	Thu Sep 08 06:28:38 2011 +0300
    12.3 @@ -0,0 +1,132 @@
    12.4 +/*
    12.5 + * cderror.h
    12.6 + *
    12.7 + * Copyright (C) 1994-1997, Thomas G. Lane.
    12.8 + * This file is part of the Independent JPEG Group's software.
    12.9 + * For conditions of distribution and use, see the accompanying README file.
   12.10 + *
   12.11 + * This file defines the error and message codes for the cjpeg/djpeg
   12.12 + * applications.  These strings are not needed as part of the JPEG library
   12.13 + * proper.
   12.14 + * Edit this file to add new codes, or to translate the message strings to
   12.15 + * some other language.
   12.16 + */
   12.17 +
   12.18 +/*
   12.19 + * To define the enum list of message codes, include this file without
   12.20 + * defining macro JMESSAGE.  To create a message string table, include it
   12.21 + * again with a suitable JMESSAGE definition (see jerror.c for an example).
   12.22 + */
   12.23 +#ifndef JMESSAGE
   12.24 +#ifndef CDERROR_H
   12.25 +#define CDERROR_H
   12.26 +/* First time through, define the enum list */
   12.27 +#define JMAKE_ENUM_LIST
   12.28 +#else
   12.29 +/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
   12.30 +#define JMESSAGE(code,string)
   12.31 +#endif /* CDERROR_H */
   12.32 +#endif /* JMESSAGE */
   12.33 +
   12.34 +#ifdef JMAKE_ENUM_LIST
   12.35 +
   12.36 +typedef enum {
   12.37 +
   12.38 +#define JMESSAGE(code,string)	code ,
   12.39 +
   12.40 +#endif /* JMAKE_ENUM_LIST */
   12.41 +
   12.42 +JMESSAGE(JMSG_FIRSTADDONCODE=1000, NULL) /* Must be first entry! */
   12.43 +
   12.44 +#ifdef BMP_SUPPORTED
   12.45 +JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format")
   12.46 +JMESSAGE(JERR_BMP_BADDEPTH, "Only 8- and 24-bit BMP files are supported")
   12.47 +JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length")
   12.48 +JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1")
   12.49 +JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB")
   12.50 +JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported")
   12.51 +JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM")
   12.52 +JMESSAGE(JTRC_BMP, "%ux%u 24-bit BMP image")
   12.53 +JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image")
   12.54 +JMESSAGE(JTRC_BMP_OS2, "%ux%u 24-bit OS2 BMP image")
   12.55 +JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image")
   12.56 +#endif /* BMP_SUPPORTED */
   12.57 +
   12.58 +#ifdef GIF_SUPPORTED
   12.59 +JMESSAGE(JERR_GIF_BUG, "GIF output got confused")
   12.60 +JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d")
   12.61 +JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB")
   12.62 +JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file")
   12.63 +JMESSAGE(JERR_GIF_NOT, "Not a GIF file")
   12.64 +JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image")
   12.65 +JMESSAGE(JTRC_GIF_BADVERSION,
   12.66 +	 "Warning: unexpected GIF version number '%c%c%c'")
   12.67 +JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x")
   12.68 +JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input")
   12.69 +JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file")
   12.70 +JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring")
   12.71 +JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image")
   12.72 +JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits")
   12.73 +#endif /* GIF_SUPPORTED */
   12.74 +
   12.75 +#ifdef PPM_SUPPORTED
   12.76 +JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB")
   12.77 +JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file")
   12.78 +JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file")
   12.79 +JMESSAGE(JTRC_PGM, "%ux%u PGM image")
   12.80 +JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image")
   12.81 +JMESSAGE(JTRC_PPM, "%ux%u PPM image")
   12.82 +JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image")
   12.83 +#endif /* PPM_SUPPORTED */
   12.84 +
   12.85 +#ifdef RLE_SUPPORTED
   12.86 +JMESSAGE(JERR_RLE_BADERROR, "Bogus error code from RLE library")
   12.87 +JMESSAGE(JERR_RLE_COLORSPACE, "RLE output must be grayscale or RGB")
   12.88 +JMESSAGE(JERR_RLE_DIMENSIONS, "Image dimensions (%ux%u) too large for RLE")
   12.89 +JMESSAGE(JERR_RLE_EMPTY, "Empty RLE file")
   12.90 +JMESSAGE(JERR_RLE_EOF, "Premature EOF in RLE header")
   12.91 +JMESSAGE(JERR_RLE_MEM, "Insufficient memory for RLE header")
   12.92 +JMESSAGE(JERR_RLE_NOT, "Not an RLE file")
   12.93 +JMESSAGE(JERR_RLE_TOOMANYCHANNELS, "Cannot handle %d output channels for RLE")
   12.94 +JMESSAGE(JERR_RLE_UNSUPPORTED, "Cannot handle this RLE setup")
   12.95 +JMESSAGE(JTRC_RLE, "%ux%u full-color RLE file")
   12.96 +JMESSAGE(JTRC_RLE_FULLMAP, "%ux%u full-color RLE file with map of length %d")
   12.97 +JMESSAGE(JTRC_RLE_GRAY, "%ux%u grayscale RLE file")
   12.98 +JMESSAGE(JTRC_RLE_MAPGRAY, "%ux%u grayscale RLE file with map of length %d")
   12.99 +JMESSAGE(JTRC_RLE_MAPPED, "%ux%u colormapped RLE file with map of length %d")
  12.100 +#endif /* RLE_SUPPORTED */
  12.101 +
  12.102 +#ifdef TARGA_SUPPORTED
  12.103 +JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format")
  12.104 +JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file")
  12.105 +JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB")
  12.106 +JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image")
  12.107 +JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image")
  12.108 +JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image")
  12.109 +#else
  12.110 +JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled")
  12.111 +#endif /* TARGA_SUPPORTED */
  12.112 +
  12.113 +JMESSAGE(JERR_BAD_CMAP_FILE,
  12.114 +	 "Color map file is invalid or of unsupported format")
  12.115 +JMESSAGE(JERR_TOO_MANY_COLORS,
  12.116 +	 "Output file format cannot handle %d colormap entries")
  12.117 +JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed")
  12.118 +#ifdef TARGA_SUPPORTED
  12.119 +JMESSAGE(JERR_UNKNOWN_FORMAT,
  12.120 +	 "Unrecognized input file format --- perhaps you need -targa")
  12.121 +#else
  12.122 +JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format")
  12.123 +#endif
  12.124 +JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format")
  12.125 +
  12.126 +#ifdef JMAKE_ENUM_LIST
  12.127 +
  12.128 +  JMSG_LASTADDONCODE
  12.129 +} ADDON_MESSAGE_CODE;
  12.130 +
  12.131 +#undef JMAKE_ENUM_LIST
  12.132 +#endif /* JMAKE_ENUM_LIST */
  12.133 +
  12.134 +/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
  12.135 +#undef JMESSAGE

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/libs/libjpeg/jcapimin.c	Thu Sep 08 06:28:38 2011 +0300
    13.3 @@ -0,0 +1,280 @@
    13.4 +/*
    13.5 + * jcapimin.c
    13.6 + *
    13.7 + * Copyright (C) 1994-1998, Thomas G. Lane.
    13.8 + * This file is part of the Independent JPEG Group's software.
    13.9 + * For conditions of distribution and use, see the accompanying README file.
   13.10 + *
   13.11 + * This file contains application interface code for the compression half
   13.12 + * of the JPEG library.  These are the "minimum" API routines that may be
   13.13 + * needed in either the normal full-compression case or the transcoding-only
   13.14 + * case.
   13.15 + *
   13.16 + * Most of the routines intended to be called directly by an application
   13.17 + * are in this file or in jcapistd.c.  But also see jcparam.c for
   13.18 + * parameter-setup helper routines, jcomapi.c for routines shared by
   13.19 + * compression and decompression, and jctrans.c for the transcoding case.
   13.20 + */
   13.21 +
   13.22 +#define JPEG_INTERNALS
   13.23 +#include "jinclude.h"
   13.24 +#include "jpeglib.h"
   13.25 +
   13.26 +
   13.27 +/*
   13.28 + * Initialization of a JPEG compression object.
   13.29 + * The error manager must already be set up (in case memory manager fails).
   13.30 + */
   13.31 +
   13.32 +GLOBAL(void)
   13.33 +jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize)
   13.34 +{
   13.35 +  int i;
   13.36 +
   13.37 +  /* Guard against version mismatches between library and caller. */
   13.38 +  cinfo->mem = NULL;		/* so jpeg_destroy knows mem mgr not called */
   13.39 +  if (version != JPEG_LIB_VERSION)
   13.40 +    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
   13.41 +  if (structsize != SIZEOF(struct jpeg_compress_struct))
   13.42 +    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, 
   13.43 +	     (int) SIZEOF(struct jpeg_compress_struct), (int) structsize);
   13.44 +
   13.45 +  /* For debugging purposes, we zero the whole master structure.
   13.46 +   * But the application has already set the err pointer, and may have set
   13.47 +   * client_data, so we have to save and restore those fields.
   13.48 +   * Note: if application hasn't set client_data, tools like Purify may
   13.49 +   * complain here.
   13.50 +   */
   13.51 +  {
   13.52 +    struct jpeg_error_mgr * err = cinfo->err;
   13.53 +    void * client_data = cinfo->client_data; /* ignore Purify complaint here */
   13.54 +    MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct));
   13.55 +    cinfo->err = err;
   13.56 +    cinfo->client_data = client_data;
   13.57 +  }
   13.58 +  cinfo->is_decompressor = FALSE;
   13.59 +
   13.60 +  /* Initialize a memory manager instance for this object */
   13.61 +  jinit_memory_mgr((j_common_ptr) cinfo);
   13.62 +
   13.63 +  /* Zero out pointers to permanent structures. */
   13.64 +  cinfo->progress = NULL;
   13.65 +  cinfo->dest = NULL;
   13.66 +
   13.67 +  cinfo->comp_info = NULL;
   13.68 +
   13.69 +  for (i = 0; i < NUM_QUANT_TBLS; i++)
   13.70 +    cinfo->quant_tbl_ptrs[i] = NULL;
   13.71 +
   13.72 +  for (i = 0; i < NUM_HUFF_TBLS; i++) {
   13.73 +    cinfo->dc_huff_tbl_ptrs[i] = NULL;
   13.74 +    cinfo->ac_huff_tbl_ptrs[i] = NULL;
   13.75 +  }
   13.76 +
   13.77 +  cinfo->script_space = NULL;
   13.78 +
   13.79 +  cinfo->input_gamma = 1.0;	/* in case application forgets */
   13.80 +
   13.81 +  /* OK, I'm ready */
   13.82 +  cinfo->global_state = CSTATE_START;
   13.83 +}
   13.84 +
   13.85 +
   13.86 +/*
   13.87 + * Destruction of a JPEG compression object
   13.88 + */
   13.89 +
   13.90 +GLOBAL(void)
   13.91 +jpeg_destroy_compress (j_compress_ptr cinfo)
   13.92 +{
   13.93 +  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
   13.94 +}
   13.95 +
   13.96 +
   13.97 +/*
   13.98 + * Abort processing of a JPEG compression operation,
   13.99 + * but don't destroy the object itself.
  13.100 + */
  13.101 +
  13.102 +GLOBAL(void)
  13.103 +jpeg_abort_compress (j_compress_ptr cinfo)
  13.104 +{
  13.105 +  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
  13.106 +}
  13.107 +
  13.108 +
  13.109 +/*
  13.110 + * Forcibly suppress or un-suppress all quantization and Huffman tables.
  13.111 + * Marks all currently defined tables as already written (if suppress)
  13.112 + * or not written (if !suppress).  This will control whether they get emitted
  13.113 + * by a subsequent jpeg_start_compress call.
  13.114 + *
  13.115 + * This routine is exported for use by applications that want to produce
  13.116 + * abbreviated JPEG datastreams.  It logically belongs in jcparam.c, but
  13.117 + * since it is called by jpeg_start_compress, we put it here --- otherwise
  13.118 + * jcparam.o would be linked whether the application used it or not.
  13.119 + */
  13.120 +
  13.121 +GLOBAL(void)
  13.122 +jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress)
  13.123 +{
  13.124 +  int i;
  13.125 +  JQUANT_TBL * qtbl;
  13.126 +  JHUFF_TBL * htbl;
  13.127 +
  13.128 +  for (i = 0; i < NUM_QUANT_TBLS; i++) {
  13.129 +    if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
  13.130 +      qtbl->sent_table = suppress;
  13.131 +  }
  13.132 +
  13.133 +  for (i = 0; i < NUM_HUFF_TBLS; i++) {
  13.134 +    if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
  13.135 +      htbl->sent_table = suppress;
  13.136 +    if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
  13.137 +      htbl->sent_table = suppress;
  13.138 +  }
  13.139 +}
  13.140 +
  13.141 +
  13.142 +/*
  13.143 + * Finish JPEG compression.
  13.144 + *
  13.145 + * If a multipass operating mode was selected, this may do a great deal of
  13.146 + * work including most of the actual output.
  13.147 + */
  13.148 +
  13.149 +GLOBAL(void)
  13.150 +jpeg_finish_compress (j_compress_ptr cinfo)
  13.151 +{
  13.152 +  JDIMENSION iMCU_row;
  13.153 +
  13.154 +  if (cinfo->global_state == CSTATE_SCANNING ||
  13.155 +      cinfo->global_state == CSTATE_RAW_OK) {
  13.156 +    /* Terminate first pass */
  13.157 +    if (cinfo->next_scanline < cinfo->image_height)
  13.158 +      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
  13.159 +    (*cinfo->master->finish_pass) (cinfo);
  13.160 +  } else if (cinfo->global_state != CSTATE_WRCOEFS)
  13.161 +    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  13.162 +  /* Perform any remaining passes */
  13.163 +  while (! cinfo->master->is_last_pass) {
  13.164 +    (*cinfo->master->prepare_for_pass) (cinfo);
  13.165 +    for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
  13.166 +      if (cinfo->progress != NULL) {
  13.167 +	cinfo->progress->pass_counter = (long) iMCU_row;
  13.168 +	cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
  13.169 +	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  13.170 +      }
  13.171 +      /* We bypass the main controller and invoke coef controller directly;
  13.172 +       * all work is being done from the coefficient buffer.
  13.173 +       */
  13.174 +      if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
  13.175 +	ERREXIT(cinfo, JERR_CANT_SUSPEND);
  13.176 +    }
  13.177 +    (*cinfo->master->finish_pass) (cinfo);
  13.178 +  }
  13.179 +  /* Write EOI, do final cleanup */
  13.180 +  (*cinfo->marker->write_file_trailer) (cinfo);
  13.181 +  (*cinfo->dest->term_destination) (cinfo);
  13.182 +  /* We can use jpeg_abort to release memory and reset global_state */
  13.183 +  jpeg_abort((j_common_ptr) cinfo);
  13.184 +}
  13.185 +
  13.186 +
  13.187 +/*
  13.188 + * Write a special marker.
  13.189 + * This is only recommended for writing COM or APPn markers.
  13.190 + * Must be called after jpeg_start_compress() and before
  13.191 + * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
  13.192 + */
  13.193 +
  13.194 +GLOBAL(void)
  13.195 +jpeg_write_marker (j_compress_ptr cinfo, int marker,
  13.196 +		   const JOCTET *dataptr, unsigned int datalen)
  13.197 +{
  13.198 +  JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val));
  13.199 +
  13.200 +  if (cinfo->next_scanline != 0 ||
  13.201 +      (cinfo->global_state != CSTATE_SCANNING &&
  13.202 +       cinfo->global_state != CSTATE_RAW_OK &&
  13.203 +       cinfo->global_state != CSTATE_WRCOEFS))
  13.204 +    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  13.205 +
  13.206 +  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
  13.207 +  write_marker_byte = cinfo->marker->write_marker_byte;	/* copy for speed */
  13.208 +  while (datalen--) {
  13.209 +    (*write_marker_byte) (cinfo, *dataptr);
  13.210 +    dataptr++;
  13.211 +  }
  13.212 +}
  13.213 +
  13.214 +/* Same, but piecemeal. */
  13.215 +
  13.216 +GLOBAL(void)
  13.217 +jpeg_write_m_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
  13.218 +{
  13.219 +  if (cinfo->next_scanline != 0 ||
  13.220 +      (cinfo->global_state != CSTATE_SCANNING &&
  13.221 +       cinfo->global_state != CSTATE_RAW_OK &&
  13.222 +       cinfo->global_state != CSTATE_WRCOEFS))
  13.223 +    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  13.224 +
  13.225 +  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
  13.226 +}
  13.227 +
  13.228 +GLOBAL(void)
  13.229 +jpeg_write_m_byte (j_compress_ptr cinfo, int val)
  13.230 +{
  13.231 +  (*cinfo->marker->write_marker_byte) (cinfo, val);
  13.232 +}
  13.233 +
  13.234 +
  13.235 +/*
  13.236 + * Alternate compression function: just write an abbreviated table file.
  13.237 + * Before calling this, all parameters and a data destination must be set up.
  13.238 + *
  13.239 + * To produce a pair of files containing abbreviated tables and abbreviated
  13.240 + * image data, one would proceed as follows:
  13.241 + *
  13.242 + *		initialize JPEG object
  13.243 + *		set JPEG parameters
  13.244 + *		set destination to table file
  13.245 + *		jpeg_write_tables(cinfo);
  13.246 + *		set destination to image file
  13.247 + *		jpeg_start_compress(cinfo, FALSE);
  13.248 + *		write data...
  13.249 + *		jpeg_finish_compress(cinfo);
  13.250 + *
  13.251 + * jpeg_write_tables has the side effect of marking all tables written
  13.252 + * (same as jpeg_suppress_tables(..., TRUE)).  Thus a subsequent start_compress
  13.253 + * will not re-emit the tables unless it is passed write_all_tables=TRUE.
  13.254 + */
  13.255 +
  13.256 +GLOBAL(void)
  13.257 +jpeg_write_tables (j_compress_ptr cinfo)
  13.258 +{
  13.259 +  if (cinfo->global_state != CSTATE_START)
  13.260 +    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  13.261 +
  13.262 +  /* (Re)initialize error mgr and destination modules */
  13.263 +  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
  13.264 +  (*cinfo->dest->init_destination) (cinfo);
  13.265 +  /* Initialize the marker writer ... bit of a crock to do it here. */
  13.266 +  jinit_marker_writer(cinfo);
  13.267 +  /* Write them tables! */
  13.268 +  (*cinfo->marker->write_tables_only) (cinfo);
  13.269 +  /* And clean up. */
  13.270 +  (*cinfo->dest->term_destination) (cinfo);
  13.271 +  /*
  13.272 +   * In library releases up through v6a, we called jpeg_abort() here to free
  13.273 +   * any working memory allocated by the destination manager and marker
  13.274 +   * writer.  Some applications had a problem with that: they allocated space
  13.275 +   * of their own from the library memory manager, and didn't want it to go
  13.276 +   * away during write_tables.  So now we do nothing.  This will cause a
  13.277 +   * memory leak if an app calls write_tables repeatedly without doing a full
  13.278 +   * compression cycle or otherwise resetting the JPEG object.  However, that
  13.279 +   * seems less bad than unexpectedly freeing memory in the normal case.
  13.280 +   * An app that prefers the old behavior can call jpeg_abort for itself after
  13.281 +   * each call to jpeg_write_tables().
  13.282 +   */
  13.283 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/libs/libjpeg/jcapistd.c	Thu Sep 08 06:28:38 2011 +0300
    14.3 @@ -0,0 +1,161 @@
    14.4 +/*
    14.5 + * jcapistd.c
    14.6 + *
    14.7 + * Copyright (C) 1994-1996, Thomas G. Lane.
    14.8 + * This file is part of the Independent JPEG Group's software.
    14.9 + * For conditions of distribution and use, see the accompanying README file.
   14.10 + *
   14.11 + * This file contains application interface code for the compression half
   14.12 + * of the JPEG library.  These are the "standard" API routines that are
   14.13 + * used in the normal full-compression case.  They are not used by a
   14.14 + * transcoding-only application.  Note that if an application links in
   14.15 + * jpeg_start_compress, it will end up linking in the entire compressor.
   14.16 + * We thus must separate this file from jcapimin.c to avoid linking the
   14.17 + * whole compression library into a transcoder.
   14.18 + */
   14.19 +
   14.20 +#define JPEG_INTERNALS
   14.21 +#include "jinclude.h"
   14.22 +#include "jpeglib.h"
   14.23 +
   14.24 +
   14.25 +/*
   14.26 + * Compression initialization.
   14.27 + * Before calling this, all parameters and a data destination must be set up.
   14.28 + *
   14.29 + * We require a write_all_tables parameter as a failsafe check when writing
   14.30 + * multiple datastreams from the same compression object.  Since prior runs
   14.31 + * will have left all the tables marked sent_table=TRUE, a subsequent run
   14.32 + * would emit an abbreviated stream (no tables) by default.  This may be what
   14.33 + * is wanted, but for safety's sake it should not be the default behavior:
   14.34 + * programmers should have to make a deliberate choice to emit abbreviated
   14.35 + * images.  Therefore the documentation and examples should encourage people
   14.36 + * to pass write_all_tables=TRUE; then it will take active thought to do the
   14.37 + * wrong thing.
   14.38 + */
   14.39 +
   14.40 +GLOBAL(void)
   14.41 +jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
   14.42 +{
   14.43 +  if (cinfo->global_state != CSTATE_START)
   14.44 +    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
   14.45 +
   14.46 +  if (write_all_tables)
   14.47 +    jpeg_suppress_tables(cinfo, FALSE);	/* mark all tables to be written */
   14.48 +
   14.49 +  /* (Re)initialize error mgr and destination modules */
   14.50 +  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
   14.51 +  (*cinfo->dest->init_destination) (cinfo);
   14.52 +  /* Perform master selection of active modules */
   14.53 +  jinit_compress_master(cinfo);
   14.54 +  /* Set up for the first pass */
   14.55 +  (*cinfo->master->prepare_for_pass) (cinfo);
   14.56 +  /* Ready for application to drive first pass through jpeg_write_scanlines
   14.57 +   * or jpeg_write_raw_data.
   14.58 +   */
   14.59 +  cinfo->next_scanline = 0;
   14.60 +  cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
   14.61 +}
   14.62 +
   14.63 +
   14.64 +/*
   14.65 + * Write some scanlines of data to the JPEG compressor.
   14.66 + *
   14.67 + * The return value will be the number of lines actually written.
   14.68 + * This should be less than the supplied num_lines only in case that
   14.69 + * the data destination module has requested suspension of the compressor,
   14.70 + * or if more than image_height scanlines are passed in.
   14.71 + *
   14.72 + * Note: we warn about excess calls to jpeg_write_scanlines() since
   14.73 + * this likely signals an application programmer error.  However,
   14.74 + * excess scanlines passed in the last valid call are *silently* ignored,
   14.75 + * so that the application need not adjust num_lines for end-of-image
   14.76 + * when using a multiple-scanline buffer.
   14.77 + */
   14.78 +
   14.79 +GLOBAL(JDIMENSION)
   14.80 +jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
   14.81 +		      JDIMENSION num_lines)
   14.82 +{
   14.83 +  JDIMENSION row_ctr, rows_left;
   14.84 +
   14.85 +  if (cinfo->global_state != CSTATE_SCANNING)
   14.86 +    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
   14.87 +  if (cinfo->next_scanline >= cinfo->image_height)
   14.88 +    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
   14.89 +
   14.90 +  /* Call progress monitor hook if present */
   14.91 +  if (cinfo->progress != NULL) {
   14.92 +    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
   14.93 +    cinfo->progress->pass_limit = (long) cinfo->image_height;
   14.94 +    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
   14.95 +  }
   14.96 +
   14.97 +  /* Give master control module another chance if this is first call to
   14.98 +   * jpeg_write_scanlines.  This lets output of the frame/scan headers be
   14.99 +   * delayed so that application can write COM, etc, markers between
  14.100 +   * jpeg_start_compress and jpeg_write_scanlines.
  14.101 +   */
  14.102 +  if (cinfo->master->call_pass_startup)
  14.103 +    (*cinfo->master->pass_startup) (cinfo);
  14.104 +
  14.105 +  /* Ignore any extra scanlines at bottom of image. */
  14.106 +  rows_left = cinfo->image_height - cinfo->next_scanline;
  14.107 +  if (num_lines > rows_left)
  14.108 +    num_lines = rows_left;
  14.109 +
  14.110 +  row_ctr = 0;
  14.111 +  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
  14.112 +  cinfo->next_scanline += row_ctr;
  14.113 +  return row_ctr;
  14.114 +}
  14.115 +
  14.116 +
  14.117 +/*
  14.118 + * Alternate entry point to write raw data.
  14.119 + * Processes exactly one iMCU row per call, unless suspended.
  14.120 + */
  14.121 +
  14.122 +GLOBAL(JDIMENSION)
  14.123 +jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data,
  14.124 +		     JDIMENSION num_lines)
  14.125 +{
  14.126 +  JDIMENSION lines_per_iMCU_row;
  14.127 +
  14.128 +  if (cinfo->global_state != CSTATE_RAW_OK)
  14.129 +    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  14.130 +  if (cinfo->next_scanline >= cinfo->image_height) {
  14.131 +    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
  14.132 +    return 0;
  14.133 +  }
  14.134 +
  14.135 +  /* Call progress monitor hook if present */
  14.136 +  if (cinfo->progress != NULL) {
  14.137 +    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
  14.138 +    cinfo->progress->pass_limit = (long) cinfo->image_height;
  14.139 +    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  14.140 +  }
  14.141 +
  14.142 +  /* Give master control module another chance if this is first call to
  14.143 +   * jpeg_write_raw_data.  This lets output of the frame/scan headers be
  14.144 +   * delayed so that application can write COM, etc, markers between
  14.145 +   * jpeg_start_compress and jpeg_write_raw_data.
  14.146 +   */
  14.147 +  if (cinfo->master->call_pass_startup)
  14.148 +    (*cinfo->master->pass_startup) (cinfo);
  14.149 +
  14.150 +  /* Verify that at least one iMCU row has been passed. */
  14.151 +  lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE;
  14.152 +  if (num_lines < lines_per_iMCU_row)
  14.153 +    ERREXIT(cinfo, JERR_BUFFER_SIZE);
  14.154 +
  14.155 +  /* Directly compress the row. */
  14.156 +  if (! (*cinfo->coef->compress_data) (cinfo, data)) {
  14.157 +    /* If compressor did not consume the whole row, suspend processing. */
  14.158 +    return 0;
  14.159 +  }
  14.160 +
  14.161 +  /* OK, we processed one iMCU row. */
  14.162 +  cinfo->next_scanline += lines_per_iMCU_row;
  14.163 +  return lines_per_iMCU_row;
  14.164 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/libs/libjpeg/jccoefct.c	Thu Sep 08 06:28:38 2011 +0300
    15.3 @@ -0,0 +1,449 @@
    15.4 +/*
    15.5 + * jccoefct.c
    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 contains the coefficient buffer controller for compression.
   15.12 + * This controller is the top level of the JPEG compressor proper.
   15.13 + * The coefficient buffer lies between forward-DCT and entropy encoding steps.
   15.14 + */
   15.15 +
   15.16 +#define JPEG_INTERNALS
   15.17 +#include "jinclude.h"
   15.18 +#include "jpeglib.h"
   15.19 +
   15.20 +
   15.21 +/* We use a full-image coefficient buffer when doing Huffman optimization,
   15.22 + * and also for writing multiple-scan JPEG files.  In all cases, the DCT
   15.23 + * step is run during the first pass, and subsequent passes need only read
   15.24 + * the buffered coefficients.
   15.25 + */
   15.26 +#ifdef ENTROPY_OPT_SUPPORTED
   15.27 +#define FULL_COEF_BUFFER_SUPPORTED
   15.28 +#else
   15.29 +#ifdef C_MULTISCAN_FILES_SUPPORTED
   15.30 +#define FULL_COEF_BUFFER_SUPPORTED
   15.31 +#endif
   15.32 +#endif
   15.33 +
   15.34 +
   15.35 +/* Private buffer controller object */
   15.36 +
   15.37 +typedef struct {
   15.38 +  struct jpeg_c_coef_controller pub; /* public fields */
   15.39 +
   15.40 +  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
   15.41 +  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
   15.42 +  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
   15.43 +  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
   15.44 +
   15.45 +  /* For single-pass compression, it's sufficient to buffer just one MCU
   15.46 +   * (although this may prove a bit slow in practice).  We allocate a
   15.47 +   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
   15.48 +   * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
   15.49 +   * it's not really very big; this is to keep the module interfaces unchanged
   15.50 +   * when a large coefficient buffer is necessary.)
   15.51 +   * In multi-pass modes, this array points to the current MCU's blocks
   15.52 +   * within the virtual arrays.
   15.53 +   */
   15.54 +  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
   15.55 +
   15.56 +  /* In multi-pass modes, we need a virtual block array for each component. */
   15.57 +  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
   15.58 +} my_coef_controller;
   15.59 +
   15.60 +typedef my_coef_controller * my_coef_ptr;
   15.61 +
   15.62 +
   15.63 +/* Forward declarations */
   15.64 +METHODDEF(boolean) compress_data
   15.65 +    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
   15.66 +#ifdef FULL_COEF_BUFFER_SUPPORTED
   15.67 +METHODDEF(boolean) compress_first_pass
   15.68 +    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
   15.69 +METHODDEF(boolean) compress_output
   15.70 +    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
   15.71 +#endif
   15.72 +
   15.73 +
   15.74 +LOCAL(void)
   15.75 +start_iMCU_row (j_compress_ptr cinfo)
   15.76 +/* Reset within-iMCU-row counters for a new row */
   15.77 +{
   15.78 +  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
   15.79 +
   15.80 +  /* In an interleaved scan, an MCU row is the same as an iMCU row.
   15.81 +   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
   15.82 +   * But at the bottom of the image, process only what's left.
   15.83 +   */
   15.84 +  if (cinfo->comps_in_scan > 1) {
   15.85 +    coef->MCU_rows_per_iMCU_row = 1;
   15.86 +  } else {
   15.87 +    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
   15.88 +      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
   15.89 +    else
   15.90 +      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
   15.91 +  }
   15.92 +
   15.93 +  coef->mcu_ctr = 0;
   15.94 +  coef->MCU_vert_offset = 0;
   15.95 +}
   15.96 +
   15.97 +
   15.98 +/*
   15.99 + * Initialize for a processing pass.
  15.100 + */
  15.101 +
  15.102 +METHODDEF(void)
  15.103 +start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
  15.104 +{
  15.105 +  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  15.106 +
  15.107 +  coef->iMCU_row_num = 0;
  15.108 +  start_iMCU_row(cinfo);
  15.109 +
  15.110 +  switch (pass_mode) {
  15.111 +  case JBUF_PASS_THRU:
  15.112 +    if (coef->whole_image[0] != NULL)
  15.113 +      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  15.114 +    coef->pub.compress_data = compress_data;
  15.115 +    break;
  15.116 +#ifdef FULL_COEF_BUFFER_SUPPORTED
  15.117 +  case JBUF_SAVE_AND_PASS:
  15.118 +    if (coef->whole_image[0] == NULL)
  15.119 +      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  15.120 +    coef->pub.compress_data = compress_first_pass;
  15.121 +    break;
  15.122 +  case JBUF_CRANK_DEST:
  15.123 +    if (coef->whole_image[0] == NULL)
  15.124 +      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  15.125 +    coef->pub.compress_data = compress_output;
  15.126 +    break;
  15.127 +#endif
  15.128 +  default:
  15.129 +    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  15.130 +    break;
  15.131 +  }
  15.132 +}
  15.133 +
  15.134 +
  15.135 +/*
  15.136 + * Process some data in the single-pass case.
  15.137 + * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  15.138 + * per call, ie, v_samp_factor block rows for each component in the image.
  15.139 + * Returns TRUE if the iMCU row is completed, FALSE if suspended.
  15.140 + *
  15.141 + * NB: input_buf contains a plane for each component in image,
  15.142 + * which we index according to the component's SOF position.
  15.143 + */
  15.144 +
  15.145 +METHODDEF(boolean)
  15.146 +compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  15.147 +{
  15.148 +  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  15.149 +  JDIMENSION MCU_col_num;	/* index of current MCU within row */
  15.150 +  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  15.151 +  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  15.152 +  int blkn, bi, ci, yindex, yoffset, blockcnt;
  15.153 +  JDIMENSION ypos, xpos;
  15.154 +  jpeg_component_info *compptr;
  15.155 +
  15.156 +  /* Loop to write as much as one whole iMCU row */
  15.157 +  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
  15.158 +       yoffset++) {
  15.159 +    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
  15.160 +	 MCU_col_num++) {
  15.161 +      /* Determine where data comes from in input_buf and do the DCT thing.
  15.162 +       * Each call on forward_DCT processes a horizontal row of DCT blocks
  15.163 +       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
  15.164 +       * sequentially.  Dummy blocks at the right or bottom edge are filled in
  15.165 +       * specially.  The data in them does not matter for image reconstruction,
  15.166 +       * so we fill them with values that will encode to the smallest amount of
  15.167 +       * data, viz: all zeroes in the AC entries, DC entries equal to previous
  15.168 +       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
  15.169 +       */
  15.170 +      blkn = 0;
  15.171 +      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  15.172 +	compptr = cinfo->cur_comp_info[ci];
  15.173 +	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
  15.174 +						: compptr->last_col_width;
  15.175 +	xpos = MCU_col_num * compptr->MCU_sample_width;
  15.176 +	ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
  15.177 +	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
  15.178 +	  if (coef->iMCU_row_num < last_iMCU_row ||
  15.179 +	      yoffset+yindex < compptr->last_row_height) {
  15.180 +	    (*cinfo->fdct->forward_DCT) (cinfo, compptr,
  15.181 +					 input_buf[compptr->component_index],
  15.182 +					 coef->MCU_buffer[blkn],
  15.183 +					 ypos, xpos, (JDIMENSION) blockcnt);
  15.184 +	    if (blockcnt < compptr->MCU_width) {
  15.185 +	      /* Create some dummy blocks at the right edge of the image. */
  15.186 +	      jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
  15.187 +			(compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
  15.188 +	      for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
  15.189 +		coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
  15.190 +	      }
  15.191 +	    }
  15.192 +	  } else {
  15.193 +	    /* Create a row of dummy blocks at the bottom of the image. */
  15.194 +	    jzero_far((void FAR *) coef->MCU_buffer[blkn],
  15.195 +		      compptr->MCU_width * SIZEOF(JBLOCK));
  15.196 +	    for (bi = 0; bi < compptr->MCU_width; bi++) {
  15.197 +	      coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
  15.198 +	    }
  15.199 +	  }
  15.200 +	  blkn += compptr->MCU_width;
  15.201 +	  ypos += DCTSIZE;
  15.202 +	}
  15.203 +      }
  15.204 +      /* Try to write the MCU.  In event of a suspension failure, we will
  15.205 +       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
  15.206 +       */
  15.207 +      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
  15.208 +	/* Suspension forced; update state counters and exit */
  15.209 +	coef->MCU_vert_offset = yoffset;
  15.210 +	coef->mcu_ctr = MCU_col_num;
  15.211 +	return FALSE;
  15.212 +      }
  15.213 +    }
  15.214 +    /* Completed an MCU row, but perhaps not an iMCU row */
  15.215 +    coef->mcu_ctr = 0;
  15.216 +  }
  15.217 +  /* Completed the iMCU row, advance counters for next one */
  15.218 +  coef->iMCU_row_num++;
  15.219 +  start_iMCU_row(cinfo);
  15.220 +  return TRUE;
  15.221 +}
  15.222 +
  15.223 +
  15.224 +#ifdef FULL_COEF_BUFFER_SUPPORTED
  15.225 +
  15.226 +/*
  15.227 + * Process some data in the first pass of a multi-pass case.
  15.228 + * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  15.229 + * per call, ie, v_samp_factor block rows for each component in the image.
  15.230 + * This amount of data is read from the source buffer, DCT'd and quantized,
  15.231 + * and saved into the virtual arrays.  We also generate suitable dummy blocks
  15.232 + * as needed at the right and lower edges.  (The dummy blocks are constructed
  15.233 + * in the virtual arrays, which have been padded appropriately.)  This makes
  15.234 + * it possible for subsequent passes not to worry about real vs. dummy blocks.
  15.235 + *
  15.236 + * We must also emit the data to the entropy encoder.  This is conveniently
  15.237 + * done by calling compress_output() after we've loaded the current strip
  15.238 + * of the virtual arrays.
  15.239 + *
  15.240 + * NB: input_buf contains a plane for each component in image.  All
  15.241 + * components are DCT'd and loaded into the virtual arrays in this pass.
  15.242 + * However, it may be that only a subset of the components are emitted to
  15.243 + * the entropy encoder during this first pass; be careful about looking
  15.244 + * at the scan-dependent variables (MCU dimensions, etc).
  15.245 + */
  15.246 +
  15.247 +METHODDEF(boolean)
  15.248 +compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  15.249 +{
  15.250 +  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  15.251 +  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  15.252 +  JDIMENSION blocks_across, MCUs_across, MCUindex;
  15.253 +  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
  15.254 +  JCOEF lastDC;
  15.255 +  jpeg_component_info *compptr;
  15.256 +  JBLOCKARRAY buffer;
  15.257 +  JBLOCKROW thisblockrow, lastblockrow;
  15.258 +
  15.259 +  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  15.260 +       ci++, compptr++) {
  15.261 +    /* Align the virtual buffer for this component. */
  15.262 +    buffer = (*cinfo->mem->access_virt_barray)
  15.263 +      ((j_common_ptr) cinfo, coef->whole_image[ci],
  15.264 +       coef->iMCU_row_num * compptr->v_samp_factor,
  15.265 +       (JDIMENSION) compptr->v_samp_factor, TRUE);
  15.266 +    /* Count non-dummy DCT block rows in this iMCU row. */
  15.267 +    if (coef->iMCU_row_num < last_iMCU_row)
  15.268 +      block_rows = compptr->v_samp_factor;
  15.269 +    else {
  15.270 +      /* NB: can't use last_row_height here, since may not be set! */
  15.271 +      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
  15.272 +      if (block_rows == 0) block_rows = compptr->v_samp_factor;
  15.273 +    }
  15.274 +    blocks_across = compptr->width_in_blocks;
  15.275 +    h_samp_factor = compptr->h_samp_factor;
  15.276 +    /* Count number of dummy blocks to be added at the right margin. */
  15.277 +    ndummy = (int) (blocks_across % h_samp_factor);
  15.278 +    if (ndummy > 0)
  15.279 +      ndummy = h_samp_factor - ndummy;
  15.280 +    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
  15.281 +     * on forward_DCT processes a complete horizontal row of DCT blocks.
  15.282 +     */
  15.283 +    for (block_row = 0; block_row < block_rows; block_row++) {
  15.284 +      thisblockrow = buffer[block_row];
  15.285 +      (*cinfo->fdct->forward_DCT) (cinfo, compptr,
  15.286 +				   input_buf[ci], thisblockrow,
  15.287 +				   (JDIMENSION) (block_row * DCTSIZE),
  15.288 +				   (JDIMENSION) 0, blocks_across);
  15.289 +      if (ndummy > 0) {
  15.290 +	/* Create dummy blocks at the right edge of the image. */
  15.291 +	thisblockrow += blocks_across; /* => first dummy block */
  15.292 +	jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
  15.293 +	lastDC = thisblockrow[-1][0];
  15.294 +	for (bi = 0; bi < ndummy; bi++) {
  15.295 +	  thisblockrow[bi][0] = lastDC;
  15.296 +	}
  15.297 +      }
  15.298 +    }
  15.299 +    /* If at end of image, create dummy block rows as needed.
  15.300 +     * The tricky part here is that within each MCU, we want the DC values
  15.301 +     * of the dummy blocks to match the last real block's DC value.
  15.302 +     * This squeezes a few more bytes out of the resulting file...
  15.303 +     */
  15.304 +    if (coef->iMCU_row_num == last_iMCU_row) {
  15.305 +      blocks_across += ndummy;	/* include lower right corner */
  15.306 +      MCUs_across = blocks_across / h_samp_factor;
  15.307 +      for (block_row = block_rows; block_row < compptr->v_samp_factor;
  15.308 +	   block_row++) {
  15.309 +	thisblockrow = buffer[block_row];
  15.310 +	lastblockrow = buffer[block_row-1];
  15.311 +	jzero_far((void FAR *) thisblockrow,
  15.312 +		  (size_t) (blocks_across * SIZEOF(JBLOCK)));
  15.313 +	for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
  15.314 +	  lastDC = lastblockrow[h_samp_factor-1][0];
  15.315 +	  for (bi = 0; bi < h_samp_factor; bi++) {
  15.316 +	    thisblockrow[bi][0] = lastDC;
  15.317 +	  }
  15.318 +	  thisblockrow += h_samp_factor; /* advance to next MCU in row */
  15.319 +	  lastblockrow += h_samp_factor;
  15.320 +	}
  15.321 +      }
  15.322 +    }
  15.323 +  }
  15.324 +  /* NB: compress_output will increment iMCU_row_num if successful.
  15.325 +   * A suspension return will result in redoing all the work above next time.
  15.326 +   */
  15.327 +
  15.328 +  /* Emit data to the entropy encoder, sharing code with subsequent passes */
  15.329 +  return compress_output(cinfo, input_buf);
  15.330 +}
  15.331 +
  15.332 +
  15.333 +/*
  15.334 + * Process some data in subsequent passes of a multi-pass case.
  15.335 + * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  15.336 + * per call, ie, v_samp_factor block rows for each component in the scan.
  15.337 + * The data is obtained from the virtual arrays and fed to the entropy coder.
  15.338 + * Returns TRUE if the iMCU row is completed, FALSE if suspended.
  15.339 + *
  15.340 + * NB: input_buf is ignored; it is likely to be a NULL pointer.
  15.341 + */
  15.342 +
  15.343 +METHODDEF(boolean)
  15.344 +compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  15.345 +{
  15.346 +  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  15.347 +  JDIMENSION MCU_col_num;	/* index of current MCU within row */
  15.348 +  int blkn, ci, xindex, yindex, yoffset;
  15.349 +  JDIMENSION start_col;
  15.350 +  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
  15.351 +  JBLOCKROW buffer_ptr;
  15.352 +  jpeg_component_info *compptr;
  15.353 +
  15.354 +  /* Align the virtual buffers for the components used in this scan.
  15.355 +   * NB: during first pass, this is safe only because the buffers will
  15.356 +   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
  15.357 +   */
  15.358 +  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  15.359 +    compptr = cinfo->cur_comp_info[ci];
  15.360 +    buffer[ci] = (*cinfo->mem->access_virt_barray)
  15.361 +      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
  15.362 +       coef->iMCU_row_num * compptr->v_samp_factor,
  15.363 +       (JDIMENSION) compptr->v_samp_factor, FALSE);
  15.364 +  }
  15.365 +
  15.366 +  /* Loop to process one whole iMCU row */
  15.367 +  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
  15.368 +       yoffset++) {
  15.369 +    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
  15.370 +	 MCU_col_num++) {
  15.371 +      /* Construct list of pointers to DCT blocks belonging to this MCU */
  15.372 +      blkn = 0;			/* index of current DCT block within MCU */
  15.373 +      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  15.374 +	compptr = cinfo->cur_comp_info[ci];
  15.375 +	start_col = MCU_col_num * compptr->MCU_width;
  15.376 +	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
  15.377 +	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
  15.378 +	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
  15.379 +	    coef->MCU_buffer[blkn++] = buffer_ptr++;
  15.380 +	  }
  15.381 +	}
  15.382 +      }
  15.383 +      /* Try to write the MCU. */
  15.384 +      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
  15.385 +	/* Suspension forced; update state counters and exit */
  15.386 +	coef->MCU_vert_offset = yoffset;
  15.387 +	coef->mcu_ctr = MCU_col_num;
  15.388 +	return FALSE;
  15.389 +      }
  15.390 +    }
  15.391 +    /* Completed an MCU row, but perhaps not an iMCU row */
  15.392 +    coef->mcu_ctr = 0;
  15.393 +  }
  15.394 +  /* Completed the iMCU row, advance counters for next one */
  15.395 +  coef->iMCU_row_num++;
  15.396 +  start_iMCU_row(cinfo);
  15.397 +  return TRUE;
  15.398 +}
  15.399 +
  15.400 +#endif /* FULL_COEF_BUFFER_SUPPORTED */
  15.401 +
  15.402 +
  15.403 +/*
  15.404 + * Initialize coefficient buffer controller.
  15.405 + */
  15.406 +
  15.407 +GLOBAL(void)
  15.408 +jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
  15.409 +{
  15.410 +  my_coef_ptr coef;
  15.411 +
  15.412 +  coef = (my_coef_ptr)
  15.413 +    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  15.414 +				SIZEOF(my_coef_controller));
  15.415 +  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
  15.416 +  coef->pub.start_pass = start_pass_coef;
  15.417 +
  15.418 +  /* Create the coefficient buffer. */
  15.419 +  if (need_full_buffer) {
  15.420 +#ifdef FULL_COEF_BUFFER_SUPPORTED
  15.421 +    /* Allocate a full-image virtual array for each component, */
  15.422 +    /* padded to a multiple of samp_factor DCT blocks in each direction. */
  15.423 +    int ci;
  15.424 +    jpeg_component_info *compptr;
  15.425 +
  15.426 +    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  15.427 +	 ci++, compptr++) {
  15.428 +      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
  15.429 +	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
  15.430 +	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
  15.431 +				(long) compptr->h_samp_factor),
  15.432 +	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
  15.433 +				(long) compptr->v_samp_factor),
  15.434 +	 (JDIMENSION) compptr->v_samp_factor);
  15.435 +    }
  15.436 +#else
  15.437 +    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  15.438 +#endif
  15.439 +  } else {
  15.440 +    /* We only need a single-MCU buffer. */
  15.441 +    JBLOCKROW buffer;
  15.442 +    int i;
  15.443 +
  15.444 +    buffer = (JBLOCKROW)
  15.445 +      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  15.446 +				  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
  15.447 +    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
  15.448 +      coef->MCU_buffer[i] = buffer + i;
  15.449 +    }
  15.450 +    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
  15.451 +  }
  15.452 +}

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/libs/libjpeg/jccolor.c	Thu Sep 08 06:28:38 2011 +0300
    16.3 @@ -0,0 +1,459 @@
    16.4 +/*
    16.5 + * jccolor.c
    16.6 + *
    16.7 + * Copyright (C) 1991-1996, Thomas G. Lane.
    16.8 + * This file is part of the Independent JPEG Group's software.
    16.9 + * For conditions of distribution and use, see the accompanying README file.
   16.10 + *
   16.11 + * This file contains input colorspace conversion routines.
   16.12 + */
   16.13 +
   16.14 +#define JPEG_INTERNALS
   16.15 +#include "jinclude.h"
   16.16 +#include "jpeglib.h"
   16.17 +
   16.18 +
   16.19 +/* Private subobject */
   16.20 +
   16.21 +typedef struct {
   16.22 +  struct jpeg_color_converter pub; /* public fields */
   16.23 +
   16.24 +  /* Private state for RGB->YCC conversion */
   16.25 +  INT32 * rgb_ycc_tab;		/* => table for RGB to YCbCr conversion */
   16.26 +} my_color_converter;
   16.27 +
   16.28 +typedef my_color_converter * my_cconvert_ptr;
   16.29 +
   16.30 +
   16.31 +/**************** RGB -> YCbCr conversion: most common case **************/
   16.32 +
   16.33 +/*
   16.34 + * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
   16.35 + * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
   16.36 + * The conversion equations to be implemented are therefore
   16.37 + *	Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
   16.38 + *	Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
   16.39 + *	Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
   16.40 + * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
   16.41 + * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
   16.42 + * rather than CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
   16.43 + * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
   16.44 + * were not represented exactly.  Now we sacrifice exact representation of
   16.45 + * maximum red and maximum blue in order to get exact grayscales.
   16.46 + *
   16.47 + * To avoid floating-point arithmetic, we represent the fractional constants
   16.48 + * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
   16.49 + * the products by 2^16, with appropriate rounding, to get the correct answer.
   16.50 + *
   16.51 + * For even more speed, we avoid doing any multiplications in the inner loop
   16.52 + * by precalculating the constants times R,G,B for all possible values.
   16.53 + * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
   16.54 + * for 12-bit samples it is still acceptable.  It's not very reasonable for
   16.55 + * 16-bit samples, but if you want lossless storage you shouldn't be changing
   16.56 + * colorspace anyway.
   16.57 + * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
   16.58 + * in the tables to save adding them separately in the inner loop.
   16.59 + */
   16.60 +
   16.61 +#define SCALEBITS	16	/* speediest right-shift on some machines */
   16.62 +#define CBCR_OFFSET	((INT32) CENTERJSAMPLE << SCALEBITS)
   16.63 +#define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
   16.64 +#define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
   16.65 +
   16.66 +/* We allocate one big table and divide it up into eight parts, instead of
   16.67 + * doing eight alloc_small requests.  This lets us use a single table base
   16.68 + * address, which can be held in a register in the inner loops on many
   16.69 + * machines (more than can hold all eight addresses, anyway).
   16.70 + */
   16.71 +
   16.72 +#define R_Y_OFF		0			/* offset to R => Y section */
   16.73 +#define G_Y_OFF		(1*(MAXJSAMPLE+1))	/* offset to G => Y section */
   16.74 +#define B_Y_OFF		(2*(MAXJSAMPLE+1))	/* etc. */
   16.75 +#define R_CB_OFF	(3*(MAXJSAMPLE+1))
   16.76 +#define G_CB_OFF	(4*(MAXJSAMPLE+1))
   16.77 +#define B_CB_OFF	(5*(MAXJSAMPLE+1))
   16.78 +#define R_CR_OFF	B_CB_OFF		/* B=>Cb, R=>Cr are the same */
   16.79 +#define G_CR_OFF	(6*(MAXJSAMPLE+1))
   16.80 +#define B_CR_OFF	(7*(MAXJSAMPLE+1))
   16.81 +#define TABLE_SIZE	(8*(MAXJSAMPLE+1))
   16.82 +
   16.83 +
   16.84 +/*
   16.85 + * Initialize for RGB->YCC colorspace conversion.
   16.86 + */
   16.87 +
   16.88 +METHODDEF(void)
   16.89 +rgb_ycc_start (j_compress_ptr cinfo)
   16.90 +{
   16.91 +  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   16.92 +  INT32 * rgb_ycc_tab;
   16.93 +  INT32 i;
   16.94 +
   16.95 +  /* Allocate and fill in the conversion tables. */
   16.96 +  cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
   16.97 +    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
   16.98 +				(TABLE_SIZE * SIZEOF(INT32)));
   16.99 +
  16.100 +  for (i = 0; i <= MAXJSAMPLE; i++) {
  16.101 +    rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
  16.102 +    rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i;
  16.103 +    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i     + ONE_HALF;
  16.104 +    rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i;
  16.105 +    rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i;
  16.106 +    /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
  16.107 +     * This ensures that the maximum output will round to MAXJSAMPLE
  16.108 +     * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
  16.109 +     */
  16.110 +    rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
  16.111 +/*  B=>Cb and R=>Cr tables are the same
  16.112 +    rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
  16.113 +*/
  16.114 +    rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i;
  16.115 +    rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i;
  16.116 +  }
  16.117 +}
  16.118 +
  16.119 +
  16.120 +/*
  16.121 + * Convert some rows of samples to the JPEG colorspace.
  16.122 + *
  16.123 + * Note that we change from the application's interleaved-pixel format
  16.124 + * to our internal noninterleaved, one-plane-per-component format.
  16.125 + * The input buffer is therefore three times as wide as the output buffer.
  16.126 + *
  16.127 + * A starting row offset is provided only for the output buffer.  The caller
  16.128 + * can easily adjust the passed input_buf value to accommodate any row
  16.129 + * offset required on that side.
  16.130 + */
  16.131 +
  16.132 +METHODDEF(void)
  16.133 +rgb_ycc_convert (j_compress_ptr cinfo,
  16.134 +		 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  16.135 +		 JDIMENSION output_row, int num_rows)
  16.136 +{
  16.137 +  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  16.138 +  register int r, g, b;
  16.139 +  register INT32 * ctab = cconvert->rgb_ycc_tab;
  16.140 +  register JSAMPROW inptr;
  16.141 +  register JSAMPROW outptr0, outptr1, outptr2;
  16.142 +  register JDIMENSION col;
  16.143 +  JDIMENSION num_cols = cinfo->image_width;
  16.144 +
  16.145 +  while (--num_rows >= 0) {
  16.146 +    inptr = *input_buf++;
  16.147 +    outptr0 = output_buf[0][output_row];
  16.148 +    outptr1 = output_buf[1][output_row];
  16.149 +    outptr2 = output_buf[2][output_row];
  16.150 +    output_row++;
  16.151 +    for (col = 0; col < num_cols; col++) {
  16.152 +      r = GETJSAMPLE(inptr[RGB_RED]);
  16.153 +      g = GETJSAMPLE(inptr[RGB_GREEN]);
  16.154 +      b = GETJSAMPLE(inptr[RGB_BLUE]);
  16.155 +      inptr += RGB_PIXELSIZE;
  16.156 +      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
  16.157 +       * must be too; we do not need an explicit range-limiting operation.
  16.158 +       * Hence the value being shifted is never negative, and we don't
  16.159 +       * need the general RIGHT_SHIFT macro.
  16.160 +       */
  16.161 +      /* Y */
  16.162 +      outptr0[col] = (JSAMPLE)
  16.163 +		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
  16.164 +		 >> SCALEBITS);
  16.165 +      /* Cb */
  16.166 +      outptr1[col] = (JSAMPLE)
  16.167 +		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
  16.168 +		 >> SCALEBITS);
  16.169 +      /* Cr */
  16.170 +      outptr2[col] = (JSAMPLE)
  16.171 +		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
  16.172 +		 >> SCALEBITS);
  16.173 +    }
  16.174 +  }
  16.175 +}
  16.176 +
  16.177 +
  16.178 +/**************** Cases other than RGB -> YCbCr **************/
  16.179 +
  16.180 +
  16.181 +/*
  16.182 + * Convert some rows of samples to the JPEG colorspace.
  16.183 + * This version handles RGB->grayscale conversion, which is the same
  16.184 + * as the RGB->Y portion of RGB->YCbCr.
  16.185 + * We assume rgb_ycc_start has been called (we only use the Y tables).
  16.186 + */
  16.187 +
  16.188 +METHODDEF(void)
  16.189 +rgb_gray_convert (j_compress_ptr cinfo,
  16.190 +		  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  16.191 +		  JDIMENSION output_row, int num_rows)
  16.192 +{
  16.193 +  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  16.194 +  register int r, g, b;
  16.195 +  register INT32 * ctab = cconvert->rgb_ycc_tab;
  16.196 +  register JSAMPROW inptr;
  16.197 +  register JSAMPROW outptr;
  16.198 +  register JDIMENSION col;
  16.199 +  JDIMENSION num_cols = cinfo->image_width;
  16.200 +
  16.201 +  while (--num_rows >= 0) {
  16.202 +    inptr = *input_buf++;
  16.203 +    outptr = output_buf[0][output_row];
  16.204 +    output_row++;
  16.205 +    for (col = 0; col < num_cols; col++) {
  16.206 +      r = GETJSAMPLE(inptr[RGB_RED]);
  16.207 +      g = GETJSAMPLE(inptr[RGB_GREEN]);
  16.208 +      b = GETJSAMPLE(inptr[RGB_BLUE]);
  16.209 +      inptr += RGB_PIXELSIZE;
  16.210 +      /* Y */
  16.211 +      outptr[col] = (JSAMPLE)
  16.212 +		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
  16.213 +		 >> SCALEBITS);
  16.214 +    }
  16.215 +  }
  16.216 +}
  16.217 +
  16.218 +
  16.219 +/*
  16.220 + * Convert some rows of samples to the JPEG colorspace.
  16.221 + * This version handles Adobe-style CMYK->YCCK conversion,
  16.222 + * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
  16.223 + * conversion as above, while passing K (black) unchanged.
  16.224 + * We assume rgb_ycc_start has been called.
  16.225 + */
  16.226 +
  16.227 +METHODDEF(void)
  16.228 +cmyk_ycck_convert (j_compress_ptr cinfo,
  16.229 +		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  16.230 +		   JDIMENSION output_row, int num_rows)
  16.231 +{
  16.232 +  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  16.233 +  register int r, g, b;
  16.234 +  register INT32 * ctab = cconvert->rgb_ycc_tab;
  16.235 +  register JSAMPROW inptr;
  16.236 +  register JSAMPROW outptr0, outptr1, outptr2, outptr3;
  16.237 +  register JDIMENSION col;
  16.238 +  JDIMENSION num_cols = cinfo->image_width;
  16.239 +
  16.240 +  while (--num_rows >= 0) {
  16.241 +    inptr = *input_buf++;
  16.242 +    outptr0 = output_buf[0][output_row];
  16.243 +    outptr1 = output_buf[1][output_row];
  16.244 +    outptr2 = output_buf[2][output_row];
  16.245 +    outptr3 = output_buf[3][output_row];
  16.246 +    output_row++;
  16.247 +    for (col = 0; col < num_cols; col++) {
  16.248 +      r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
  16.249 +      g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
  16.250 +      b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
  16.251 +      /* K passes through as-is */
  16.252 +      outptr3[col] = inptr[3];	/* don't need GETJSAMPLE here */
  16.253 +      inptr += 4;
  16.254 +      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
  16.255 +       * must be too; we do not need an explicit range-limiting operation.
  16.256 +       * Hence the value being shifted is never negative, and we don't
  16.257 +       * need the general RIGHT_SHIFT macro.
  16.258 +       */
  16.259 +      /* Y */
  16.260 +      outptr0[col] = (JSAMPLE)
  16.261 +		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
  16.262 +		 >> SCALEBITS);
  16.263 +      /* Cb */
  16.264 +      outptr1[col] = (JSAMPLE)
  16.265 +		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
  16.266 +		 >> SCALEBITS);
  16.267 +      /* Cr */
  16.268 +      outptr2[col] = (JSAMPLE)
  16.269 +		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
  16.270 +		 >> SCALEBITS);
  16.271 +    }
  16.272 +  }
  16.273 +}
  16.274 +
  16.275 +
  16.276 +/*
  16.277 + * Convert some rows of samples to the JPEG colorspace.
  16.278 + * This version handles grayscale output with no conversion.
  16.279 + * The source can be either plain grayscale or YCbCr (since Y == gray).
  16.280 + */
  16.281 +
  16.282 +METHODDEF(void)
  16.283 +grayscale_convert (j_compress_ptr cinfo,
  16.284 +		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  16.285 +		   JDIMENSION output_row, int num_rows)
  16.286 +{
  16.287 +  register JSAMPROW inptr;
  16.288 +  register JSAMPROW outptr;
  16.289 +  register JDIMENSION col;
  16.290 +  JDIMENSION num_cols = cinfo->image_width;
  16.291 +  int instride = cinfo->input_components;
  16.292 +
  16.293 +  while (--num_rows >= 0) {
  16.294 +    inptr = *input_buf++;
  16.295 +    outptr = output_buf[0][output_row];
  16.296 +    output_row++;
  16.297 +    for (col = 0; col < num_cols; col++) {
  16.298 +      outptr[col] = inptr[0];	/* don't need GETJSAMPLE() here */
  16.299 +      inptr += instride;
  16.300 +    }
  16.301 +  }
  16.302 +}
  16.303 +
  16.304 +
  16.305 +/*
  16.306 + * Convert some rows of samples to the JPEG colorspace.
  16.307 + * This version handles multi-component colorspaces without conversion.
  16.308 + * We assume input_components == num_components.
  16.309 + */
  16.310 +
  16.311 +METHODDEF(void)
  16.312 +null_convert (j_compress_ptr cinfo,
  16.313 +	      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  16.314 +	      JDIMENSION output_row, int num_rows)
  16.315 +{
  16.316 +  register JSAMPROW inptr;
  16.317 +  register JSAMPROW outptr;
  16.318 +  register JDIMENSION col;
  16.319 +  register int ci;
  16.320 +  int nc = cinfo->num_components;
  16.321 +  JDIMENSION num_cols = cinfo->image_width;
  16.322 +
  16.323 +  while (--num_rows >= 0) {
  16.324 +    /* It seems fastest to make a separate pass for each component. */
  16.325 +    for (ci = 0; ci < nc; ci++) {
  16.326 +      inptr = *input_buf;
  16.327 +      outptr = output_buf[ci][output_row];
  16.328 +      for (col = 0; col < num_cols; col++) {
  16.329 +	outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
  16.330 +	inptr += nc;
  16.331 +      }
  16.332 +    }
  16.333 +    input_buf++;
  16.334 +    output_row++;
  16.335 +  }
  16.336 +}
  16.337 +
  16.338 +
  16.339 +/*
  16.340 + * Empty method for start_pass.
  16.341 + */
  16.342 +
  16.343 +METHODDEF(void)
  16.344 +null_method (j_compress_ptr cinfo)
  16.345 +{
  16.346 +  /* no work needed */
  16.347 +}
  16.348 +
  16.349 +
  16.350 +/*
  16.351 + * Module initialization routine for input colorspace conversion.
  16.352 + */
  16.353 +
  16.354 +GLOBAL(void)
  16.355 +jinit_color_converter (j_compress_ptr cinfo)
  16.356 +{
  16.357 +  my_cconvert_ptr cconvert;
  16.358 +
  16.359 +  cconvert = (my_cconvert_ptr)
  16.360 +    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  16.361 +				SIZEOF(my_color_converter));
  16.362 +  cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
  16.363 +  /* set start_pass to null method until we find out differently */
  16.364 +  cconvert->pub.start_pass = null_method;
  16.365 +
  16.366 +  /* Make sure input_components agrees with in_color_space */
  16.367 +  switch (cinfo->in_color_space) {
  16.368 +  case JCS_GRAYSCALE:
  16.369 +    if (cinfo->input_components != 1)
  16.370 +      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
  16.371 +    break;
  16.372 +
  16.373 +  case JCS_RGB:
  16.374 +#if RGB_PIXELSIZE != 3
  16.375 +    if (cinfo->input_components != RGB_PIXELSIZE)
  16.376 +      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
  16.377 +    break;
  16.378 +#endif /* else share code with YCbCr */
  16.379 +
  16.380 +  case JCS_YCbCr:
  16.381 +    if (cinfo->input_components != 3)
  16.382 +      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
  16.383 +    break;
  16.384 +
  16.385 +  case JCS_CMYK:
  16.386 +  case JCS_YCCK:
  16.387 +    if (cinfo->input_components != 4)
  16.388 +      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
  16.389 +    break;
  16.390 +
  16.391 +  default:			/* JCS_UNKNOWN can be anything */
  16.392 +    if (cinfo->input_components < 1)
  16.393 +      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
  16.394 +    break;
  16.395 +  }
  16.396 +
  16.397 +  /* Check num_components, set conversion method based on requested space */
  16.398 +  switch (cinfo->jpeg_color_space) {
  16.399 +  case JCS_GRAYSCALE:
  16.400 +    if (cinfo->num_components != 1)
  16.401 +      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
  16.402 +    if (cinfo->in_color_space == JCS_GRAYSCALE)
  16.403 +      cconvert->pub.color_convert = grayscale_convert;
  16.404 +    else if (cinfo->in_color_space == JCS_RGB) {
  16.405 +      cconvert->pub.start_pass = rgb_ycc_start;
  16.406 +      cconvert->pub.color_convert = rgb_gray_convert;
  16.407 +    } else if (cinfo->in_color_space == JCS_YCbCr)
  16.408 +      cconvert->pub.color_convert = grayscale_convert;
  16.409 +    else
  16.410 +      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  16.411 +    break;
  16.412 +
  16.413 +  case JCS_RGB:
  16.414 +    if (cinfo->num_components != 3)
  16.415 +      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
  16.416 +    if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3)
  16.417 +      cconvert->pub.color_convert = null_convert;
  16.418 +    else
  16.419 +      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  16.420 +    break;
  16.421 +
  16.422 +  case JCS_YCbCr:
  16.423 +    if (cinfo->num_components != 3)
  16.424 +      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
  16.425 +    if (cinfo->in_color_space == JCS_RGB) {
  16.426 +      cconvert->pub.start_pass = rgb_ycc_start;
  16.427 +      cconvert->pub.color_convert = rgb_ycc_convert;
  16.428 +    } else if (cinfo->in_color_space == JCS_YCbCr)
  16.429 +      cconvert->pub.color_convert = null_convert;
  16.430 +    else
  16.431 +      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  16.432 +    break;
  16.433 +
  16.434 +  case JCS_CMYK:
  16.435 +    if (cinfo->num_components != 4)
  16.436 +      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
  16.437 +    if (cinfo->in_color_space == JCS_CMYK)
  16.438 +      cconvert->pub.color_convert = null_convert;
  16.439 +    else
  16.440 +      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  16.441 +    break;
  16.442 +
  16.443 +  case JCS_YCCK:
  16.444 +    if (cinfo->num_components != 4)
  16.445 +      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
  16.446 +    if (cinfo->in_color_space == JCS_CMYK) {
  16.447 +      cconvert->pub.start_pass = rgb_ycc_start;
  16.448 +      cconvert->pub.color_convert = cmyk_ycck_convert;
  16.449 +    } else if (cinfo->in_color_space == JCS_YCCK)
  16.450 +      cconvert->pub.color_convert = null_convert;
  16.451 +    else
  16.452 +      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  16.453 +    break;
  16.454 +
  16.455 +  default:			/* allow null conversion of JCS_UNKNOWN */
  16.456 +    if (cinfo->jpeg_color_space != cinfo->in_color_space ||
  16.457 +	cinfo->num_components != cinfo->input_components)
  16.458 +      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  16.459 +    cconvert->pub.color_convert = null_convert;
  16.460 +    break;
  16.461 +  }
  16.462 +}

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/libs/libjpeg/jcdctmgr.c	Thu Sep 08 06:28:38 2011 +0300
    17.3 @@ -0,0 +1,387 @@
    17.4 +/*
    17.5 + * jcdctmgr.c
    17.6 + *
    17.7 + * Copyright (C) 1994-1996, Thomas G. Lane.
    17.8 + * This file is part of the Independent JPEG Group's software.
    17.9 + * For conditions of distribution and use, see the accompanying README file.
   17.10 + *
   17.11 + * This file contains the forward-DCT management logic.
   17.12 + * This code selects a particular DCT implementation to be used,
   17.13 + * and it performs related housekeeping chores including coefficient
   17.14 + * quantization.
   17.15 + */
   17.16 +
   17.17 +#define JPEG_INTERNALS
   17.18 +#include "jinclude.h"
   17.19 +#include "jpeglib.h"
   17.20 +#include "jdct.h"		/* Private declarations for DCT subsystem */
   17.21 +
   17.22 +
   17.23 +/* Private subobject for this module */
   17.24 +
   17.25 +typedef struct {
   17.26 +  struct jpeg_forward_dct pub;	/* public fields */
   17.27 +
   17.28 +  /* Pointer to the DCT routine actually in use */
   17.29 +  forward_DCT_method_ptr do_dct;
   17.30 +
   17.31 +  /* The actual post-DCT divisors --- not identical to the quant table
   17.32 +   * entries, because of scaling (especially for an unnormalized DCT).
   17.33 +   * Each table is given in normal array order.
   17.34 +   */
   17.35 +  DCTELEM * divisors[NUM_QUANT_TBLS];
   17.36 +
   17.37 +#ifdef DCT_FLOAT_SUPPORTED
   17.38 +  /* Same as above for the floating-point case. */
   17.39 +  float_DCT_method_ptr do_float_dct;
   17.40 +  FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
   17.41 +#endif
   17.42 +} my_fdct_controller;
   17.43 +
   17.44 +typedef my_fdct_controller * my_fdct_ptr;
   17.45 +
   17.46 +
   17.47 +/*
   17.48 + * Initialize for a processing pass.
   17.49 + * Verify that all referenced Q-tables are present, and set up
   17.50 + * the divisor table for each one.
   17.51 + * In the current implementation, DCT of all components is done during
   17.52 + * the first pass, even if only some components will be output in the
   17.53 + * first scan.  Hence all components should be examined here.
   17.54 + */
   17.55 +
   17.56 +METHODDEF(void)
   17.57 +start_pass_fdctmgr (j_compress_ptr cinfo)
   17.58 +{
   17.59 +  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
   17.60 +  int ci, qtblno, i;
   17.61 +  jpeg_component_info *compptr;
   17.62 +  JQUANT_TBL * qtbl;
   17.63 +  DCTELEM * dtbl;
   17.64 +
   17.65 +  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
   17.66 +       ci++, compptr++) {
   17.67 +    qtblno = compptr->quant_tbl_no;
   17.68 +    /* Make sure specified quantization table is present */
   17.69 +    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
   17.70 +	cinfo->quant_tbl_ptrs[qtblno] == NULL)
   17.71 +      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
   17.72 +    qtbl = cinfo->quant_tbl_ptrs[qtblno];
   17.73 +    /* Compute divisors for this quant table */
   17.74 +    /* We may do this more than once for same table, but it's not a big deal */
   17.75 +    switch (cinfo->dct_method) {
   17.76 +#ifdef DCT_ISLOW_SUPPORTED
   17.77 +    case JDCT_ISLOW:
   17.78 +      /* For LL&M IDCT method, divisors are equal to raw quantization
   17.79 +       * coefficients multiplied by 8 (to counteract scaling).
   17.80 +       */
   17.81 +      if (fdct->divisors[qtblno] == NULL) {
   17.82 +	fdct->divisors[qtblno] = (DCTELEM *)
   17.83 +	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
   17.84 +				      DCTSIZE2 * SIZEOF(DCTELEM));
   17.85 +      }
   17.86 +      dtbl = fdct->divisors[qtblno];
   17.87 +      for (i = 0; i < DCTSIZE2; i++) {
   17.88 +	dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
   17.89 +      }
   17.90 +      break;
   17.91 +#endif
   17.92 +#ifdef DCT_IFAST_SUPPORTED
   17.93 +    case JDCT_IFAST:
   17.94 +      {
   17.95 +	/* For AA&N IDCT method, divisors are equal to quantization
   17.96 +	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
   17.97 +	 *   scalefactor[0] = 1
   17.98 +	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
   17.99 +	 * We apply a further scale factor of 8.
  17.100 +	 */
  17.101 +#define CONST_BITS 14
  17.102 +	static const INT16 aanscales[DCTSIZE2] = {
  17.103 +	  /* precomputed values scaled up by 14 bits */
  17.104 +	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  17.105 +	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  17.106 +	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  17.107 +	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  17.108 +	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  17.109 +	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  17.110 +	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  17.111 +	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  17.112 +	};
  17.113 +	SHIFT_TEMPS
  17.114 +
  17.115 +	if (fdct->divisors[qtblno] == NULL) {
  17.116 +	  fdct->divisors[qtblno] = (DCTELEM *)
  17.117 +	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  17.118 +					DCTSIZE2 * SIZEOF(DCTELEM));
  17.119 +	}
  17.120 +	dtbl = fdct->divisors[qtblno];
  17.121 +	for (i = 0; i < DCTSIZE2; i++) {
  17.122 +	  dtbl[i] = (DCTELEM)
  17.123 +	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
  17.124 +				  (INT32) aanscales[i]),
  17.125 +		    CONST_BITS-3);
  17.126 +	}
  17.127 +      }
  17.128 +      break;
  17.129 +#endif
  17.130 +#ifdef DCT_FLOAT_SUPPORTED
  17.131 +    case JDCT_FLOAT:
  17.132 +      {
  17.133 +	/* For float AA&N IDCT method, divisors are equal to quantization
  17.134 +	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
  17.135 +	 *   scalefactor[0] = 1
  17.136 +	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
  17.137 +	 * We apply a further scale factor of 8.
  17.138 +	 * What's actually stored is 1/divisor so that the inner loop can
  17.139 +	 * use a multiplication rather than a division.
  17.140 +	 */
  17.141 +	FAST_FLOAT * fdtbl;
  17.142 +	int row, col;
  17.143 +	static const double aanscalefactor[DCTSIZE] = {
  17.144 +	  1.0, 1.387039845, 1.306562965, 1.175875602,
  17.145 +	  1.0, 0.785694958, 0.541196100, 0.275899379
  17.146 +	};
  17.147 +
  17.148 +	if (fdct->float_divisors[qtblno] == NULL) {
  17.149 +	  fdct->float_divisors[qtblno] = (FAST_FLOAT *)
  17.150 +	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  17.151 +					DCTSIZE2 * SIZEOF(FAST_FLOAT));
  17.152 +	}
  17.153 +	fdtbl = fdct->float_divisors[qtblno];
  17.154 +	i = 0;
  17.155 +	for (row = 0; row < DCTSIZE; row++) {
  17.156 +	  for (col = 0; col < DCTSIZE; col++) {
  17.157 +	    fdtbl[i] = (FAST_FLOAT)
  17.158 +	      (1.0 / (((double) qtbl->quantval[i] *
  17.159 +		       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
  17.160 +	    i++;
  17.161 +	  }
  17.162 +	}
  17.163 +      }
  17.164 +      break;
  17.165 +#endif
  17.166 +    default:
  17.167 +      ERREXIT(cinfo, JERR_NOT_COMPILED);
  17.168 +      break;
  17.169 +    }
  17.170 +  }
  17.171 +}
  17.172 +
  17.173 +
  17.174 +/*
  17.175 + * Perform forward DCT on one or more blocks of a component.
  17.176 + *
  17.177 + * The input samples are taken from the sample_data[] array starting at
  17.178 + * position start_row/start_col, and moving to the right for any additional
  17.179 + * blocks. The quantized coefficients are returned in coef_blocks[].
  17.180 + */
  17.181 +
  17.182 +METHODDEF(void)
  17.183 +forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
  17.184 +	     JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
  17.185 +	     JDIMENSION start_row, JDIMENSION start_col,
  17.186 +	     JDIMENSION num_blocks)
  17.187 +/* This version is used for integer DCT implementations. */
  17.188 +{
  17.189 +  /* This routine is heavily used, so it's worth coding it tightly. */
  17.190 +  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  17.191 +  forward_DCT_method_ptr do_dct = fdct->do_dct;
  17.192 +  DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
  17.193 +  DCTELEM workspace[DCTSIZE2];	/* work area for FDCT subroutine */
  17.194 +  JDIMENSION bi;
  17.195 +
  17.196 +  sample_data += start_row;	/* fold in the vertical offset once */
  17.197 +
  17.198 +  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
  17.199 +    /* Load data into workspace, applying unsigned->signed conversion */
  17.200 +    { register DCTELEM *workspaceptr;
  17.201 +      register JSAMPROW elemptr;
  17.202 +      register int elemr;
  17.203 +
  17.204 +      workspaceptr = workspace;
  17.205 +      for (elemr = 0; elemr < DCTSIZE; elemr++) {
  17.206 +	elemptr = sample_data[elemr] + start_col;
  17.207 +#if DCTSIZE == 8		/* unroll the inner loop */
  17.208 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.209 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.210 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.211 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.212 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.213 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.214 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.215 +	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.216 +#else
  17.217 +	{ register int elemc;
  17.218 +	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
  17.219 +	    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  17.220 +	  }
  17.221 +	}
  17.222 +#endif
  17.223 +      }
  17.224 +    }
  17.225 +
  17.226 +    /* Perform the DCT */
  17.227 +    (*do_dct) (workspace);
  17.228 +
  17.229 +    /* Quantize/descale the coefficients, and store into coef_blocks[] */
  17.230 +    { register DCTELEM temp, qval;
  17.231 +      register int i;
  17.232 +      register JCOEFPTR output_ptr = coef_blocks[bi];
  17.233 +
  17.234 +      for (i = 0; i < DCTSIZE2; i++) {
  17.235 +	qval = divisors[i];
  17.236 +	temp = workspace[i];
  17.237 +	/* Divide the coefficient value by qval, ensuring proper rounding.
  17.238 +	 * Since C does not specify the direction of rounding for negative
  17.239 +	 * quotients, we have to force the dividend positive for portability.
  17.240 +	 *
  17.241 +	 * In most files, at least half of the output values will be zero
  17.242 +	 * (at default quantization settings, more like three-quarters...)
  17.243 +	 * so we should ensure that this case is fast.  On many machines,
  17.244 +	 * a comparison is enough cheaper than a divide to make a special test
  17.245 +	 * a win.  Since both inputs will be nonnegative, we need only test
  17.246 +	 * for a < b to discover whether a/b is 0.
  17.247 +	 * If your machine's division is fast enough, define FAST_DIVIDE.
  17.248 +	 */
  17.249 +#ifdef FAST_DIVIDE
  17.250 +#define DIVIDE_BY(a,b)	a /= b
  17.251 +#else
  17.252 +#define DIVIDE_BY(a,b)	if (a >= b) a /= b; else a = 0
  17.253 +#endif
  17.254 +	if (temp < 0) {
  17.255 +	  temp = -temp;
  17.256 +	  temp += qval>>1;	/* for rounding */
  17.257 +	  DIVIDE_BY(temp, qval);
  17.258 +	  temp = -temp;
  17.259 +	} else {
  17.260 +	  temp += qval>>1;	/* for rounding */
  17.261 +	  DIVIDE_BY(temp, qval);
  17.262 +	}
  17.263 +	output_ptr[i] = (JCOEF) temp;
  17.264 +      }
  17.265 +    }
  17.266 +  }
  17.267 +}
  17.268 +
  17.269 +
  17.270 +#ifdef DCT_FLOAT_SUPPORTED
  17.271 +
  17.272 +METHODDEF(void)
  17.273 +forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
  17.274 +		   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
  17.275 +		   JDIMENSION start_row, JDIMENSION start_col,
  17.276 +		   JDIMENSION num_blocks)
  17.277 +/* This version is used for floating-point DCT implementations. */
  17.278 +{
  17.279 +  /* This routine is heavily used, so it's worth coding it tightly. */
  17.280 +  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  17.281 +  float_DCT_method_ptr do_dct = fdct->do_float_dct;
  17.282 +  FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
  17.283 +  FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
  17.284 +  JDIMENSION bi;
  17.285 +
  17.286 +  sample_data += start_row;	/* fold in the vertical offset once */
  17.287 +
  17.288 +  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
  17.289 +    /* Load data into workspace, applying unsigned->signed conversion */
  17.290 +    { register FAST_FLOAT *workspaceptr;
  17.291 +      register JSAMPROW elemptr;
  17.292 +      register int elemr;
  17.293 +
  17.294 +      workspaceptr = workspace;
  17.295 +      for (elemr = 0; elemr < DCTSIZE; elemr++) {
  17.296 +	elemptr = sample_data[elemr] + start_col;
  17.297 +#if DCTSIZE == 8		/* unroll the inner loop */
  17.298 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.299 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.300 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.301 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.302 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.303 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.304 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.305 +	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.306 +#else
  17.307 +	{ register int elemc;
  17.308 +	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
  17.309 +	    *workspaceptr++ = (FAST_FLOAT)
  17.310 +	      (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  17.311 +	  }
  17.312 +	}
  17.313 +#endif
  17.314 +      }
  17.315 +    }
  17.316 +
  17.317 +    /* Perform the DCT */
  17.318 +    (*do_dct) (workspace);
  17.319 +
  17.320 +    /* Quantize/descale the coefficients, and store into coef_blocks[] */
  17.321 +    { register FAST_FLOAT temp;
  17.322 +      register int i;
  17.323 +      register JCOEFPTR output_ptr = coef_blocks[bi];
  17.324 +
  17.325 +      for (i = 0; i < DCTSIZE2; i++) {
  17.326 +	/* Apply the quantization and scaling factor */
  17.327 +	temp = workspace[i] * divisors[i];
  17.328 +	/* Round to nearest integer.
  17.329 +	 * Since C does not specify the direction of rounding for negative
  17.330 +	 * quotients, we have to force the dividend positive for portability.
  17.331 +	 * The maximum coefficient size is +-16K (for 12-bit data), so this
  17.332 +	 * code should work for either 16-bit or 32-bit ints.
  17.333 +	 */
  17.334 +	output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
  17.335 +      }
  17.336 +    }
  17.337 +  }
  17.338 +}
  17.339 +
  17.340 +#endif /* DCT_FLOAT_SUPPORTED */
  17.341 +
  17.342 +
  17.343 +/*
  17.344 + * Initialize FDCT manager.
  17.345 + */
  17.346 +
  17.347 +GLOBAL(void)
  17.348 +jinit_forward_dct (j_compress_ptr cinfo)
  17.349 +{
  17.350 +  my_fdct_ptr fdct;
  17.351 +  int i;
  17.352 +
  17.353 +  fdct = (my_fdct_ptr)
  17.354 +    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  17.355 +				SIZEOF(my_fdct_controller));
  17.356 +  cinfo->fdct = (struct jpeg_forward_dct *) fdct;
  17.357 +  fdct->pub.start_pass = start_pass_fdctmgr;
  17.358 +
  17.359 +  switch (cinfo->dct_method) {
  17.360 +#ifdef DCT_ISLOW_SUPPORTED
  17.361 +  case JDCT_ISLOW:
  17.362 +    fdct->pub.forward_DCT = forward_DCT;
  17.363 +    fdct->do_dct = jpeg_fdct_islow;
  17.364 +    break;
  17.365 +#endif
  17.366 +#ifdef DCT_IFAST_SUPPORTED
  17.367 +  case JDCT_IFAST:
  17.368 +    fdct->pub.forward_DCT = forward_DCT;
  17.369 +    fdct->do_dct = jpeg_fdct_ifast;
  17.370 +    break;
  17.371 +#endif
  17.372 +#ifdef DCT_FLOAT_SUPPORTED
  17.373 +  case JDCT_FLOAT:
  17.374 +    fdct->pub.forward_DCT = forward_DCT_float;
  17.375 +    fdct->do_float_dct = jpeg_fdct_float;
  17.376 +    break;
  17.377 +#endif
  17.378 +  default:
  17.379 +    ERREXIT(cinfo, JERR_NOT_COMPILED);
  17.380 +    break;
  17.381 +  }
  17.382 +
  17.383 +  /* Mark divisor tables unallocated */
  17.384 +  for (i = 0; i < NUM_QUANT_TBLS; i++) {
  17.385 +    fdct->divisors[i] = NULL;
  17.386 +#ifdef DCT_FLOAT_SUPPORTED
  17.387 +    fdct->float_divisors[i] = NULL;
  17.388 +#endif
  17.389 +  }
  17.390 +}