/* dither.c
 * Dithering
 * (c) 2000-2002 Karel 'Clock' Kulhavy
 * This file is a part of the Links program, released under GPL.
 */

#include "cfg.h"

#ifdef G

#include "links.h"

#include "bits.h"

#ifdef HAVE_MATH_H
#include <math.h>
#endif

/* The input of dithering function is 3 times 16-bit value. The value is
 * proportional to light that will go out of the monitor. Only in this space it
 * is possible to dither accurately because distributing the error means maintaining
 * the photon count (blurring caused by human eye from big distance preservers photon
 * count, just spreads the photons a little around)
 * The 8-bit dithering functions are to be used only for dithering text.
 */

/* This source does dithering and rounding of images (in photon space) into
 * struct bitmap. It also computes colors given r,g,b.
 */

/* No dither function destroys the passed bitmap */
/* All dither functions take format in booklike order without inter-line gaps.
 * red, green, blue order. Input bytes=3*y*x. Takes x and y from bitmap.
 */

/* The input of dithering function is 3 times 8-bit value. The value is
 * proportional to desired input into graphics driver (which is in fact
 * proportional to monitor's input voltage for graphic drivers that do not
 * pollute the picture with gamma correction)
 */

/* Dithering algorithm: Floyd-Steinberg error distribution. The used
 * coefficients are depicted in the following table. The empty box denotes the
 * originator pixel that generated the error.
 *
 *                    +----+----+
 *                    |    |7/16|
 *               +----+----+----+
 *               |3/16|5/16|1/16|
 *               +----+----+----+
 */

/* We assume here int holds at least 32 bits */
static int *red_table = DUMMY, *green_table = DUMMY, *blue_table = DUMMY;
static int table_16 = 1;
static unsigned short *
#ifdef __GNUC__
#if __GNUC__ == 3
volatile
#endif
#endif
real_colors_table = NULL;

/* If we want to represent some 16-bit from-screen-light, it would require certain display input
 * value (0-255 red, 0-255 green, 0-255 blue), possibly not a whole number. [red|green|blue]_table
 * translares 16-bit light to the nearest index (that should be fed into the
 * display). Nearest is meant in realm of numbers that are proportional to
 * display input. The table also says what will be the real value this rounded
 * display input yields. index is in
 * bits 16-31, real light value is in bits 0-15. real light value is 0 (no
 * photons) to 65535 (maximum photon flux). This is subtracted from wanted
 * value and error remains which is the distributed into some neighboring
 * pixels.
 *
 * Index memory organization
 * -------------------------
 *	1 byte per pixel: obvious. The output byte is OR of all three LSB's from red_table,
 *		green_table, blue_table
 *	2 bytes per pixel: cast all three values to unsigned  short, OR them together
 *		and dump the short into the memory
 *	3 and 4 bytes per pixel: LSB's contain the red, green, and blue bytes.
 */

/* These tables allow the most precise dithering possible:
 * a) Rouding is performed always to perceptually nearest value, not to
 *    nearest light flux
 * b) error addition is performed in photon space to maintain fiedlity
 * c) photon space addition from b) is performed with 16 bits thus not
 *    degrading 24-bit images
 */

/* We assume here unsigned short holds at least 16 bits */
static unsigned short round_red_table[256];
static unsigned short round_green_table[256];
static unsigned short round_blue_table[256];
/* Transforms sRGB red, green, blue (0-255) to light of nearest voltage to
 * voltage appropriate to given sRGB coordinate.
 */

void (*round_fn)(unsigned short *my_restrict in, struct bitmap *out);
/* When you finish the stuff with dither_start, dither_restart, just do "if (dregs) mem_free(dregs);" */
static void (*dither_fn_internal)(unsigned short *my_restrict in, struct bitmap *out, int *dregs);

int slow_fpu = -1;

/* EMPIRE IMAGINE FEAR */
#define LTABLES \
	ir = in[0];\
	ig = in[1];\
	ib = in[2];\
	r+=(int)ir;\
	g+=(int)ig;\
	b+=(int)ib;\
	in+=3;\
	{\
		int rc=r,gc=g,bc=b;\
		if ((unsigned)rc>65535) rc=rc<0?0:65535;\
		if ((unsigned)gc>65535) gc=gc<0?0:65535;\
		if ((unsigned)bc>65535) bc=bc<0?0:65535;\
		rt=red_table[rc >> shift];\
		gt=green_table[gc >> shift];\
		bt=blue_table[bc >> shift];\
	}\
	SAVE_CODE\
	rt=r-(rt&65535);\
	gt=g-(gt&65535);\
	bt=b-(bt&65535);\


#define BODY \
	LTABLES\
	r=bptr[3];\
	g=bptr[4];\
	b=bptr[5];\
	r+=rt;\
	g+=gt;\
	b+=bt;\
	rt+=8;\
	gt+=8;\
	bt+=8;\
	rt>>=4;\
	gt>>=4;\
	bt>>=4;\
	r-=9*rt;\
	g-=9*gt;\
	b-=9*bt;\
	bptr[3]=rt;\
	bptr[4]=gt;\
	bptr[5]=bt;

#define BODYR \
	LTABLES\
	rt+=8;\
	gt+=8;\
	bt+=8;\
	rt>>=4;\
	gt>>=4;\
	bt>>=4;\
	bptr[-3]+=3*rt;\
	bptr[-2]+=3*gt;\
	bptr[-1]+=3*bt;\
	bptr[0]+=5*rt;\
	bptr[1]+=5*gt;\
	bptr[2]+=5*bt;

#define BODYC \
	LTABLES\
	r=rt;\
	g=gt;\
	b=bt;

#define BODYL \
	bptr=dregs;\
	r=bptr[0];\
	g=bptr[1];\
	b=bptr[2];\
	BODY\
	bptr[0]=5*rt;\
	bptr[1]=5*gt;\
	bptr[2]=5*bt;\
	bptr+=3;

#define BODYI \
	BODY\
	bptr[0]+=5*rt;\
	bptr[1]+=5*gt;\
	bptr[2]+=5*bt;\
	bptr[-3]+=3*rt;\
	bptr[-2]+=3*gt;\
	bptr[-1]+=3*bt;\
	bptr+=3;

#define DITHER_TEMPLATE(template_name, sh) \
	static void template_name(unsigned short *my_restrict in, struct bitmap *out, int *dregs)\
	{\
		const int shift = sh;\
		unsigned short ir, ig, ib;\
		int r,g,b,o,rt,gt,bt,y,x;\
		unsigned char *my_restrict outp=out->data;\
		int *my_restrict bptr;\
		ssize_t skip = out->skip - SKIP_CODE;\
\
		o=0;o=o; /*warning go away */\
		switch(out->x){\
\
			case 0:\
			return;\
\
			case 1:\
			r=g=b=0;\
			for (y=out->y;y;y--){\
				BODYC\
				outp+=skip;\
			}\
			break;\
\
			default:\
			for (y=out->y;y;y--){\
				BODYL\
				for (x=out->x-2;x;x--){\
					BODYI\
				}\
				BODYR\
				outp+=skip;\
			}\
			break;\
		}\
	}

#define ROUND_TEMPLATE(template_name, sh)\
	static void template_name(unsigned short *my_restrict in, struct bitmap *out)\
	{\
		const int shift = sh;\
		unsigned short ir, ig, ib;\
		int rt,gt,bt,o,x,y;\
		unsigned char *my_restrict outp=out->data;\
		ssize_t skip = out->skip - SKIP_CODE;\
\
		o=0;o=o; /*warning go away */\
		for (y=out->y;y;y--){\
			for (x=out->x;x;x--){\
				ir = in[0];\
				ig = in[1];\
				ib = in[2];\
				rt=red_table[limit_16(ir) >> shift];\
				gt=green_table[limit_16(ig) >> shift];\
				bt=blue_table[limit_16(ib) >> shift];\
				in+=3;\
				SAVE_CODE\
			}\
			outp+=skip;\
		}\
	}

/* Expression determining line length in bytes */
#define SKIP_CODE out->x

/* Code with input in rt, gt, bt (values from red_table, green_table, blue_table)
 * that saves appropriate code on *outp (unsigned char *outp). We can use int o;
 * as a scratchpad.
 */
#define SAVE_CODE					\
	o = (rt >> 16) + (gt >> 16) + (bt >> 16);	\
	*outp++ = (unsigned char)o;

DITHER_TEMPLATE(dither_1byte, 0)
ROUND_TEMPLATE(round_1byte, 0)
DITHER_TEMPLATE(dither_1byte_8, 8)
ROUND_TEMPLATE(round_1byte_8, 8)

#undef SKIP_CODE
#undef SAVE_CODE

#define SKIP_CODE out->x
#define SAVE_CODE						\
	{							\
		int rr, gr, br, or;				\
		o = (rt >> 16) + (gt >> 16) + (bt >> 16);	\
		rr = red_table[limit_16(ir) >> shift];		\
		gr = green_table[limit_16(ig) >> shift];	\
		br = blue_table[limit_16(ib) >> shift];		\
		or = (rr >> 16) + (gr >> 16) + (br >> 16);	\
		if (!((real_colors_table[or * 3 + 0] - ir) |	\
		      (real_colors_table[or * 3 + 1] - ig) |	\
		      (real_colors_table[or * 3 + 2] - ib))) {	\
			o = or;					\
		}						\
		rt = real_colors_table[o * 3 + 0];		\
		gt = real_colors_table[o * 3 + 1];		\
		bt = real_colors_table[o * 3 + 2];		\
		*outp++ = (unsigned char)o;			\
	}							\

DITHER_TEMPLATE(dither_1byte_real_colors, 0)
DITHER_TEMPLATE(dither_1byte_real_colors_8, 8)

#undef SKIP_CODE
#undef SAVE_CODE

#define SKIP_CODE out->x*2
#if defined(t2c) && defined(C_LITTLE_ENDIAN)
#define SAVE_CODE \
	o=rt|gt|bt;\
	*(t2c *)outp=(o>>16);\
	outp+=2;
#else
#define SAVE_CODE \
	o=rt|gt|bt;\
	o>>=16;\
	outp[0]=o;\
	outp[1]=o>>8;\
	outp+=2;
#endif /* #ifdef t2c */

DITHER_TEMPLATE(dither_2byte, 0)
ROUND_TEMPLATE(round_2byte, 0)
DITHER_TEMPLATE(dither_2byte_8, 8)
ROUND_TEMPLATE(round_2byte_8, 8)
#undef SAVE_CODE
#undef SKIP_CODE

/* B G R */
#define SKIP_CODE out->x*3
#define SAVE_CODE \
	outp[0]=bt>>16;\
	outp[1]=gt>>16;\
	outp[2]=rt>>16;\
	outp+=3;
DITHER_TEMPLATE(dither_195, 0)
ROUND_TEMPLATE(round_195, 0)
DITHER_TEMPLATE(dither_195_8, 8)
ROUND_TEMPLATE(round_195_8, 8)
#undef SAVE_CODE
#undef SKIP_CODE

/* R G B */
#define SKIP_CODE out->x*3
#define SAVE_CODE \
	outp[0]=rt>>16;\
	outp[1]=gt>>16;\
	outp[2]=bt>>16;\
	outp+=3;
DITHER_TEMPLATE(dither_451, 0)
ROUND_TEMPLATE(round_451, 0)
DITHER_TEMPLATE(dither_451_8, 8)
ROUND_TEMPLATE(round_451_8, 8)
#undef SAVE_CODE
#undef SKIP_CODE

/* B G R 0 */
#define SKIP_CODE out->x*4
#define SAVE_CODE \
	outp[0]=bt>>16;\
	outp[1]=gt>>16;\
	outp[2]=rt>>16;\
	outp[3]=0;\
	outp+=4;
DITHER_TEMPLATE(dither_196, 0)
ROUND_TEMPLATE(round_196, 0)
DITHER_TEMPLATE(dither_196_8, 8)
ROUND_TEMPLATE(round_196_8, 8)
#undef SAVE_CODE
#undef SKIP_CODE

/* 0 B G R */
#define SKIP_CODE out->x*4
#define SAVE_CODE \
	outp[0]=0;\
	outp[1]=bt>>16;\
	outp[2]=gt>>16;\
	outp[3]=rt>>16;\
	outp+=4;
DITHER_TEMPLATE(dither_452, 0)
ROUND_TEMPLATE(round_452, 0)
DITHER_TEMPLATE(dither_452_8, 8)
ROUND_TEMPLATE(round_452_8, 8)
#undef SAVE_CODE
#undef SKIP_CODE

/* 0 R G B */
#define SKIP_CODE out->x*4
#define SAVE_CODE \
	outp[0]=0;\
	outp[1]=rt>>16;\
	outp[2]=gt>>16;\
	outp[3]=bt>>16;\
	outp+=4;
DITHER_TEMPLATE(dither_708, 0)
ROUND_TEMPLATE(round_708, 0)
DITHER_TEMPLATE(dither_708_8, 8)
ROUND_TEMPLATE(round_708_8, 8)
#undef SAVE_CODE
#undef SKIP_CODE



/* For 256-color cube */
static long color_332(int rgb)
{
	int r,g,b;
	long ret = 0;

	r=(rgb>>16)&255;
	g=(rgb>>8)&255;
	b=rgb&255;
	r=(r*7+127)/255;
	g=(g*7+127)/255;
	b=(b*3+127)/255;

	*(unsigned char *)&ret=(r<<5)|(g<<2)|b;
	return ret;

}

/* For 216-color cube */
static long color_666(int rgb)
{
	int r, g, b;
	unsigned char i;
	long ret = 0;

	r = (rgb >> 16) & 255;
	g = (rgb >> 8) & 255;
	b = rgb & 255;

	r = (r * 5 + 127) / 255;
	g = (g * 5 + 127) / 255;
	b = (b * 5 + 127) / 255;

	i = (unsigned char)r;
	i *= 6;
	i += g;
	i *= 6;
	i += b;

	*(unsigned char *)&ret = i;
	return ret;

}

static long color_121(int rgb)
{
	int r, g, b;
	long ret = 0;

	r = (rgb >> 16) & 255;
	g = (rgb >> 8) & 255;
	b = rgb & 255;
	r = (r + 127) / 255;
	g = (3 * g + 127) / 255;
	b = (b + 127) / 255;
	*(unsigned char *)&ret = (r << 3) | (g << 1) | b;
	return ret;

}

static long color_111(int rgb)
{
	int r, g, b;
	long ret = 0;

	r = (rgb >> 16) & 255;
	g = (rgb >> 8) & 255;
	b = rgb & 255;
	r = (r + 127) / 255;
	g = (g + 127) / 255;
	b = (b + 127) / 255;
	*(unsigned char *)&ret = (r << 2) | (g << 1) | b;
	return ret;

}

static long color_888_rgb(int rgb)
{
	long ret = 0;

	((unsigned char *)&ret)[0]=rgb>>16;
	((unsigned char *)&ret)[1]=rgb>>8;
	((unsigned char *)&ret)[2]=(unsigned char)rgb;

	return ret;

}

static long color_888_bgr(int rgb)
{
	long ret = 0;

	((unsigned char *)&ret)[0]=(unsigned char)rgb;
	((unsigned char *)&ret)[1]=rgb>>8;
	((unsigned char *)&ret)[2]=rgb>>16;

	return ret;
}

static long color_8888_bgr0(int rgb)
{
	long ret = 0;

	((unsigned char *)&ret)[0]=(unsigned char)rgb;
	((unsigned char *)&ret)[1]=rgb>>8;
	((unsigned char *)&ret)[2]=rgb>>16;
	((unsigned char *)&ret)[3]=0;

	return ret;
}

/* Long live the sigma-delta modulator! */
static long color_8888_0bgr(int rgb)
{
	long ret = 0;

	/* Atmospheric lightwave communication rulez */
	((unsigned char *)&ret)[0]=0;
	((unsigned char *)&ret)[1]=(unsigned char)rgb;
	((unsigned char *)&ret)[2]=rgb>>8;
	((unsigned char *)&ret)[3]=rgb>>16;

	return ret;
}

/* Long live His Holiness The 14. Dalai Lama Taendzin Gjamccho! */
/* The above line will probably cause a ban of this browser in China under
 * the capital punishment ;-) */
static long color_8888_0rgb(int rgb)
{
	long ret = 0;

	/* Chokpori Dharamsala Lhasa Laddakh */
	((unsigned char *)&ret)[0]=0;
	((unsigned char *)&ret)[1]=rgb>>16;
	((unsigned char *)&ret)[2]=rgb>>8;
	((unsigned char *)&ret)[3]=(unsigned char)rgb;

	return ret;
}

/* We assume long holds at least 32 bits */
static long color_555be(int rgb)
{
	int r=(rgb>>16)&255;
	int g=(rgb>>8)&255;
	int b=(rgb)&255;
	int i;
	long ret = 0;

	r=(r*31+127)/255;
	g=(g*31+127)/255;
	b=(b*31+127)/255;
	i=(r<<10)|(g<<5)|b;
	((unsigned char *)&ret)[0]=i>>8;
	((unsigned char *)&ret)[1]=(unsigned char)i;
	return ret;
}

/* We assume long holds at least 32 bits */
static long color_555(int rgb)
{
	int r=(rgb>>16)&255;
	int g=(rgb>>8)&255;
	int b=(rgb)&255;
	int i;
	long ret = 0;

	r=(r*31+127)/255;
	g=(g*31+127)/255;
	b=(b*31+127)/255;
	i=(r<<10)|(g<<5)|b;
	((unsigned char *)&ret)[0]=(unsigned char)i;
	((unsigned char *)&ret)[1]=i>>8;
	return ret;
}

static long color_565be(int rgb)
{
	int r,g,b;
	long ret = 0;
	int i;

	r=(rgb>>16)&255;
	g=(rgb>>8)&255;
	/* Long live the PIN photodiode */
	b=rgb&255;

	r=(r*31+127)/255;
	g=(g*63+127)/255;
	b=(b*31+127)/255;
	i = (r<<11)|(g<<5)|b;
	((unsigned char *)&ret)[0]=i>>8;
	((unsigned char *)&ret)[1]=(unsigned char)i;
	return ret;
}

static long color_565(int rgb)
{
	int r,g,b;
	long ret = 0;
	int i;

	r=(rgb>>16)&255;
	g=(rgb>>8)&255;
	/* Long live the PIN photodiode */
	b=rgb&255;

	r=(r*31+127)/255;
	g=(g*63+127)/255;
	b=(b*31+127)/255;
	i=(r<<11)|(g<<5)|b;
	((unsigned char *)&ret)[0]=(unsigned char)i;
	((unsigned char *)&ret)[1]=i>>8;
	return ret;
}

static long color_888_bgr_15bit(int rgb)
{
	int r,g,b;
	long ret = 0;

	r=(rgb>>16)&255;
	g=(rgb>>8)&255;
	/* Long live the PIN photodiode */
	b=rgb&255;

	r=(r*31+127)/255;
	g=(g*31+127)/255;
	b=(b*31+127)/255;

	((unsigned char *)&ret)[0]=(unsigned char)(r<<3);
	((unsigned char *)&ret)[1]=(unsigned char)(g<<3);
	((unsigned char *)&ret)[2]=(unsigned char)(b<<3);

	return ret;
}

static long color_888_bgr_16bit(int rgb)
{
	int r,g,b;
	long ret = 0;

	r=(rgb>>16)&255;
	g=(rgb>>8)&255;
	/* Long live the PIN photodiode */
	b=rgb&255;

	r=(r*31+127)/255;
	g=(g*63+127)/255;
	b=(b*31+127)/255;

	((unsigned char *)&ret)[0]=(unsigned char)(r<<3);
	((unsigned char *)&ret)[1]=(unsigned char)(g<<2);
	((unsigned char *)&ret)[2]=(unsigned char)(b<<3);

	return ret;
}



/* rgb = r*65536+g*256+b */
/* The selected color_fn returns a long.
 * When we have for example 2 bytes per pixel, we make them in the memory,
 * then copy them to the beginning of the memory occupied by the long
 * variable, and return that long variable.
 */
long (*get_color_fn(int depth))(int rgb)
{
	switch (depth) {
		case 33:
			return color_121;
			break;

		case 801:
			return color_111;
			break;

		case 65:
			return color_332;
			break;

		case 833:
			return color_666;

		case 122:
			return color_555;
			break;

		case 378:
			return color_555be;
			break;

		case 130:
			return color_565;
			break;

		case 386:
			return color_565be;
			break;

		case 451:
			return color_888_rgb;
			break;

		case 195:
			return color_888_bgr;
			break;

		case 452:
			return color_8888_0bgr;
			break;

		case 196:
			return color_8888_bgr0;
			break;

		case 708:
			return color_8888_0rgb;
			break;

		case 15555:
			return color_888_bgr_15bit;
			break;

		case 16579:
			return color_888_bgr_16bit;
			break;

		default:
			return NULL;
			break;

	}
}

/* Gamma says that light=electricity raised to gamma */
static void make_16_table(int *table, int values, int mult, float_double gamma, int bigendian)
{
	int grades = values - 1;
	int j, light_val, grade;
	float_double voltage;
	float_double rev_gamma = 1 / gamma;
	const float_double inv_65535 = (float_double)(1 / 65535.);
	int last_grade, last_content;
	unsigned val;
	uttime start_time = get_time();
	int sample_state = 0;
	int x_slow_fpu = slow_fpu;

	if (gamma_bits != 2) x_slow_fpu = !gamma_bits;

repeat_loop:
	last_grade = -1;
	last_content = 0;

	for (j=0;j<65536;j++){
		if (x_slow_fpu) {
			if (x_slow_fpu == 1) {
				if (j & 255) {
					table[j] = last_content;
					continue;
				}
			} else {
				if (!(j & (j - 1))) {
					uttime now = get_time();
					if (!sample_state) {
						if (now != start_time) start_time = now, sample_state = 1;
					} else {
						if (now - start_time > SLOW_FPU_DETECT_THRESHOLD && (now - start_time) * 65536 / j > SLOW_FPU_MAX_STARTUP / 3) {
							x_slow_fpu = 1;
							goto repeat_loop;
						}
					}
				}
			}
		}
		voltage=fd_pow(j * inv_65535, rev_gamma);
		/* Determine which monitor input voltage is equivalent
		 * to said photon flux level
		 */

		grade=(int)(voltage * grades + (float_double)0.5);
		if (grade == last_grade){
			table[j] = last_content;
			continue;
		}
		last_grade = grade;
		voltage = (float_double)grade / grades;
		/* Find nearest voltage to this voltage. Finding nearest voltage, not
		 * nearest photon flux ensures the dithered pixels will be perceived to be
		 * near. The voltage input into the monitor was intentionally chosen by
		 * generations of television engineers to roughly comply with eye's
		 * response, thus minimizing and unifying noise impact on transmitted
		 * signal. This is only marginal enhancement however it sounds
		 * kool ;-) (and is kool)
		 */

		light_val = (int)(fd_pow(voltage, gamma) * 65535 + (float_double)0.5);
		/* Find out what photon flux this index represents */

		if (light_val < 0) light_val = 0;
		if (light_val > 65535) light_val = 65535;
		/* Clip photon flux for safety */

		val = grade * mult;
		if (bigendian)
			val = (val >> 8) | ((val & 0xff) << 8);
		last_content = light_val | (val << 16);

		table[j] = last_content;
		/* Save index and photon flux. */
	}
	if (x_slow_fpu == -1) slow_fpu = 0;	/* if loop passed once without
		detecting slow fpu, always assume fast FPU */
	if (gamma_bits == 2 && x_slow_fpu == 1) slow_fpu = 1;
}

static void make_red_table(int values, int mult, int be)
{
	red_table = mem_realloc(red_table, 65536 * sizeof(*red_table));
	make_16_table(red_table, values, mult, (float_double)(display_red_gamma tcc_hack), be);
}

static void make_green_table(int values, int mult, int be)
{
	green_table = mem_realloc(green_table, 65536 * sizeof(*green_table));
	make_16_table(green_table, values, mult, (float_double)(display_green_gamma tcc_hack), be);
}

static void make_blue_table(int values, int mult, int be)
{
	blue_table = mem_realloc(blue_table, 65536 * sizeof(*blue_table));
	make_16_table(blue_table, values, mult, (float_double)(display_blue_gamma tcc_hack), be);
}

void dither(unsigned short *in, struct bitmap *out)
{
	int *dregs;

	if ((unsigned)out->x > MAXINT / 3 / sizeof(*dregs)) overalloc();
	dregs=mem_calloc(out->x*3*sizeof(*dregs));
	(*dither_fn_internal)(in, out, dregs);
	mem_free(dregs);
}

/* For functions that do dithering.
 * Returns allocated dregs. */
int *dither_start(unsigned short *in, struct bitmap *out)
{
	int *dregs;

	if ((unsigned)out->x > MAXINT / 3 / sizeof(*dregs)) overalloc();
	dregs=mem_calloc(out->x*3*sizeof(*dregs));
	(*dither_fn_internal)(in, out, dregs);
	return dregs;
}

void dither_restart(unsigned short *in, struct bitmap *out, int *dregs)
{
	(*dither_fn_internal)(in, out, dregs);
}

static void make_round_tables(void)
{
	int a;
	/* ICC bug */
	icc_volatile unsigned short v;

	for (a = 0; a < 256; a++) {
		/* a is sRGB coordinate */
		v=ags_8_to_16((unsigned char)a, (float)(user_gamma / sRGB_gamma));
		round_red_table[a] = red_table[v >> (8 - 8 * table_16)] & 0xffff;
		round_green_table[a] = green_table[v >> (8 - 8 * table_16)] & 0xffff;
		round_blue_table[a] = blue_table[v >> (8 - 8 * table_16)] & 0xffff;
	}
}

static void compress_tables(void)
{
	int i;
	int *rt, *gt, *bt;
	/*for (i = 0; i < 65536; i++) {
		fprintf(stderr, "16: %03d: %08x %08x %08x\n", i, red_table[i], green_table[i], blue_table[i]);
	}*/
	for (i = 0; i < 65536; i++) {
		if (red_table[i] != red_table[i & 0xff00] ||
		    green_table[i] != green_table[i & 0xff00] ||
		    blue_table[i] != blue_table[i & 0xff00])
			return;
	}
	table_16 = 0;
	rt = mem_alloc(256 * sizeof(*rt));
	gt = mem_alloc(256 * sizeof(*gt));
	bt = mem_alloc(256 * sizeof(*bt));
	for (i = 0; i < 256; i++) {
		rt[i] = red_table[i << 8];
		gt[i] = green_table[i << 8];
		bt[i] = blue_table[i << 8];
		/*fprintf(stderr, "8: %03d: %08x %08x %08x\n", i, rt[i], gt[i], bt[i]);*/
	}
	mem_free(red_table);
	mem_free(green_table);
	mem_free(blue_table);
	red_table = rt;
	green_table = gt;
	blue_table = bt;
}

static void make_real_colors_table(void)
{
	unsigned short *real_colors;
	if (real_colors_table) mem_free(real_colors_table), real_colors_table = NULL;
	if (round_fn != round_1byte && round_fn != round_1byte_8)
		return;
	if (!drv->get_real_colors)
		return;
	real_colors = drv->get_real_colors();
	if (!real_colors)
		return;
	real_colors_table = mem_alloc(256 * 3 * sizeof(unsigned short));
	agx_48_to_48(real_colors_table, real_colors, 256, (float)(display_red_gamma tcc_hack), (float)(display_green_gamma tcc_hack), (float)(display_blue_gamma tcc_hack));
	mem_free(real_colors);
}

/* Also makes up the dithering tables.
 * You may call it twice - it doesn't leak any memory.
 */
void init_dither(int depth)
{
	table_16 = 1;
	switch (depth) {
		case 33:
		/* 4bpp, 1Bpp */
		make_red_table(1 << 1, 1 << 3, 0);
		make_green_table(1 << 2, 1 << 1, 0);
		make_blue_table(1 << 1, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_1byte : dither_1byte_8;
		round_fn = table_16 ? round_1byte : round_1byte_8;
		break;

		case 801:
		/* 8bpp, 1Bpp, 1x1x1 */
		make_red_table(1 << 1, 1 << 2, 0);
		make_green_table(1 << 1, 1 << 1, 0);
		make_blue_table(1 << 1, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_1byte : dither_1byte_8;
		round_fn = table_16 ? round_1byte : round_1byte_8;
		break;

		case 65:
		/* 8 bpp, 1Bpp */
		make_red_table(1 << 3, 1 << 5, 0);
		make_green_table(1 << 3, 1 << 2, 0);
		make_blue_table(1 << 2, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_1byte : dither_1byte_8;
		round_fn = table_16 ? round_1byte : round_1byte_8;
		break;

		case 833:
		/* 8bpp, 1Bpp, 6x6x6 */
		make_red_table(6, 36, 0);
		make_green_table(6, 6, 0);
		make_blue_table(6, 1, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_1byte : dither_1byte_8;
		round_fn = table_16 ? round_1byte : round_1byte_8;
		break;

		case 122:
		/* 15bpp, 2Bpp */
		make_red_table(1 << 5, 1 << 10, 0);
		make_green_table(1 << 5, 1 << 5, 0);
		make_blue_table(1 << 5, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_2byte : dither_2byte_8;
		round_fn = table_16 ? round_2byte : round_2byte_8;
		break;

		case 378:
		/* 15bpp, 2Bpp, disordered (1 << I have a mental disorder) */
		make_red_table(1 << 5, 1 << 10, 1);
		make_green_table(1 << 5, 1 << 5, 1);
		make_blue_table(1 << 5, 1 << 0, 1);
		compress_tables();
		dither_fn_internal = table_16 ? dither_2byte : dither_2byte_8;
		round_fn = table_16 ? round_2byte : round_2byte_8;
		break;

		case 130:
		/* 16bpp, 2Bpp */
		make_red_table(1 << 5, 1 << 11, 0);
		make_green_table(1 << 6, 1 << 5, 0);
		make_blue_table(1 << 5, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_2byte : dither_2byte_8;
		round_fn = table_16 ? round_2byte : round_2byte_8;
		break;

		case 386:
		/* 16bpp, 2Bpp, disordered */
		make_red_table(1 << 5, 1 << 11, 1);
		make_green_table(1 << 6, 1 << 5, 1);
		make_blue_table(1 << 5, 1 << 0, 1);
		compress_tables();
		dither_fn_internal = table_16 ? dither_2byte : dither_2byte_8;
		round_fn = table_16 ? round_2byte : round_2byte_8;
		break;

		case 451:
		/* 24bpp, 3Bpp, misordered
		 * Even this is dithered!
		 * R G B
		 */
		make_red_table(1 << 8, 1 << 0, 0);
		make_green_table(1 << 8, 1 << 0, 0);
		make_blue_table(1 << 8, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_451 : dither_451_8;
		round_fn = table_16 ? round_451 : round_451_8;
		break;

		case 195:
		/* 24bpp, 3Bpp
		 * Even this is dithered!
		 * B G R
		 */
		make_red_table(1 << 8, 1 << 0, 0);
		make_green_table(1 << 8, 1 << 0, 0);
		make_blue_table(1 << 8, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_195 : dither_195_8;
		round_fn = table_16 ? round_195 : round_195_8;
		break;

		case 452:
		/* 24bpp, 4Bpp, misordered
		 * Even this is dithered!
		 * 0 B G R
		 */
		make_red_table(1 << 8, 1 << 0, 0);
		make_green_table(1 << 8, 1 << 0, 0);
		make_blue_table(1 << 8, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_452 : dither_452_8;
		round_fn = table_16 ? round_452 : round_452_8;
		break;

		case 196:
		/* 24bpp, 4Bpp
		 * Even this is dithered!
		 * B G R 0
		 */
		make_red_table(1 << 8, 1 << 0, 0);
		make_green_table(1 << 8, 1 << 0, 0);
		make_blue_table(1 << 8, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_196 : dither_196_8;
		round_fn = table_16 ? round_196 : round_196_8;
		break;

		case 708:
		/* 24bpp, 4Bpp
		 * Even this is dithered!
		 * 0 R G B
		 */
		make_red_table(1 << 8, 1 << 0, 0);
		make_green_table(1 << 8, 1 << 0, 0);
		make_blue_table(1 << 8, 1 << 0, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_708 : dither_708_8;
		round_fn = table_16 ? round_708 : round_708_8;
		break;

		case 15555:
		/* 24bpp, 3Bpp, downsampled to 15bit
		 * B G R
		 */
		make_red_table(1 << 5, 1 << 3, 0);
		make_green_table(1 << 5, 1 << 3, 0);
		make_blue_table(1 << 5, 1 << 3, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_195 : dither_195_8;
		round_fn = table_16 ? round_195 : round_195_8;
		break;

		case 16579:
		/* 24bpp, 3Bpp, downsampled to 16bit
		 * B G R
		 */
		make_red_table(1 << 5, 1 << 3, 0);
		make_green_table(1 << 6, 1 << 2, 0);
		make_blue_table(1 << 5, 1 << 3, 0);
		compress_tables();
		dither_fn_internal = table_16 ? dither_195 : dither_195_8;
		round_fn = table_16 ? round_195 : round_195_8;
		break;

		default:
		internal_error("Graphics driver returned unsupported pixel memory organisation %d",depth);
	}

	make_round_tables();
	make_real_colors_table();

	if (real_colors_table) {
		if (dither_fn_internal == dither_1byte)
			dither_fn_internal = dither_1byte_real_colors;
		if (dither_fn_internal == dither_1byte_8)
			dither_fn_internal = dither_1byte_real_colors_8;
	}

	gamma_cache_rgb_1 = -2;
	gamma_cache_rgb_2 = -2;
	gamma_stamp++;
}

/* Input is in sRGB space (unrounded, i. e. directly from HTML)
 * Output is linear 48-bit value (in photons) that has corresponding
 * voltage nearest to the voltage that would be procduced ideally
 * by the input value. */
void round_color_sRGB_to_48(unsigned short *my_restrict red, unsigned short *my_restrict green,
		unsigned short *my_restrict blue, int rgb)
{
	*red = round_red_table[(rgb >> 16) & 255];
	*green = round_green_table[(rgb >> 8) & 255];
	*blue = round_blue_table[rgb & 255];
	if (real_colors_table) {
		int shift, rt, gt, bt, o;
		shift = 8 - table_16 * 8;
		rt = red_table[*red >> shift];
		gt = green_table[*green >> shift];
		bt = blue_table[*blue >> shift];
		o = (rt >> 16) + (gt >> 16) + (bt >> 16);
		*red = real_colors_table[o * 3 + 0];
		*green = real_colors_table[o * 3 + 1];
		*blue = real_colors_table[o * 3 + 2];
	}
}

void free_dither(void)
{
	if (red_table) mem_free(red_table), red_table = DUMMY;
	if (green_table) mem_free(green_table), green_table = DUMMY;
	if (blue_table) mem_free(blue_table), blue_table = DUMMY;
	if (real_colors_table) mem_free(real_colors_table), real_colors_table = NULL;
}

#endif