Imported Upstream version 2.6upstream/2.6upstream

1 files changed, 974 insertions, 0 deletions

diff --git a/dither.c b/dither.c
new file mode 100644
index 0000000..9d1488d
--- /dev/null
+++ b/dither.c
@@ -0,0 +1,974 @@
+/* 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_ENDIAN_H
+#include <endian.h>
+#endif
+#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[65536],green_table[65536],blue_table[65536];
+/* 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 *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 *in, struct bitmap *out, int * dregs);
+
+
+     /* prototypes */
+static void dither_1byte(unsigned short *, struct bitmap *, int *);   /* DITHER_TEMPLATE */
+static void round_1byte(unsigned short *, struct bitmap *);           /* ROUND_TEMPLATE */
+static void dither_2byte(unsigned short *, struct bitmap *, int *);   /* DITHER_TEMPLATE */
+static void round_2byte(unsigned short *, struct bitmap *);           /* ROUND_TEMPLATE */
+static void dither_195(unsigned short *, struct bitmap *, int *);   /* DITHER_TEMPLATE */
+static void round_195(unsigned short *, struct bitmap *);           /* ROUND_TEMPLATE */
+static void dither_451(unsigned short *, struct bitmap *, int *);   /* DITHER_TEMPLATE */
+static void round_451(unsigned short *, struct bitmap *);           /* ROUND_TEMPLATE */
+static void dither_196(unsigned short *, struct bitmap *, int *);   /* DITHER_TEMPLATE */
+static void round_196(unsigned short *, struct bitmap *);           /* ROUND_TEMPLATE */
+static void dither_452(unsigned short *, struct bitmap *, int *);   /* DITHER_TEMPLATE */
+static void round_452(unsigned short *, struct bitmap *);           /* ROUND_TEMPLATE */
+static void dither_708(unsigned short *, struct bitmap *, int *);   /* DITHER_TEMPLATE */
+static void round_708(unsigned short *, struct bitmap *);           /* ROUND_TEMPLATE */
+static long color_332(int);
+static long color_121(int);
+static long color_pass_rgb(int);
+static long color_888_bgr(int);
+/*static void pass_bgr(unsigned short *, struct bitmap *);*/
+static long color_8888_bgr0(int);
+static long color_8888_0bgr(int);
+static long color_8888_0rgb(int);
+/*static void pass_0bgr(unsigned short *, struct bitmap *);*/
+static long color_555be(int);
+static long color_555(int);
+static long color_565be(int);
+static long color_565(int);
+/*static void make_8_table(int *, double);*/
+static void make_16_table(int *, int, int, double , int, int);
+static void make_red_table(int, int, int, int);
+static void make_green_table(int, int, int, int);
+static void make_blue_table(int, int, int, int);
+static void make_round_tables(void);
+
+int slow_fpu = -1;
+
+#define LIN \
+	r+=(int)(in[0]);\
+	g+=(int)(in[1]);\
+	b+=(int)(in[2]);\
+	in+=3;
+
+/* EMPIRE IMAGINE FEAR */
+#define LTABLES \
+	{\
+		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];\
+		gt=green_table[gc];\
+		bt=blue_table[bc];\
+	}\
+	SAVE_CODE\
+	rt=r-(rt&65535);\
+	gt=g-(gt&65535);\
+	bt=b-(bt&65535);\
+
+	
+#define BODY \
+	LIN\
+	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 \
+	LIN\
+	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+=5*rt;\
+	bptr[1]+=5*gt;\
+	bptr[2]+=5*bt;
+
+#define BODYC \
+	LIN\
+	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) \
+	static void template_name(unsigned short *in, struct bitmap *out, int *dregs)\
+		{\
+		int r,g,b,o,rt,gt,bt,y,x;\
+		unsigned char *outp=out->data;\
+		int *bptr;\
+		int 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)\
+	static void template_name(unsigned short *in, struct bitmap *out)\
+	{\
+		int rt,gt,bt,o,x,y;\
+		unsigned char *outp=out->data;\
+		int skip=out->skip-SKIP_CODE;\
+	\
+		o=0;o=o; /*warning go away */\
+		for (y=out->y;y;y--){\
+			for (x=out->x;x;x--){\
+				rt=red_table[in[0]];\
+				gt=green_table[in[1]];\
+				bt=blue_table[in[2]];\
+				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|gt|bt;\
+	*outp++=(o>>16);
+		
+DITHER_TEMPLATE(dither_1byte)
+ROUND_TEMPLATE(round_1byte)
+
+#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;\
+	*(unsigned char *)outp=o;\
+	((unsigned char *)outp)[1]=o>>8;\
+	outp+=2;
+#endif /* #ifdef t2c */
+		
+DITHER_TEMPLATE(dither_2byte)
+ROUND_TEMPLATE(round_2byte)
+#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)
+ROUND_TEMPLATE(round_195)
+#undef SAVE_CODE
+#undef SKIP_CODE
+
+/* R G B */
+#define SKIP_CODE out->x*3;
+#define SAVE_CODE *outp=rt>>16;\
+	outp[1]=gt>>16;\
+	outp[2]=bt>>16;\
+	outp+=3;
+DITHER_TEMPLATE(dither_451)
+ROUND_TEMPLATE(round_451)
+#undef SAVE_CODE
+#undef SKIP_CODE
+
+/* B G R 0 */
+#define SKIP_CODE out->x*4;
+#define SAVE_CODE *outp=bt>>16;\
+	outp[1]=gt>>16;\
+	outp[2]=rt>>16;\
+	outp[3]=0;\
+	outp+=4;
+DITHER_TEMPLATE(dither_196)
+ROUND_TEMPLATE(round_196)
+#undef SAVE_CODE
+#undef SKIP_CODE 
+
+/* 0 B G R */
+#define SKIP_CODE out->x*4;
+#define SAVE_CODE *outp=0;\
+	outp[1]=bt>>16;\
+	outp[2]=gt>>16;\
+	outp[3]=rt>>16;\
+	outp+=4;
+DITHER_TEMPLATE(dither_452)
+ROUND_TEMPLATE(round_452)
+#undef SAVE_CODE
+#undef SKIP_CODE 
+
+/* 0 R G B */
+#define SKIP_CODE out->x*4;
+#define SAVE_CODE *outp=0;\
+	outp[1]=rt>>16;\
+	outp[2]=gt>>16;\
+	outp[3]=bt>>16;\
+	outp+=4;
+DITHER_TEMPLATE(dither_708)
+ROUND_TEMPLATE(round_708)
+#undef SAVE_CODE
+#undef SKIP_CODE 
+
+
+
+/* For 256-color cube */
+static long color_332(int rgb)
+{
+	int r,g,b;
+	long ret;
+
+	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;
+
+	*(char *)&ret=(r<<5)|(g<<2)|b;
+	return ret;
+
+}
+
+static long color_121(int rgb)
+{
+	int r,g,b;
+	long ret;
+
+	r=(rgb>>16)&255;
+	g=(rgb>>8)&255;
+	b=rgb&255;
+	r=(r+127)/255;
+	g=(3*g+127)/255;
+	b=(b+127)/255;
+	*(char *)&ret=(r<<3)|(g<<1)|b;
+	return ret;
+
+}
+
+static long color_pass_rgb(int rgb)
+{
+	long ret;
+
+	*(char *)&ret=rgb>>16;
+	((char *)&ret)[1]=rgb>>8;
+	((char *)&ret)[2]=rgb;
+
+	return ret;
+
+}
+
+static long color_888_bgr(int rgb)
+{
+	long ret;
+
+	((char *)&ret)[0]=rgb;
+	((char *)&ret)[1]=rgb>>8;
+	((char *)&ret)[2]=rgb>>16;
+
+	return ret;
+}
+
+#if 0
+/* Long live the Manchester Modulation! */
+static void pass_bgr(unsigned short *in, struct bitmap *out)
+{
+	int skip=out->skip-3*out->x,y,x;
+	unsigned char *outp=out->data;
+	
+	for (y=out->y;y;y--){
+		for (x=out->x;x;x--){
+			outp[0]=in[2];
+			outp[1]=in[1];
+			outp[2]=in[0];
+			outp+=3;
+			in+=3;
+		}
+		outp+=skip;
+	}
+		
+}
+#endif
+
+static long color_8888_bgr0(int rgb)
+{
+	long ret;
+
+	((char *)&ret)[0]=rgb;
+	((char *)&ret)[1]=rgb>>8;
+	((char *)&ret)[2]=rgb>>16;
+	((char *)&ret)[3]=0;
+
+	return ret;
+}
+
+/* Long live the sigma-delta modulator! */
+static long color_8888_0bgr(int rgb)
+{
+	long ret;
+
+	/* Atmospheric lightwave communication rulez */
+	((char *)&ret)[0]=0;
+	((char *)&ret)[1]=rgb;
+	((char *)&ret)[2]=rgb>>8;
+	((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;
+
+	/* Chokpori Dharamsala Lhasa Laddakh */
+	((char *)&ret)[0]=0;
+	((char *)&ret)[1]=rgb>>16;
+	((char *)&ret)[2]=rgb>>8;
+	((char *)&ret)[3]=rgb;
+
+	return ret;
+}
+
+#if 0
+/* We assume unsgned short holds at least 16 bits. */
+static void pass_0bgr(unsigned short *in, struct bitmap *out)
+{
+	int skip=out->skip-4*out->x,y,x;
+	unsigned char *outp=out->data;
+	
+	for (y=out->y;y;y--){
+		for (x=out->x;x;x--){
+			outp[0]=0;
+			outp[1]=in[2]>>8;
+			outp[2]=in[1]>>8;
+			outp[3]=in[0]>>8;
+			outp+=4;
+			in+=3;
+		}
+		outp+=skip;
+	}
+		
+}
+#endif
+
+/* 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;
+
+	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]=i;
+	return ret;
+}
+
+/* We assume long holds at least 32 bits */
+long color_555(int rgb)
+{
+	int r=(rgb>>16)&255;
+	int g=(rgb>>8)&255;
+	int b=(rgb)&255;
+	int i;
+	long ret;
+
+	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;
+	((unsigned char *)&ret)[1]=i>>8;
+	return ret;
+}
+
+static long color_565be(int rgb)
+{
+	int r,g,b;
+	long ret;
+	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]=i;
+	return ret;
+}
+
+long color_565(int rgb)
+{
+	int r,g,b;
+	long ret;
+	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;
+	((unsigned char *)&ret)[1]=i>>8;
+	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 65:
+			return color_332;
+			break;
+
+		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_pass_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;
+
+		default:
+			return NULL;
+			break;
+
+	}
+}
+
+#if 0
+static void make_8_table(int *table, double gamma)
+{
+	int i,light0;
+	double light;
+	
+	for (i=0;i<256;i++){
+		light=pow((double)i/255,gamma);
+		/* Long live the Nipkow Disk */
+		light0=65535*light;
+		if (light0<0) light0=0;
+		if (light0>65535) light0=65535;
+		table[i]=light0;
+	}
+}
+#endif
+
+/* Gamma says that light=electricity raised to gamma */
+/* dump_t2c means memory organization defined in comment for
+ * red_table on the top of dither.c */
+/* dump_t2c is taken into account only if t2c is defined. */
+static void make_16_table(int *table, int bits, int pos,double gamma, int dump_t2c,
+	int bigendian)
+{
+	int j,light_val,grades=(1<<bits)-1,grade;
+	double voltage;
+	double rev_gamma=1/gamma;
+	const double t=((double)1)/65535;
+	int last_grade, last_content;
+	ttime 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))) {
+					ttime now = get_time();
+					if (!sample_state) {
+						if (now != start_time) start_time = now, sample_state = 1;
+					} else {
+						if ((uttime)now - (uttime)start_time > SLOW_FPU_DETECT_THRESHOLD && ((uttime)now - (uttime)start_time) * 65536 / j > SLOW_FPU_MAX_STARTUP / 3) {
+							x_slow_fpu = 1;
+							goto repeat_loop;
+						}
+					}
+				}
+			}
+		}
+		voltage=pow(j*t,rev_gamma);
+		/* Determine which monitor input voltage is equivalent
+		 * to said photon flux level
+		 */
+
+		grade=voltage*grades+.5;
+		if (grade==last_grade){
+			table[j]=last_content;
+			continue;
+		}
+		last_grade=grade;
+		voltage=(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=pow(voltage,gamma)*65535+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 */
+
+#ifdef t2c_xxx
+/* This branch is broken, but it was never tried */
+		if (dump_t2c){
+			t2c sh;
+			int val=grade<<pos;
+
+			if (bigendian) {
+				((unsigned char *)&sh)[0]=val;
+				((unsigned char *)&sh)[1]=val>>8;
+			}else{
+				((unsigned char *)&sh)[1]=val;
+				((unsigned char *)&sh)[0]=val>>8;
+			}
+			last_content=light_val|(sh<<16U);	
+		}else{
+#endif /* #ifdef t2c */
+			if (bigendian) {
+				int val, val2;
+				val = grade<<pos;
+				val2 = (val>>8) | ((val&0xff)<<8);
+				last_content=light_val|(val2<<16U);
+			}else{
+				last_content=light_val|(grade<<(pos+16U));
+			}
+#ifdef t2c_xxx
+		}
+#endif /* #ifdef t2c */
+		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 bits, int pos, int dump_t2c, int be)
+{
+	make_16_table(red_table,bits,pos,display_red_gamma,dump_t2c, be);
+}
+
+static void make_green_table(int bits, int pos, int dump_t2c, int be)
+{
+	make_16_table(green_table,bits,pos,display_green_gamma,dump_t2c, be);
+}
+
+static void make_blue_table(int bits, int pos,int dump_t2c, int be)
+{
+	make_16_table(blue_table,bits,pos,display_blue_gamma, dump_t2c, 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;
+	unsigned short v;
+
+	for (a=0;a<256;a++){
+		/* a is sRGB coordinate */
+		v=apply_gamma_single_8_to_16(a,user_gamma/sRGB_gamma);
+		round_red_table[a]=red_table[v];
+		round_green_table[a]=green_table[v];
+		round_blue_table[a]=blue_table[v];
+	}
+
+}
+
+/* Also makes up the dithering tables.
+ * You may call it twice - it doesn't leak any memory.
+ */
+void init_dither(int depth)
+{
+	switch(depth){
+		case 33:
+		/* 4bpp, 1Bpp */
+		make_red_table(1,3,0,0);
+		make_green_table(2,1,0,0);
+		make_blue_table(1,0,0,0);
+		dither_fn_internal=dither_1byte;
+		round_fn=round_1byte;
+		break;
+
+		case 65:
+		/* 8 bpp, 1 Bpp */
+		make_red_table(3,5,0,0);
+		make_green_table(3,2,0,0);
+		make_blue_table(2,0,0,0);
+		dither_fn_internal=dither_1byte;
+		round_fn=round_1byte;
+		break;
+
+		case 122:
+		/* 15bpp, 2Bpp */
+		make_red_table(5,10,1,0);
+		make_green_table(5,5,1,0);
+		make_blue_table(5,0,1,0);
+		dither_fn_internal=dither_2byte;
+		round_fn=round_2byte;
+		break;
+
+		case 378:
+		/* 15bpp, 2Bpp, disordered (I have a mental disorder) */
+		make_red_table(5,10,1,1);
+		make_green_table(5,5,1,1);
+		make_blue_table(5,0,1,1);
+		dither_fn_internal=dither_2byte;
+		round_fn=round_2byte;
+		break;
+
+		case 130:
+		/* 16bpp, 2Bpp */
+		make_red_table(5,11,1,0);
+		make_green_table(6,5,1,0);
+		make_blue_table(5,0,1,0);
+		dither_fn_internal=dither_2byte;
+		round_fn=round_2byte;
+		break;
+
+		case 386:
+		/* 16bpp, 2Bpp, disordered */
+		make_red_table(5,11,1,1);
+		make_green_table(6,5,1,1);
+		make_blue_table(5,0,1,1);
+		dither_fn_internal=dither_2byte;
+		round_fn=round_2byte;
+		break;
+
+		case 451:
+		/* 24bpp, 3Bpp, misordered
+		 * Even this is dithered!
+		 * R G B
+		 */
+		make_red_table(8,0,0,0);
+		make_green_table(8,0,0,0);
+		make_blue_table(8,0,0,0);
+		dither_fn_internal=dither_451;
+		round_fn=round_451;
+		break;
+
+		case 195:
+		/* 24bpp, 3Bpp
+		 * Even this is dithered!
+		 * B G R
+		 */
+		make_red_table(8,0,0,0);
+		make_green_table(8,0,0,0);
+		make_blue_table(8,0,0,0);
+		dither_fn_internal=dither_195;
+		round_fn=round_195;
+		break;
+
+		case 452:
+		/* 24bpp, 4Bpp, misordered
+		 * Even this is dithered!
+		 * 0 B G R
+		 */
+		make_red_table(8,0,0,0);
+		make_green_table(8,0,0,0);
+		make_blue_table(8,0,0,0);
+		dither_fn_internal=dither_452;
+		round_fn=round_452;
+		break;
+
+		case 196:
+		/* 24bpp, 4Bpp 
+		 * Even this is dithered!
+		 * B G R 0
+		 */
+		make_red_table(8,0,0,0);
+		make_green_table(8,0,0,0);
+		make_blue_table(8,0,0,0);
+		dither_fn_internal=dither_196;
+		round_fn=round_196;
+		break;
+
+		case 708:
+		/* 24bpp, 4Bpp 
+		 * Even this is dithered!
+		 * 0 R G B
+		 */
+		make_red_table(8,0,0,0);
+		make_green_table(8,0,0,0);
+		make_blue_table(8,0,0,0);
+		dither_fn_internal=dither_708;
+		round_fn=round_708;
+		break;
+
+		default: 
+		internal("Graphics driver returned unsupported \
+pixel memory organisation %d",depth);
+	}
+	make_round_tables();
+}
+
+/* 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 *red, unsigned short *green,
+		unsigned short *blue, int rgb)
+{
+	*red=round_red_table[(rgb>>16)&255];
+	*green=round_green_table[(rgb>>8)&255];
+	*blue=round_blue_table[rgb&255];
+}
+
+#endif