Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <bio.h>

#include <draw.h>

#include <memdraw.h>

#define DBG if(0)

#define RGB2K(r,g,b)	((299*((ulong)(r))+587*((ulong)(g))+114*((ulong)(b)))/1000)

/*

 * This program tests the 'memimagedraw' primitive stochastically.

 * It tests the combination aspects of it thoroughly, but since the

 * three images it uses are disjoint, it makes no check of the

 * correct behavior when images overlap.  That is, however, much

 * easier to get right and to test.

 */

void	drawonepixel(Memimage*, Point, Memimage*, Point, Memimage*, Point);

void	verifyone(void);

void	verifyline(void);

void	verifyrect(void);

void	verifyrectrepl(int, int);

void putpixel(Memimage *img, Point pt, ulong nv);

ulong rgbatopix(uchar, uchar, uchar, uchar);

char *dchan, *schan, *mchan;

int dbpp, sbpp, mbpp;

int drawdebug=0;

int	seed;

int	niters = 100;

int	dbpp;	/* bits per pixel in destination */

int	sbpp;	/* bits per pixel in src */

int	mbpp;	/* bits per pixel in mask */

int	dpm;	/* pixel mask at high part of byte, in destination */

int	nbytes;	/* in destination */

int	Xrange	= 64;

int	Yrange	= 8;

Memimage	*dst;

Memimage	*src;

Memimage	*mask;

Memimage	*stmp;

Memimage	*mtmp;

Memimage	*ones;

uchar	*dstbits;

uchar	*srcbits;

uchar	*maskbits;

ulong	*savedstbits;

void

rdb(void)

{

}

int

iprint(char *fmt, ...)

{

	int n;	

	va_list va;

	char buf[1024];

	va_start(va, fmt);

	n = vseprint(buf, buf+sizeof buf, fmt, va) - buf;

	va_end(va);

	write(1,buf,n);

	return 1;

}

void

main(int argc, char *argv[])

{

	memimageinit();

	seed = time(0);

	ARGBEGIN{

	case 'x':

		Xrange = atoi(ARGF());

		break;

	case 'y':

		Yrange = atoi(ARGF());

		break;

	case 'n':

		niters = atoi(ARGF());

		break;

	case 's':

		seed = atoi(ARGF());

		break;

	}ARGEND

	dchan = "r8g8b8";

	schan = "r8g8b8";

	mchan = "r8g8b8";

	switch(argc){

	case 3:	mchan = argv[2];

	case 2:	schan = argv[1];

	case 1:	dchan = argv[0];

	case 0:	break;

	default:	goto Usage;

	Usage:

		fprint(2, "usage: dtest [dchan [schan [mchan]]]\n");

		exits("usage");

	}

//	fmtinstall('b', numbconv);	/* binary! */

	fprint(2, "%s -x %d -y %d -s 0x%x %s %s %s\n", argv0, Xrange, Yrange, seed, dchan, schan, mchan);

	srand(seed);

	dst = allocmemimage(Rect(0, 0, Xrange, Yrange), strtochan(dchan));

	src = allocmemimage(Rect(0, 0, Xrange, Yrange), strtochan(schan));

	mask = allocmemimage(Rect(0, 0, Xrange, Yrange), strtochan(mchan));

	stmp = allocmemimage(Rect(0, 0, Xrange, Yrange), strtochan(schan));

	mtmp = allocmemimage(Rect(0, 0, Xrange, Yrange), strtochan(mchan));

	ones = allocmemimage(Rect(0, 0, Xrange, Yrange), strtochan(mchan));

//	print("chan %lux %lux %lux %lux %lux %lux\n", dst->chan, src->chan, mask->chan, stmp->chan, mtmp->chan, ones->chan);

	if(dst==0 || src==0 || mask==0 || mtmp==0 || ones==0) {

	Alloc:

		fprint(2, "dtest: allocation failed: %r\n");

		exits("alloc");

	}

	nbytes = (4*Xrange+4)*Yrange;

	srcbits = malloc(nbytes);

	dstbits = malloc(nbytes);

	maskbits = malloc(nbytes);

	savedstbits = malloc(nbytes);

	if(dstbits==0 || srcbits==0 || maskbits==0 || savedstbits==0)

		goto Alloc;

	dbpp = dst->depth;

	sbpp = src->depth;

	mbpp = mask->depth;

	dpm = 0xFF ^ (0xFF>>dbpp);

	memset(ones->data->bdata, 0xFF, ones->width*sizeof(ulong)*Yrange);

	fprint(2, "dtest: verify single pixel operation\n");

	verifyone();

	fprint(2, "dtest: verify full line non-replicated\n");

	verifyline();

	fprint(2, "dtest: verify full rectangle non-replicated\n");

	verifyrect();

	fprint(2, "dtest: verify full rectangle source replicated\n");

	verifyrectrepl(1, 0);

	fprint(2, "dtest: verify full rectangle mask replicated\n");

	verifyrectrepl(0, 1);

	fprint(2, "dtest: verify full rectangle source and mask replicated\n");

	verifyrectrepl(1, 1);

	exits(0);

}

/*

 * Dump out an ASCII representation of an image.  The label specifies

 * a list of characters to put at various points in the picture.

 */

static void

Bprintr5g6b5(Biobuf *bio, char*, ulong v)

{

	int r,g,b;

	r = (v>>11)&31;

	g = (v>>5)&63;

	b = v&31;

	Bprint(bio, "%.2x%.2x%.2x", r,g,b);

}

static void

Bprintr5g5b5a1(Biobuf *bio, char*, ulong v)

{

	int r,g,b,a;

	r = (v>>11)&31;

	g = (v>>6)&31;

	b = (v>>1)&31;

	a = v&1;

	Bprint(bio, "%.2x%.2x%.2x%.2x", r,g,b,a);

}

void

dumpimage(char *name, Memimage *img, void *vdata, Point labelpt)

{

	Biobuf b;

	uchar *data;

	uchar *p;

	char *arg;

	void (*fmt)(Biobuf*, char*, ulong);

	int npr, x, y, nb, bpp;

	ulong v, mask;

	Rectangle r;

	fmt = nil;

	arg = nil;

	switch(img->depth){

	case 1:

	case 2:

	case 4:

		fmt = (void(*)(Biobuf*,char*,ulong))Bprint;

		arg = "%.1ux";

		break;

	case 8:

		fmt = (void(*)(Biobuf*,char*,ulong))Bprint;

		arg = "%.2ux";

		break;

	case 16:

		arg = nil;

		if(img->chan == RGB16)

			fmt = Bprintr5g6b5;

		else{

			fmt = (void(*)(Biobuf*,char*,ulong))Bprint;

			arg = "%.4ux";

		}

		break;

	case 24:

		fmt = (void(*)(Biobuf*,char*,ulong))Bprint;

		arg = "%.6lux";

		break;

	case 32:

		fmt = (void(*)(Biobuf*,char*,ulong))Bprint;

		arg = "%.8lux";

		break;

	}

	if(fmt == nil){

		fprint(2, "bad format\n");

		abort();

	}

	r  = img->r;

	Binit(&b, 2, OWRITE);

	data = vdata;

	bpp = img->depth;

	Bprint(&b, "%s\t%d\tr %R clipr %R repl %d data %p *%P\n", name, r.min.x, r, img->clipr, (img->flags&Frepl) ? 1 : 0, vdata, labelpt);

	mask = (1ULL<<bpp)-1;

//	for(y=r.min.y; y<r.max.y; y++){

	for(y=0; y<Yrange; y++){

		nb = 0;

		v = 0;

		p = data+(byteaddr(img, Pt(0,y))-(uchar*)img->data->bdata);

		Bprint(&b, "%-4d\t", y);

//		for(x=r.min.x; x<r.max.x; x++){

		for(x=0; x<Xrange; x++){

			if(x==0)

				Bprint(&b, "\t");

			if(x != 0 && (x%8)==0)

				Bprint(&b, " ");

			npr = 0;

			if(x==labelpt.x && y==labelpt.y){

				Bprint(&b, "*");

				npr++;

			}

			if(npr == 0)

				Bprint(&b, " ");

			while(nb < bpp){

				v &= (1<<nb)-1;

				v |= (ulong)(*p++) << nb;

				nb += 8;

			}

			nb -= bpp;

//			print("bpp %d v %.8lux mask %.8lux nb %d\n", bpp, v, mask, nb);

			fmt(&b, arg, (v>>nb)&mask);

		}

		Bprint(&b, "\n");

	}

	Bterm(&b);

}

/*

 * Verify that the destination pixel has the specified value.

 * The value is in the high bits of v, suitably masked, but must

 * be extracted from the destination Memimage.

 */

void

checkone(Point p, Point sp, Point mp)

{

	int delta;

	uchar *dp, *sdp;

	delta = (uchar*)byteaddr(dst, p)-(uchar*)dst->data->bdata;

	dp = (uchar*)dst->data->bdata+delta;

	sdp = (uchar*)savedstbits+delta;

	if(memcmp(dp, sdp, (dst->depth+7)/8) != 0) {

		fprint(2, "dtest: one bad pixel drawing at dst %P from source %P mask %P\n", p, sp, mp);

		fprint(2, " %.2ux %.2ux %.2ux %.2ux should be %.2ux %.2ux %.2ux %.2ux\n",

			dp[0], dp[1], dp[2], dp[3], sdp[0], sdp[1], sdp[2], sdp[3]);

		fprint(2, "addresses dst %p src %p mask %p\n", dp, byteaddr(src, sp), byteaddr(mask, mp));

		dumpimage("src", src, src->data->bdata, sp);

		dumpimage("mask", mask, mask->data->bdata, mp);

		dumpimage("origdst", dst, dstbits, p);

		dumpimage("dst", dst, dst->data->bdata, p);

		dumpimage("gooddst", dst, savedstbits, p);

		abort();

	}

}

/*

 * Verify that the destination line has the same value as the saved line.

 */

#define RECTPTS(r) (r).min.x, (r).min.y, (r).max.x, (r).max.y

void

checkline(Rectangle r, Point sp, Point mp, int y, Memimage *stmp, Memimage *mtmp)

{

	ulong *dp;

	int nb;

	ulong *saved;

	dp = wordaddr(dst, Pt(0, y));

	saved = savedstbits + y*dst->width;

	if(dst->depth < 8)

		nb = Xrange/(8/dst->depth);

	else

		nb = Xrange*(dst->depth/8);

	if(memcmp(dp, saved, nb) != 0){

		fprint(2, "dtest: bad line at y=%d; saved %p dp %p\n", y, saved, dp);

		fprint(2, "draw dst %R src %P mask %P\n", r, sp, mp);

		dumpimage("src", src, src->data->bdata, sp);

		if(stmp) dumpimage("stmp", stmp, stmp->data->bdata, sp);

		dumpimage("mask", mask, mask->data->bdata, mp);

		if(mtmp) dumpimage("mtmp", mtmp, mtmp->data->bdata, mp);

		dumpimage("origdst", dst, dstbits, r.min);

		dumpimage("dst", dst, dst->data->bdata, r.min);

		dumpimage("gooddst", dst, savedstbits, r.min);

		abort();

	}

}

/*

 * Fill the bits of an image with random data.

 * The Memimage parameter is used only to make sure

 * the data is well formatted: only ucbits is written.

 */

void

fill(Memimage *img, uchar *ucbits)

{

	int i, x, y;

	ushort *up;

	uchar alpha, r, g, b;

	void *data;

	if((img->flags&Falpha) == 0){

		up = (ushort*)ucbits;

		for(i=0; i<nbytes/2; i++)

			*up++ = lrand() >> 7;

		if(i+i != nbytes)

			*(uchar*)up = lrand() >> 7;

	}else{

		data = img->data->bdata;

		img->data->bdata = ucbits;

		for(x=img->r.min.x; x<img->r.max.x; x++)

		for(y=img->r.min.y; y<img->r.max.y; y++){

			alpha = rand() >> 4;

			r = rand()%(alpha+1);

			g = rand()%(alpha+1);

			b = rand()%(alpha+1);

			putpixel(img, Pt(x,y), rgbatopix(r,g,b,alpha));

		}

		img->data->bdata = data;

	}

}

/*

 * Mask is preset; do the rest

 */

void

verifyonemask(void)

{

	Point dp, sp, mp;

	fill(dst, dstbits);

	fill(src, srcbits);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

	memmove(src->data->bdata, srcbits, src->width*sizeof(ulong)*Yrange);

	memmove(mask->data->bdata, maskbits, mask->width*sizeof(ulong)*Yrange);

	dp.x = nrand(Xrange);

	dp.y = nrand(Yrange);

	sp.x = nrand(Xrange);

	sp.y = nrand(Yrange);

	mp.x = nrand(Xrange);

	mp.y = nrand(Yrange);

	drawonepixel(dst, dp, src, sp, mask, mp);

	memmove(mask->data->bdata, maskbits, mask->width*sizeof(ulong)*Yrange);

	memmove(savedstbits, dst->data->bdata, dst->width*sizeof(ulong)*Yrange);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

	memimagedraw(dst, Rect(dp.x, dp.y, dp.x+1, dp.y+1), src, sp, mask, mp, SoverD);

	memmove(mask->data->bdata, maskbits, mask->width*sizeof(ulong)*Yrange);

	checkone(dp, sp, mp);

}

void

verifyone(void)

{

	int i;

	/* mask all zeros */

	memset(maskbits, 0, nbytes);

	for(i=0; i<niters; i++)

		verifyonemask();

	/* mask all ones */

	memset(maskbits, 0xFF, nbytes);

	for(i=0; i<niters; i++)

		verifyonemask();

	/* random mask */

	for(i=0; i<niters; i++){

		fill(mask, maskbits);

		verifyonemask();

	}

}

/*

 * Mask is preset; do the rest

 */

void

verifylinemask(void)

{

	Point sp, mp, tp, up;

	Rectangle dr;

	int x;

	fill(dst, dstbits);

	fill(src, srcbits);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

	memmove(src->data->bdata, srcbits, src->width*sizeof(ulong)*Yrange);

	memmove(mask->data->bdata, maskbits, mask->width*sizeof(ulong)*Yrange);

	dr.min.x = nrand(Xrange-1);

	dr.min.y = nrand(Yrange-1);

	dr.max.x = dr.min.x + 1 + nrand(Xrange-1-dr.min.x);

	dr.max.y = dr.min.y + 1;

	sp.x = nrand(Xrange);

	sp.y = nrand(Yrange);

	mp.x = nrand(Xrange);

	mp.y = nrand(Yrange);

	tp = sp;

	up = mp;

	for(x=dr.min.x; x<dr.max.x && tp.x<Xrange && up.x<Xrange; x++,tp.x++,up.x++)

		memimagedraw(dst, Rect(x, dr.min.y, x+1, dr.min.y+1), src, tp, mask, up, SoverD);

	memmove(savedstbits, dst->data->bdata, dst->width*sizeof(ulong)*Yrange);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

	memimagedraw(dst, dr, src, sp, mask, mp, SoverD);

	checkline(dr, drawrepl(src->r, sp), drawrepl(mask->r, mp), dr.min.y, nil, nil);

}

void

verifyline(void)

{

	int i;

	/* mask all ones */

	memset(maskbits, 0xFF, nbytes);

	for(i=0; i<niters; i++)

		verifylinemask();

	/* mask all zeros */

	memset(maskbits, 0, nbytes);

	for(i=0; i<niters; i++)

		verifylinemask();

	/* random mask */

	for(i=0; i<niters; i++){

		fill(mask, maskbits);

		verifylinemask();

	}

}

/*

 * Mask is preset; do the rest

 */

void

verifyrectmask(void)

{

	Point sp, mp, tp, up;

	Rectangle dr;

	int x, y;

	fill(dst, dstbits);

	fill(src, srcbits);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

	memmove(src->data->bdata, srcbits, src->width*sizeof(ulong)*Yrange);

	memmove(mask->data->bdata, maskbits, mask->width*sizeof(ulong)*Yrange);

	dr.min.x = nrand(Xrange-1);

	dr.min.y = nrand(Yrange-1);

	dr.max.x = dr.min.x + 1 + nrand(Xrange-1-dr.min.x);

	dr.max.y = dr.min.y + 1 + nrand(Yrange-1-dr.min.y);

	sp.x = nrand(Xrange);

	sp.y = nrand(Yrange);

	mp.x = nrand(Xrange);

	mp.y = nrand(Yrange);

	tp = sp;

	up = mp;

	for(y=dr.min.y; y<dr.max.y && tp.y<Yrange && up.y<Yrange; y++,tp.y++,up.y++){

		for(x=dr.min.x; x<dr.max.x && tp.x<Xrange && up.x<Xrange; x++,tp.x++,up.x++)

			memimagedraw(dst, Rect(x, y, x+1, y+1), src, tp, mask, up, SoverD);

		tp.x = sp.x;

		up.x = mp.x;

	}

	memmove(savedstbits, dst->data->bdata, dst->width*sizeof(ulong)*Yrange);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

	memimagedraw(dst, dr, src, sp, mask, mp, SoverD);

	for(y=0; y<Yrange; y++)

		checkline(dr, drawrepl(src->r, sp), drawrepl(mask->r, mp), y, nil, nil);

}

void

verifyrect(void)

{

	int i;

	/* mask all zeros */

	memset(maskbits, 0, nbytes);

	for(i=0; i<niters; i++)

		verifyrectmask();

	/* mask all ones */

	memset(maskbits, 0xFF, nbytes);

	for(i=0; i<niters; i++)

		verifyrectmask();

	/* random mask */

	for(i=0; i<niters; i++){

		fill(mask, maskbits);

		verifyrectmask();

	}

}

Rectangle

randrect(void)

{

	Rectangle r;

	r.min.x = nrand(Xrange-1);

	r.min.y = nrand(Yrange-1);

	r.max.x = r.min.x + 1 + nrand(Xrange-1-r.min.x);

	r.max.y = r.min.y + 1 + nrand(Yrange-1-r.min.y);

	return r;

}

/*

 * Return coordinate corresponding to x withing range [minx, maxx)

 */

int

tilexy(int minx, int maxx, int x)

{

	int sx;

	sx = (x-minx) % (maxx-minx);

	if(sx < 0)

		sx += maxx-minx;

	return sx+minx;

}

void

replicate(Memimage *i, Memimage *tmp)

{

	Rectangle r, r1;

	int x, y, nb;

	/* choose the replication window (i->r) */

	r.min.x = nrand(Xrange-1);

	r.min.y = nrand(Yrange-1);

	/* make it trivial more often than pure chance allows */

	switch(lrand()&0){

	case 1:

		r.max.x = r.min.x + 2;

		r.max.y = r.min.y + 2;

		if(r.max.x < Xrange && r.max.y < Yrange)

			break;

		/* fall through */

	case 0:

		r.max.x = r.min.x + 1;

		r.max.y = r.min.y + 1;

		break;

	default:

		if(r.min.x+3 >= Xrange)

			r.max.x = Xrange;

		else

			r.max.x = r.min.x+3 + nrand(Xrange-(r.min.x+3));

		if(r.min.y+3 >= Yrange)

			r.max.y = Yrange;

		else

			r.max.y = r.min.y+3 + nrand(Yrange-(r.min.y+3));

	}

	assert(r.min.x >= 0);	

	assert(r.max.x <= Xrange);

	assert(r.min.y >= 0);

	assert(r.max.y <= Yrange);

	/* copy from i to tmp so we have just the replicated bits */

	nb = tmp->width*sizeof(ulong)*Yrange;

	memset(tmp->data->bdata, 0, nb);

	memimagedraw(tmp, r, i, r.min, ones, r.min, SoverD);

	memmove(i->data->bdata, tmp->data->bdata, nb);

	/* i is now a non-replicated instance of the replication */

	/* replicate it by hand through tmp */

	memset(tmp->data->bdata, 0, nb);

	x = -(tilexy(r.min.x, r.max.x, 0)-r.min.x);

	for(; x<Xrange; x+=Dx(r)){

		y = -(tilexy(r.min.y, r.max.y, 0)-r.min.y);

		for(; y<Yrange; y+=Dy(r)){

			/* set r1 to instance of tile by translation */

			r1.min.x = x;

			r1.min.y = y;

			r1.max.x = r1.min.x+Dx(r);

			r1.max.y = r1.min.y+Dy(r);

			memimagedraw(tmp, r1, i, r.min, ones, r.min, SoverD);

		}

	}

	i->flags |= Frepl;

	i->r = r;

	i->clipr = randrect();

//	fprint(2, "replicate [[%d %d] [%d %d]] [[%d %d][%d %d]]\n", r.min.x, r.min.y, r.max.x, r.max.y,

//		i->clipr.min.x, i->clipr.min.y, i->clipr.max.x, i->clipr.max.y);

	tmp->clipr = i->clipr;

}

/*

 * Mask is preset; do the rest

 */

void

verifyrectmaskrepl(int srcrepl, int maskrepl)

{

	Point sp, mp, tp, up;

	Rectangle dr;

	int x, y;

	Memimage *s, *m;

//	print("verfrect %d %d\n", srcrepl, maskrepl);

	src->flags &= ~Frepl;

	src->r = Rect(0, 0, Xrange, Yrange);

	src->clipr = src->r;

	stmp->flags &= ~Frepl;

	stmp->r = Rect(0, 0, Xrange, Yrange);

	stmp->clipr = src->r;

	mask->flags &= ~Frepl;

	mask->r = Rect(0, 0, Xrange, Yrange);

	mask->clipr = mask->r;

	mtmp->flags &= ~Frepl;

	mtmp->r = Rect(0, 0, Xrange, Yrange);

	mtmp->clipr = mask->r;

	fill(dst, dstbits);

	fill(src, srcbits);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

	memmove(src->data->bdata, srcbits, src->width*sizeof(ulong)*Yrange);

	memmove(mask->data->bdata, maskbits, mask->width*sizeof(ulong)*Yrange);

	if(srcrepl){

		replicate(src, stmp);

		s = stmp;

	}else

		s = src;

	if(maskrepl){

		replicate(mask, mtmp);

		m = mtmp;

	}else

		m = mask;

	dr = randrect();

	sp.x = nrand(Xrange);

	sp.y = nrand(Yrange);

	mp.x = nrand(Xrange);

	mp.y = nrand(Yrange);

DBG	print("smalldraws\n");

	for(tp.y=sp.y,up.y=mp.y,y=dr.min.y; y<dr.max.y && tp.y<Yrange && up.y<Yrange; y++,tp.y++,up.y++)

		for(tp.x=sp.x,up.x=mp.x,x=dr.min.x; x<dr.max.x && tp.x<Xrange && up.x<Xrange; x++,tp.x++,up.x++)

			memimagedraw(dst, Rect(x, y, x+1, y+1), s, tp, m, up, SoverD);

	memmove(savedstbits, dst->data->bdata, dst->width*sizeof(ulong)*Yrange);

	memmove(dst->data->bdata, dstbits, dst->width*sizeof(ulong)*Yrange);

DBG	print("bigdraw\n");

	memimagedraw(dst, dr, src, sp, mask, mp, SoverD);

	for(y=0; y<Yrange; y++)

		checkline(dr, drawrepl(src->r, sp), drawrepl(mask->r, mp), y, srcrepl?stmp:nil, maskrepl?mtmp:nil);

}

void

verifyrectrepl(int srcrepl, int maskrepl)

{

	int i;

	/* mask all ones */

	memset(maskbits, 0xFF, nbytes);

	for(i=0; i<niters; i++)

		verifyrectmaskrepl(srcrepl, maskrepl);

	/* mask all zeros */

	memset(maskbits, 0, nbytes);

	for(i=0; i<niters; i++)

		verifyrectmaskrepl(srcrepl, maskrepl);

	/* random mask */

	for(i=0; i<niters; i++){

		fill(mask, maskbits);

		verifyrectmaskrepl(srcrepl, maskrepl);

	}

}

/*

 * Trivial draw implementation.

 * Color values are passed around as ulongs containing ααRRGGBB

 */

/*

 * Convert v, which is nhave bits wide, into its nwant bits wide equivalent.

 * Replicates to widen the value, truncates to narrow it.

 */

ulong

replbits(ulong v, int nhave, int nwant)

{

	v &= (1<<nhave)-1;

	for(; nhave<nwant; nhave*=2)

		v |= v<<nhave;

	v >>= (nhave-nwant);

	return v & ((1<<nwant)-1);

}

/*

 * Decode a pixel into the uchar* values.

 */

void

pixtorgba(ulong v, uchar *r, uchar *g, uchar *b, uchar *a)

{

	*a = v>>24;

	*r = v>>16;

	*g = v>>8;

	*b = v;

}

/*

 * Convert uchar channels into ulong pixel.

 */

ulong

rgbatopix(uchar r, uchar g, uchar b, uchar a)

{

	return (a<<24)|(r<<16)|(g<<8)|b;

}

/*

 * Retrieve the pixel value at pt in the image.

 */

ulong

getpixel(Memimage *img, Point pt)

{

	uchar r, g, b, a, *p;

	int nbits, npack, bpp;

	ulong v, c, rbits, bits;

	r = g = b = 0;

	a = ~0;	/* default alpha is full */

	p = byteaddr(img, pt);

	v = p[0]|(p[1]<<8)|(p[2]<<16)|(p[3]<<24);

	bpp = img->depth;

	if(bpp<8){

		/*

		 * Sub-byte greyscale pixels.

		 *

		 * We want to throw away the top pt.x%npack pixels and then use the next bpp bits

		 * in the bottom byte of v.  This madness is due to having big endian bits

		 * but little endian bytes.

		 */

		npack = 8/bpp;

		v >>= 8 - bpp*(pt.x%npack+1);

		v &= (1<<bpp)-1;

		r = g = b = replbits(v, bpp, 8);

	}else{

		/*

		 * General case.  We need to parse the channel descriptor and do what it says.

		 * In all channels but the color map, we replicate to 8 bits because that's the

		 * precision that all calculations are done at.

		 *

		 * In the case of the color map, we leave the bits alone, in case a color map

		 * with less than 8 bits of index is used.  This is currently disallowed, so it's

		 * sort of silly.

		 */

		for(c=img->chan; c; c>>=8){

			nbits = NBITS(c);

			bits = v & ((1<<nbits)-1);

			rbits = replbits(bits, nbits, 8);

			v >>= nbits;

			switch(TYPE(c)){

			case CRed:

				r = rbits;

				break;

			case CGreen:

				g = rbits;

				break;

			case CBlue:

				b = rbits;

				break;

			case CGrey:

				r = g = b = rbits;

				break;

			case CAlpha:

				a = rbits;

				break;

			case CMap:

				p = img->cmap->cmap2rgb + 3*bits;

				r = p[0];

				g = p[1];

				b = p[2];

				break;

			case CIgnore:

				break;

			default:

				fprint(2, "unknown channel type %lud\n", TYPE(c));

				abort();

			}

		}

	}

	return rgbatopix(r, g, b, a);

}

/*

 * Return the greyscale equivalent of a pixel.

 */

uchar

getgrey(Memimage *img, Point pt)

{

	uchar r, g, b, a;

	pixtorgba(getpixel(img, pt), &r, &g, &b, &a);

	return RGB2K(r, g, b);

}

/*

 * Return the value at pt in image, if image is interpreted

 * as a mask.  This means the alpha channel if present, else

 * the greyscale or its computed equivalent.

 */

uchar

getmask(Memimage *img, Point pt)

{

	if(img->flags&Falpha)

		return getpixel(img, pt)>>24;

	else

		return getgrey(img, pt);

}

#undef DBG

#define DBG if(0)

/*

 * Write a pixel to img at point pt.

 *