plan 9 kernel history: overview | file list | diff list

1993/1116/pc/devvga.c (diff list | history)

1993/0915/sys/src/9/pc/devvga.c:8,49 – 1993/1116/sys/src/9/pc/devvga.c:8,77 (short | long | prev | next)
1992/0527    
1992/0603    
#include	<libg.h> 
#include	<gnot.h>
1992/1119    
#include	"screen.h"
1992/0528    
#include	"vga.h"
1992/0527    
1992/1119    
#define	MINX	8
1993/1116    
enum 
{ 
	EMISCR=		0x3CC,		/* control sync polarity */ 
	EMISCW=		0x3C2, 
	EFCW=		0x3DA,		/* feature control */ 
	EFCR=		0x3CA, 
	GRX=		0x3CE,		/* index to graphics registers */ 
	GR=		0x3CF,		/* graphics registers */ 
	 Grms=		 0x04,		/*  read map select register */ 
	SRX=		0x3C4,		/* index to sequence registers */ 
	SR=		0x3C5,		/* sequence registers */ 
	 Smmask=	 0x02,		/*  map mask */ 
	CRX=		0x3D4,		/* index to crt registers */ 
	CR=		0x3D5,		/* crt registers */ 
	 Cvre=		 0x11,		/*  vertical retrace end */ 
	ARW=		0x3C0,		/* attribute registers (writing) */ 
	ARR=		0x3C1,		/* attribute registers (reading) */ 
	CMRX=		0x3C7,		/* color map read index */ 
	CMWX=		0x3C8,		/* color map write index */ 
	CM=		0x3C9,		/* color map data reg */ 
};
1992/1119    
 
struct{ 
	Point	pos; 
	int	bwid; 
}out; 
                 
/* imported */ 
extern	GSubfont defont0; 
extern	Cursor arrow; 
extern	GBitmap cursorback; 
 
/* exported */ 
GSubfont *defont; 
int islittle = 1;		/* little endian bit ordering in bytes */ 
GBitmap	gscreen; 
 
/* local */ 
static	Lock vgalock;
1993/1116    
/* vga screen */ 
static	Lock	screenlock;
1992/1119    
static	GBitmap	vgascreen; 
static	ulong colormap[256][3]; 
static	int cga = 1;		/* true if in cga mode */
1993/1116    
static	ulong	colormap[256][3]; 
static	Rectangle mbb; 
static	Rectangle NULLMBB = {10000, 10000, -10000, -10000};
1992/1119    
1993/1116    
/* cga screen */ 
static	int	cga = 1;		/* true if in cga mode */ 
 
/* system window */ 
static	int	isscroll; 
static	Rectangle window; 
static	int	h, w; 
static	Point	cursor;
1992/0527    
/*
1992/1119    
 *  screen dimensions
1992/0527    
 */
1993/1116    
#define	MINX	8
1992/1119    
#define MAXX	640 
#define MAXY	480
1993/1116    
#define	CGAWIDTH	160 
#define	CGAHEIGHT	24
1992/0527    
1992/1119    
/* 
 *  'soft' screen bitmap
1993/1116    
 *  screen memory addresses
1992/1119    
 */
1993/1116    
#define SCREENMEM	(0xA0000 | KZERO) 
#define CGASCREEN	((uchar*)(0xB8000 | KZERO))
1992/0527    
1993/1116    
/* 
 *  VGA modes 
 */
1992/1119    
typedef struct VGAmode	VGAmode; 
struct VGAmode 
{
1993/0915/sys/src/9/pc/devvga.c:100,111 – 1993/1116/sys/src/9/pc/devvga.c:128,133
1992/1119    
	0x41, 0x10, 0x0f, 0x00, 0x00, 
}; 
 
static	Rectangle mbb; 
static	Rectangle NULLMBB = {10000, 10000, -10000, -10000};
1992/1216    
static	void nopage(int), tsengpage(int), tridentpage(int), parapage(int);
1993/0915    
static	void atipage(int), cirruspage(int);
1992/1216    
static	void vgaupdate(void);
1992/1119    
                 
/* 
 *  definitions of known cards 
 */
1993/0915/sys/src/9/pc/devvga.c:113,119 – 1993/1116/sys/src/9/pc/devvga.c:135,141
1992/1119    
struct Vgacard 
{ 
	char	*name; 
	void	(*setpage)(int);
1993/1116    
	void	(*setpage)(int);	/* routine to page though display memory */
1992/1119    
}; 
 
enum
1993/0915/sys/src/9/pc/devvga.c:126,131 – 1993/1116/sys/src/9/pc/devvga.c:148,156
1992/1119    
	Generic, 
};
1993/1116    
static void	nopage(int), tsengpage(int), tridentpage(int), parapage(int); 
static void	atipage(int), cirruspage(int);
1993/0106    
Vgacard vgachips[] =
1992/1119    
{
1993/0106    
[Ati]		{ "ati", atipage, },
1993/0915/sys/src/9/pc/devvga.c:139,146 – 1993/1116/sys/src/9/pc/devvga.c:164,192
1992/1119    
 
Vgacard	*vgacard;	/* current vga card */
1993/1116    
/* predefined for the stupid compiler */ 
static void	setscreen(int, int, int); 
static uchar	srin(int); 
static void	genout(int, int); 
static void	srout(int, int); 
static void	grout(int, int); 
static void	arout(int, int); 
static void	crout(int, int); 
static void	setmode(VGAmode*); 
static void	getmode(VGAmode*); 
static void	printmode(VGAmode*); 
static void	cgascreenputc(int); 
static void	cgascreenputs(char*, int); 
static void	screenputc(char*); 
static void	scroll(void); 
static ulong	x3to32(uchar); 
static ulong	x6to32(uchar); 
void	screenupdate(void); 
void	pixreverse(uchar*, int, int); 
void	mbbrect(Rectangle);
1992/1119    
/* 
 *  vga device directory
1993/1116    
 *  vga device
1992/1119    
 */ 
enum 
{
1993/0915/sys/src/9/pc/devvga.c:148,159 – 1993/1116/sys/src/9/pc/devvga.c:194,207
1992/1119    
	Qvgasize=	1, 
	Qvgatype=	2, 
	Qvgaport=	3,
1993/0106    
	Nvga=		3,
1993/1116    
	Qvgaportw=	4, 
	Nvga=		4,
1992/1119    
};
1992/0527    
Dirtab vgadir[]={ 
	"vgasize",	{Qvgasize},	0,		0666,
1992/1119    
	"vgatype",	{Qvgatype},	0,		0666,
1992/0528    
	"vgaport",	{Qvgaport},	0,		0666,
1993/1116    
	"vgaportw",	{Qvgaportw},	0,		0666,
1992/0527    
}; 
 
void
1993/0915/sys/src/9/pc/devvga.c:214,221 – 1993/1116/sys/src/9/pc/devvga.c:262,270
1992/0527    
vgaread(Chan *c, void *buf, long n, ulong offset) 
{
1992/0711    
	int port;
1992/0528    
	uchar *cp = buf;
1993/1116    
	uchar *cp;
1992/1119    
	char cbuf[64];
1993/1116    
	ushort *sp;
1992/0528    
1992/0527    
	switch(c->qid.path&~CHDIR){ 
	case Qdir:
1993/0915/sys/src/9/pc/devvga.c:227,239 – 1993/1116/sys/src/9/pc/devvga.c:276,291
1992/1119    
	case Qvgatype: 
		return readstr(offset, buf, n, vgacard->name);
1992/0528    
	case Qvgaport:
1992/1216    
		/* at the moment, I need freedom for the ATI card - ches
1992/1119    
		if (offset + n >= 0x8000 || offset < 0x300)
1992/0528    
			error(Ebadarg);
1992/1216    
		*/
1992/0604    
		for (port=offset; port<offset+n; port++)
1993/1116    
		for (cp = buf, port=offset; port<offset+n; port++)
1992/0528    
			*cp++ = inb(port); 
		return n;
1993/1116    
	case Qvgaportw: 
		if((n & 01) || (offset & 01)) 
			error(Ebadarg); 
		n /= 2; 
		for (sp = buf, port=offset; port<offset+n; port+=2) 
			*sp++ = ins(port); 
		return n*2;
1992/0527    
	}
1992/1119    
	error(Eperm); 
	return 0;
1993/0915/sys/src/9/pc/devvga.c:245,250 – 1993/1116/sys/src/9/pc/devvga.c:297,303
1992/1119    
	char cbuf[64], *cp; 
	Vgacard *vp; 
	int port, maxx, maxy, ldepth;
1993/1116    
	ushort *sp;
1992/0528    
1992/0527    
	switch(c->qid.path&~CHDIR){ 
	case Qdir:
1993/0915/sys/src/9/pc/devvga.c:294,313 – 1993/1116/sys/src/9/pc/devvga.c:347,365
1992/1119    
		|| maxx > 1280 || maxy > 1024 
		|| ldepth > 3 || ldepth < 0)
1992/0603    
			error(Ebadarg);
1992/1216    
		cursoroff(1);
1992/1119    
		setscreen(maxx, maxy, ldepth);
1992/1216    
		cursoron(1);
1992/0603    
		return n;
1992/0528    
	case Qvgaport:
1992/0603    
		cp = buf;
1992/1217    
		/*
1992/1119    
		if (offset + n >= 0x8000 || offset < 0x300)
1992/0528    
			error(Ebadarg);
1992/1217    
		*/
1992/0603    
		for (port=offset; port<offset+n; port++) {
1993/1116    
		for (cp = buf, port=offset; port<offset+n; port++)
1992/0528    
			outb(port, *cp++);
1992/0603    
		}
1992/0604    
		return n;
1993/1116    
	case Qvgaportw: 
		if((n & 01) || (offset & 01)) 
			error(Ebadarg); 
		n /= 2; 
		for (sp = buf, port=offset; port<offset+n; port+=2) 
			outs(port, *sp++); 
		return n*2;
1992/0527    
	}
1992/1119    
	error(Eperm); 
	return 0;
1993/0915/sys/src/9/pc/devvga.c:327,338 – 1993/1116/sys/src/9/pc/devvga.c:379,725
1992/0527    
	error(Eperm); 
}
1992/1119    
1993/0108    
uchar
1993/1116    
/* 
 *  start the screen in CGA mode.  Create the fonts for VGA. 
 */ 
void 
screeninit(void) 
{ 
	int i; 
	ulong *l; 
 
	/* 
	 *  swizzle the font longs.  we do both byte and bit swizzling 
	 *  since the font is initialized with big endian longs. 
	 */ 
	defont = &defont0; 
	l = defont->bits->base; 
	for(i = defont->bits->width*Dy(defont->bits->r); i > 0; i--, l++) 
		*l = (*l<<24) | ((*l>>8)&0x0000ff00) | ((*l<<8)&0x00ff0000) | (*l>>24); 
	pixreverse((uchar*)defont->bits->base, 
		defont->bits->width*BY2WD*Dy(defont->bits->r), 0); 
 
	/* 
	 *  start in CGA mode 
	 */ 
	cga = 1; 
	crout(0x0a, 0xff);		/* turn off cursor */ 
	memset(CGASCREEN, 0, CGAWIDTH*CGAHEIGHT); 
} 
 
/* 
 *  reconfigure screen shape 
 */ 
static void 
setscreen(int maxx, int maxy, int ldepth) 
{ 
	int len, vgamaxy, width, i, x, s; 
	ulong *p, *oldp; 
 
	if(ldepth == 3) 
		setmode(&mode13); 
	else 
		setmode(&mode12); 
 
	/* allocate a new soft bitmap area */ 
	width = (maxx*(1<<ldepth))/32; 
	len = width * BY2WD * maxy; 
	p = xalloc(len); 
	if(p == 0) 
		error(Enobitstore); 
	memset(p, 0xff, len); 
	mbb = NULLMBB; 
 
	/* 
	 *  zero hard screen and setup a bitmap for the new size 
	 */ 
	if(ldepth == 3) 
		vgascreen.ldepth = 3; 
	else 
		vgascreen.ldepth = 0; 
	vgascreen.width = (maxx*(1<<vgascreen.ldepth))/32; 
	if(maxy > (64*1024)/(vgascreen.width*BY2WD)) 
		vgamaxy = (64*1024)/(vgascreen.width*BY2WD); 
	else 
		vgamaxy = maxy; 
	vgascreen.base = (void*)SCREENMEM; 
	vgascreen.r.min = Pt(0, 0); 
	vgascreen.r.max = Pt(maxx, vgamaxy); 
	vgascreen.clipr = vgascreen.r; 
 
	/* 
	 *  setup new soft screen, free memory for old screen 
	 */ 
	oldp = gscreen.base; 
	s = splhi(); 
	gscreen.ldepth = ldepth; 
	gscreen.width = width; 
	gscreen.r.min = Pt(0, 0); 
	gscreen.r.max = Pt(maxx, maxy); 
	gscreen.clipr = gscreen.r; 
	gscreen.base = p; 
	splx(s); 
	if(oldp) 
		xfree(oldp); 
 
	/* 
	 *  default color map 
	 */ 
	switch(ldepth){ 
	case 3: 
		for(i = 0; i < 256; i++) 
			setcolor(i, x3to32(i>>5), x3to32(i>>2), x3to32(i<<1)); 
		break; 
	case 2: 
	case 1: 
	case 0: 
		gscreen.ldepth = 3; 
		for(i = 0; i < 16; i++){ 
			x = x6to32((i*63)/15); 
			setcolor(i, x, x, x); 
		} 
		gscreen.ldepth = ldepth; 
		break; 
	} 
	cga = 0; 
 
	/* 
	 * display white window 
	 */ 
	mbb = gscreen.r; 
	screenupdate(); 
 
	/* 
	 *  set up inset system window 
	 */ 
	h = defont0.height; 
	w = defont0.info[' '].width; 
 
	window.min = Pt(50, 50); 
	window.max = add(window.min, Pt(10+w*64, 10+h*24)); 
 
	gbitblt(&gscreen, window.min, &gscreen, window, Zero); 
	window = inset(window, 5); 
	cursor = window.min; 
	window.max.y = window.min.y+((window.max.y-window.min.y)/h)*h; 
	hwcurs = 0; 
 
	mbb = gscreen.r; 
	screenupdate(); 
} 
 
/* 
 * paste tile into soft screen. 
 * tile is at location r, first pixel in *data.  tl is length of scan line to insert, 
 * l is amount to advance data after each scan line. 
 */ 
void 
screenload(Rectangle r, uchar *data, int tl, int l) 
{ 
	int y, lpart, rpart, mx, m, mr; 
	uchar *q; 
	extern void cursorlock(Rectangle); 
	extern void cursorunlock(void); 
 
	if(!rectclip(&r, gscreen.r) || tl<=0) 
		return; 
	lock(&screenlock); 
	cursorlock(r); 
	screenupdate(); 
	q = gbaddr(&gscreen, r.min); 
	mx = 7>>gscreen.ldepth; 
	lpart = (r.min.x & mx) << gscreen.ldepth; 
	rpart = (r.max.x & mx) << gscreen.ldepth; 
	m = 0xFF >> lpart; 
	mr = 0xFF ^ (0xFF >> rpart); 
	/* may need to do bit insertion on edges */ 
	if(l == 1){	/* all in one byte */ 
		if(rpart) 
			m ^= 0xFF >> rpart; 
		for(y=r.min.y; y<r.max.y; y++){ 
			*q ^= (*data^*q) & m; 
			q += gscreen.width*sizeof(ulong); 
			data += l; 
		} 
	}else if(lpart==0 && rpart==0){	/* easy case */ 
		for(y=r.min.y; y<r.max.y; y++){ 
			memmove(q, data, tl); 
			q += gscreen.width*sizeof(ulong); 
			data += l; 
		} 
	}else if(rpart==0){ 
		for(y=r.min.y; y<r.max.y; y++){ 
			*q ^= (*data^*q) & m; 
			if(tl > 1) 
				memmove(q+1, data+1, tl-1); 
			q += gscreen.width*sizeof(ulong); 
			data += l; 
		} 
	}else if(lpart == 0){ 
		for(y=r.min.y; y<r.max.y; y++){ 
			if(tl > 1) 
				memmove(q, data, tl-1); 
			q[tl-1] ^= (data[tl-1]^q[tl-1]) & mr; 
			q += gscreen.width*sizeof(ulong); 
			data += l; 
		} 
	}else for(y=r.min.y; y<r.max.y; y++){ 
			*q ^= (*data^*q) & m; 
			if(l > 2) 
				memmove(q+1, data+1, tl-2); 
			q[tl-1] ^= (data[tl-1]^q[l-1]) & mr; 
			q += gscreen.width*sizeof(ulong); 
			data += l; 
		} 
	mbbrect(r); 
	screenupdate(); 
	cursorunlock(); 
	screenupdate(); 
	unlock(&screenlock); 
} 
 
/* 
 *  copy litte endian soft screen to big endian hard screen 
 */ 
void 
screenupdate(void) 
{ 
	uchar *sp, *hp, *edisp; 
	int y, len, incs, inch, off, page; 
	Rectangle r; 
	void* (*f)(void*, void*, long); 
 
	r = mbb; 
	mbb = NULLMBB; 
 
	if(Dy(r) < 0) 
		return; 
 
	if(r.min.x < 0) 
		r.min.x = 0; 
	if(r.min.y < 0) 
		r.min.y = 0; 
	if(r.max.x > gscreen.r.max.x) 
		r.max.x = gscreen.r.max.x; 
	if(r.max.y > gscreen.r.max.y) 
		r.max.y = gscreen.r.max.y; 
 
	incs = gscreen.width * BY2WD; 
	inch = vgascreen.width * BY2WD; 
 
	switch(gscreen.ldepth){ 
	case 0: 
		r.min.x &= ~15;		/* 16 pixel allignment for l0update() */ 
		f = l0update; 
		len = (r.max.x + 7)/8 - r.min.x/8; 
		if(len & 1) 
			len++;		/* 16 bit allignment for l0update() */ 
		break; 
	case 1: 
		r.min.x &= ~15;		/* 8 pixel allignment for l1update() */ 
		f = l1update; 
		len = (r.max.x + 7)/8 - r.min.x/8; 
		if(len & 1) 
			len++;		/* 8 pixel allignment for l1update() */ 
		break; 
	case 2: 
		r.min.x &= ~7;		/* 8 pixel allignment for l2update() */ 
		f = l2update; 
		len = (r.max.x + 7)/8 - r.min.x/8; 
		break; 
	case 3: 
		f = memmove; 
		len = r.max.x - r.min.x; 
		break; 
	default: 
		return; 
	} 
	if(len < 1) 
		return; 
 
	off = r.min.y * vgascreen.width * BY2WD + (r.min.x>>(3 - vgascreen.ldepth)); 
	page = off>>16; 
	off &= (1<<16)-1; 
	hp = ((uchar*)vgascreen.base) + off; 
	off = r.min.y * gscreen.width * BY2WD 
		+ (r.min.x>>(3 - gscreen.ldepth)); 
	sp = ((uchar*)gscreen.base) + off; 
 
	edisp = ((uchar*)vgascreen.base) + 64*1024; 
	vgacard->setpage(page); 
	for(y = r.min.y; y < r.max.y; y++){ 
		if(hp + inch < edisp){ 
			f(hp, sp, len); 
			sp += incs; 
			hp += inch; 
		} else { 
			off = edisp - hp; 
			if(off <= len){ 
				if(off > 0) 
					f(hp, sp, off); 
				vgacard->setpage(++page); 
				if(len - off > 0) 
					f(vgascreen.base, sp+off, len - off); 
			} else { 
				f(hp, sp, len); 
				vgacard->setpage(++page); 
			} 
			sp += incs; 
			hp += inch - 64*1024; 
		} 
	} 
} 
 
void 
screenputs(char *s, int n) 
{ 
	int i; 
	Rune r; 
	char buf[4]; 
 
	if(cga) { 
		cgascreenputs(s, n); 
		return; 
	} 
 
	if((getstatus() & IFLAG) == 0) { 
		/* don't deadlock trying to print in interrupt */ 
		if(!canlock(&screenlock)) 
			return;	 
	} else 
		lock(&screenlock); 
 
	while(n > 0) { 
		i = chartorune(&r, s); 
		if(i == 0){ 
			s++; 
			--n; 
			continue; 
		} 
		memmove(buf, s, i); 
		buf[i] = 0; 
		n -= i; 
		s += i; 
		screenputc(buf); 
	} 
	if(isscroll) { 
		mbb = window; 
		isscroll = 0; 
	} 
 
	screenupdate(); 
	unlock(&screenlock); 
} 
 
/* 
 *  accessing registers 
 */ 
static uchar
1993/0108    
srin(int i) { 
	outb(SRX, i); 
	return inb(SR); 
}
1992/1119    
void
1993/1116    
static void
1992/1119    
genout(int reg, int val) 
{ 
	if(reg == 0)
1993/0915/sys/src/9/pc/devvga.c:340,358 – 1993/1116/sys/src/9/pc/devvga.c:727,745
1992/1119    
	else if (reg == 1) 
		outb(EFCW, val); 
} 
void
1993/1116    
static void
1992/1119    
srout(int reg, int val) 
{ 
	outb(SRX, reg); 
	outb(SR, val); 
} 
void
1993/1116    
static void
1992/1119    
grout(int reg, int val) 
{ 
	outb(GRX, reg); 
	outb(GR, val); 
} 
void
1993/1116    
static void
1992/1119    
arout(int reg, int val) 
{ 
	inb(0x3DA);
1993/0915/sys/src/9/pc/devvga.c:366,373 – 1993/1116/sys/src/9/pc/devvga.c:753,759
1992/1119    
		outb(ARW, val); 
	} 
} 
                 
void
1993/1116    
static void
1992/1119    
crout(int reg, int val) 
{ 
	outb(CRX, reg);
1993/0915/sys/src/9/pc/devvga.c:374,380 – 1993/1116/sys/src/9/pc/devvga.c:760,766
1992/1119    
	outb(CR, val); 
} 
 
void
1993/1116    
static void
1992/1119    
setmode(VGAmode *v) 
{ 
	int i;
1993/0915/sys/src/9/pc/devvga.c:405,412 – 1993/1116/sys/src/9/pc/devvga.c:791,799
1992/1119    
	srout(1, v->sequencer[1]); 
} 
 
void 
getmode(VGAmode *v) {
1993/1116    
static void 
getmode(VGAmode *v) 
{
1992/1119    
	int i; 
	v->general[0] = inb(0x3cc); 
	v->general[1] = inb(0x3ca);
1993/0915/sys/src/9/pc/devvga.c:429,436 – 1993/1116/sys/src/9/pc/devvga.c:816,824
1992/1119    
	} 
} 
 
void 
printmode(VGAmode *v) {
1993/1116    
static void 
printmode(VGAmode *v) 
{
1992/1119    
	int i; 
	print("g %2.2x %2x\n", 
		v->general[0], v->general[1]);
1993/0915/sys/src/9/pc/devvga.c:480,604 – 1993/1116/sys/src/9/pc/devvga.c:868,886
1992/1119    
	return y; 
}
1993/1116    
/* 
 *  just in case we have one 
 */
1992/1119    
void 
setscreen(int maxx, int maxy, int ldepth)
1993/1116    
hwcursset(ulong *s, ulong *c, int ox, int oy)
1992/1119    
{
1993/0102    
	int len, vgamaxy, width, i, x, s;
1993/0103    
	ulong *p, *oldp;
1992/1119    
                 
	if(ldepth == 3) 
		setmode(&mode13); 
	else 
		setmode(&mode12); 
                 
	/* allocate a new soft bitmap area */ 
	width = (maxx*(1<<ldepth))/32; 
	len = width * BY2WD * maxy; 
	p = xalloc(len); 
	if(p == 0)
1993/0102    
		error(Enobitstore);
1993/0115    
	memset(p, 0xff, len);
1992/1119    
	mbb = NULLMBB; 
                 
	/* 
	 *  zero hard screen and setup a bitmap for the new size 
	 */ 
	if(ldepth == 3) 
		vgascreen.ldepth = 3; 
	else 
		vgascreen.ldepth = 0; 
	vgascreen.width = (maxx*(1<<vgascreen.ldepth))/32; 
	if(maxy > (64*1024)/(vgascreen.width*BY2WD)) 
		vgamaxy = (64*1024)/(vgascreen.width*BY2WD); 
	else 
		vgamaxy = maxy; 
	vgascreen.base = (void*)SCREENMEM; 
	vgascreen.r.min = Pt(0, 0); 
	vgascreen.r.max = Pt(maxx, vgamaxy); 
	vgascreen.clipr = vgascreen.r; 
                 
	/* 
	 *  setup new soft screen, free memory for old screen 
	 */
1993/0102    
	oldp = gscreen.base; 
	s = splhi();
1992/1119    
	gscreen.ldepth = ldepth; 
	gscreen.width = width; 
	gscreen.r.min = Pt(0, 0); 
	gscreen.r.max = Pt(maxx, maxy); 
	gscreen.clipr = gscreen.r;
1993/0103    
	gscreen.base = p;
1993/0102    
	splx(s); 
	if(oldp) 
		xfree(oldp);
1992/1119    
                 
	/* 
	 *  set depth of cursor backup area 
	 */ 
	bitdepth(); 
                 
	/* 
	 *  set string pointer to upper left 
	 */ 
	out.pos.x = MINX; 
	out.pos.y = 0; 
	out.bwid = defont0.info[' '].width; 
                 
	/* 
	 *  default color map 
	 */ 
	switch(ldepth){ 
	case 3: 
		for(i = 0; i < 256; i++) 
			setcolor(i, x3to32(i>>5), x3to32(i>>2), x3to32(i<<1)); 
		break; 
	case 2: 
	case 1: 
	case 0: 
		gscreen.ldepth = 3; 
		for(i = 0; i < 16; i++){ 
			x = x6to32((i*63)/15); 
			setcolor(i, x, x, x); 
		} 
		gscreen.ldepth = ldepth; 
		break; 
	}
1993/0409    
	bbinit();
1992/1119    
	cga = 0;
1992/1216    
                 
	/* 
	 * clear screen 
	 */ 
	mbb = gscreen.r; 
	vgaupdate();
1993/1116    
	USED(s, c, ox, oy);
1992/1119    
} 
 
void 
screeninit(void)
1993/1116    
hwcursmove(int x, int y)
1992/1119    
{ 
	int i; 
	ulong *l; 
                 
	/* 
	 *  arrow is defined as a big endian 
	 */ 
	pixreverse(arrow.set, 2*16, 0); 
	pixreverse(arrow.clr, 2*16, 0); 
                 
	/* 
	 *  swizzle the font longs.  we do both byte and bit swizzling 
	 *  since the font is initialized with big endian longs. 
	 */ 
	defont = &defont0; 
	l = defont->bits->base; 
	for(i = defont->bits->width*Dy(defont->bits->r); i > 0; i--, l++) 
		*l = (*l<<24) | ((*l>>8)&0x0000ff00) | ((*l<<8)&0x00ff0000) | (*l>>24); 
	pixreverse((uchar*)defont->bits->base, 
		defont->bits->width*BY2WD*Dy(defont->bits->r), 0); 
                 
	cga = 1; 
	crout(0x0a, 0xff);		/* turn off cursor */ 
	memset(CGASCREEN, 0, CGAWIDTH*CGAHEIGHT);
1993/1116    
	USED(x, y);
1992/1119    
} 
 
/*
1993/0915/sys/src/9/pc/devvga.c:615,621 – 1993/1116/sys/src/9/pc/devvga.c:897,902
1992/1119    
		mbb.max.x = r.max.x; 
	if (r.max.y > mbb.max.y) 
		mbb.max.y = r.max.y;
1992/1209    
	mousescreenupdate();
1992/1119    
} 
 
void
1993/0915/sys/src/9/pc/devvga.c:639,647 – 1993/1116/sys/src/9/pc/devvga.c:920,932
1992/1119    
{ 
	USED(page);
1992/1216    
}
1993/1116    
1993/0106    
/* 
 * The following code is unproven: we haven't got the 
 * ATI stuff to work yet.
1993/1116    
 * Extended registers can be read with inb(), but must be 
 * written with outs(). The index must be written each time 
 * before the register is accessed. 
 * The page bits are spread across registers 0xAE and 0xB2. 
 * This can go away when we use the memory aperture.
1993/0106    
 */
1992/1216    
static void
1993/0106    
atipage(int page)
1993/0915/sys/src/9/pc/devvga.c:650,660 – 1993/1116/sys/src/9/pc/devvga.c:935,949
1993/0106    
	ushort extreg = *((ushort *)0x800C0010); 
	uchar v; 
 
	outb(extreg, 0xb2); 
	v = (inb(extreg+1) & 0xe1) | (page<<1); 
	outb(extreg, 0xb2); 
	outb(extreg+1, v);
1993/1116    
	outb(extreg, 0xAE); 
	v = (inb(extreg+1) & 0xFC)|((page>>4) & 0x03); 
	outs(extreg, (v<<8)|0xAE); 
 
	outb(extreg, 0xB2); 
	v = (inb(extreg+1) & 0xE1)|((page & 0x0F)<<1); 
	outs(extreg, (v<<8)|0xB2);
1993/0106    
}
1993/1116    
1993/0206    
/* 
 * The following assumes that the new mode registers have been selected. 
 */
1993/0915/sys/src/9/pc/devvga.c:679,793 – 1993/1116/sys/src/9/pc/devvga.c:968,983
1993/0915    
	grout(0x9, page<<4);
1992/1119    
} 
 
/* 
 *  copy litte endian soft screen to big endian hard screen 
 */ 
static void 
vgaupdate(void)
1993/1116    
void 
mousescreenupdate(void)
1992/1119    
{ 
	uchar *sp, *hp, *edisp; 
	int y, len, incs, inch, off, page; 
	Rectangle r; 
	void* (*f)(void*, void*, long); 
                 
	r = mbb; 
	mbb = NULLMBB; 
                 
	if(Dy(r) < 0)
1993/1116    
	if(canlock(&screenlock) == 0)
1992/1119    
		return; 
 
	if(r.min.x < 0) 
		r.min.x = 0; 
	if(r.min.y < 0) 
		r.min.y = 0; 
	if(r.max.x > gscreen.r.max.x) 
		r.max.x = gscreen.r.max.x; 
	if(r.max.y > gscreen.r.max.y) 
		r.max.y = gscreen.r.max.y; 
                 
	incs = gscreen.width * BY2WD; 
	inch = vgascreen.width * BY2WD; 
                 
	switch(gscreen.ldepth){ 
	case 0:
1992/1121    
		r.min.x &= ~15;		/* 16 pixel allignment for l0update() */
1992/1119    
		f = l0update; 
		len = (r.max.x + 7)/8 - r.min.x/8; 
		if(len & 1) 
			len++;		/* 16 bit allignment for l0update() */ 
		break; 
	case 1:
1992/1121    
		r.min.x &= ~15;		/* 8 pixel allignment for l1update() */
1992/1119    
		f = l1update; 
		len = (r.max.x + 7)/8 - r.min.x/8; 
		if(len & 1)
1992/1121    
			len++;		/* 8 pixel allignment for l1update() */
1992/1119    
		break; 
	case 2:
1992/1121    
		r.min.x &= ~7;		/* 8 pixel allignment for l2update() */
1992/1119    
		f = l2update; 
		len = (r.max.x + 7)/8 - r.min.x/8; 
		break; 
	case 3: 
		f = memmove; 
		len = r.max.x - r.min.x; 
		break; 
	default: 
		return; 
	} 
	if(len < 1) 
		return; 
                 
	off = r.min.y * vgascreen.width * BY2WD + (r.min.x>>(3 - vgascreen.ldepth)); 
	page = off>>16; 
	off &= (1<<16)-1; 
	hp = ((uchar*)vgascreen.base) + off;
1992/1121    
	off = r.min.y * gscreen.width * BY2WD 
		+ (r.min.x>>(3 - gscreen.ldepth));
1992/1119    
	sp = ((uchar*)gscreen.base) + off; 
                 
	edisp = ((uchar*)vgascreen.base) + 64*1024; 
	vgacard->setpage(page); 
	for(y = r.min.y; y < r.max.y; y++){ 
		if(hp + inch < edisp){ 
			f(hp, sp, len); 
			sp += incs; 
			hp += inch; 
		} else { 
			off = edisp - hp; 
			if(off <= len){ 
				if(off > 0) 
					f(hp, sp, off); 
				vgacard->setpage(++page); 
				if(len - off > 0) 
					f(vgascreen.base, sp+off, len - off); 
			} else { 
				f(hp, sp, len); 
				vgacard->setpage(++page); 
			} 
			sp += incs; 
			hp += inch - 64*1024; 
		} 
	}
1993/1116    
	screenupdate(); 
	unlock(&screenlock);
1992/1119    
} 
 
void 
screenupdate(void) 
{ 
	lock(&vgalock); 
	vgaupdate(); 
	unlock(&vgalock); 
} 
                 
void 
mousescreenupdate(void) 
{ 
	if(canlock(&vgalock)){ 
		vgaupdate(); 
		unlock(&vgalock); 
	} 
} 
                 
static void 
cgascreenputc(int c) 
{
1993/0915/sys/src/9/pc/devvga.c:818,824 – 1993/1116/sys/src/9/pc/devvga.c:1008,1014
1992/1119    
	} 
} 
 
void
1993/1116    
static void
1992/1119    
cgascreenputs(char *s, int n) 
{ 
	while(n-- > 0)
1993/0915/sys/src/9/pc/devvga.c:825,895 – 1993/1116/sys/src/9/pc/devvga.c:1015,1067
1992/1119    
		cgascreenputc(*s++); 
} 
 
void 
screenputnl(void)
1993/1116    
static void 
scroll(void)
1992/1119    
{
1993/1116    
	int o;
1992/1119    
	Rectangle r; 
 
	out.pos.x = MINX; 
	out.pos.y += defont0.height; 
	if(out.pos.y > gscreen.r.max.y-defont0.height){ 
		vgaupdate(); 
		out.pos.y = gscreen.r.min.y; 
	} 
	r = Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height); 
	gbitblt(&gscreen, r.min, &gscreen, r, flipD[0]); 
	mbbrect(r); 
	vgaupdate();
1993/1116    
	o = 5*h; 
	r = Rpt(Pt(window.min.x, window.min.y+o), window.max); 
	gbitblt(&gscreen, window.min, &gscreen, r, S); 
	r = Rpt(Pt(window.min.x, window.max.y-o), window.max); 
	gbitblt(&gscreen, r.min, &gscreen, r, Zero); 
	cursor.y -= o; 
	isscroll = 1;
1992/1119    
} 
 
void 
screenputs(char *s, int n)
1993/1116    
static void 
screenputc(char *buf)
1992/1119    
{ 
	Rune r; 
	int i; 
	char buf[4]; 
	Rectangle rect;
1993/1116    
	int pos;
1992/1119    
 
	if(cga) { 
		cgascreenputs(s, n); 
		return; 
	}
1993/1116    
	mbbpt(cursor); 
	switch(buf[0]) { 
	case '\n': 
		if(cursor.y+h >= window.max.y) 
			scroll(); 
		cursor.y += h; 
		screenputc("\r"); 
		break; 
	case '\r': 
		cursor.x = window.min.x; 
		break; 
	case '\t': 
		pos = (cursor.x-window.min.x)/w; 
		pos = 8-(pos%8); 
		cursor.x += pos*w; 
		break; 
	case '\b': 
		if(cursor.x-w >= window.min.x) 
			cursor.x -= w; 
		break; 
	default: 
		if(cursor.x >= window.max.x-w) 
			screenputc("\n");
1992/1119    
 
	while(n > 0){ 
		i = chartorune(&r, s); 
		if(i == 0){ 
			s++; 
			--n; 
			continue; 
		} 
		memmove(buf, s, i); 
		buf[i] = 0; 
		n -= i; 
		s += i; 
		if(r == '\n') 
			screenputnl(); 
		else if(r == '\t'){ 
			out.pos.x += (8-((out.pos.x-MINX)/out.bwid&7))*out.bwid; 
			if(out.pos.x >= gscreen.r.max.x) 
				screenputnl(); 
		}else if(r == '\b'){ 
			if(out.pos.x >= out.bwid+MINX){ 
				out.pos.x -= out.bwid; 
				gsubfstring(&gscreen, out.pos, defont, " ", flipD[S]); 
			} 
			rect.min = Pt(out.pos.x, out.pos.y); 
			rect.max = Pt(out.pos.x+out.bwid, out.pos.y+defont0.height); 
			mbbrect(rect); 
		}else{ 
			if(out.pos.x >= gscreen.r.max.x-out.bwid) 
				screenputnl(); 
			rect.min = Pt(out.pos.x, out.pos.y); 
			rect.max = Pt(out.pos.x+out.bwid, out.pos.y+defont0.height); 
			out.pos = gsubfstring(&gscreen, out.pos, defont, buf, flipD[S]); 
			mbbrect(rect); 
		}
1993/1116    
		cursor = gsubfstring(&gscreen, cursor, &defont0, buf, S);
1992/1119    
	} 
	vgaupdate();
1993/1116    
	mbbpt(Pt(cursor.x, cursor.y+h));
1992/1119    
} 
 
int
1993/0915/sys/src/9/pc/devvga.c:902,912 – 1993/1116/sys/src/9/pc/devvga.c:1074,1084
1992/1119    
getcolor(ulong p, ulong *pr, ulong *pg, ulong *pb) 
{ 
	p &= (1<<(1<<gscreen.ldepth))-1; 
	lock(&vgalock);
1993/1116    
	lock(&screenlock);
1992/1119    
	*pr = colormap[p][0]; 
	*pg = colormap[p][1]; 
	*pb = colormap[p][2]; 
	unlock(&vgalock);
1993/1116    
	unlock(&screenlock);
1992/1119    
} 
 
int
1993/0915/sys/src/9/pc/devvga.c:913,919 – 1993/1116/sys/src/9/pc/devvga.c:1085,1091
1992/1119    
setcolor(ulong p, ulong r, ulong g, ulong b) 
{ 
	p &= (1<<(1<<gscreen.ldepth))-1; 
	lock(&vgalock);
1993/1116    
	lock(&screenlock);
1992/1119    
	colormap[p][0] = r; 
	colormap[p][1] = g; 
	colormap[p][2] = b;
1993/0915/sys/src/9/pc/devvga.c:921,970 – 1993/1116/sys/src/9/pc/devvga.c:1093,1103
1992/1119    
	outb(CM, r>>(32-6)); 
	outb(CM, g>>(32-6)); 
	outb(CM, b>>(32-6)); 
	unlock(&vgalock);
1993/1116    
	unlock(&screenlock);
1992/1119    
	return ~0; 
}
1993/0915    
void 
hwcursset(ulong *s, ulong *c, int ox, int oy)
1992/1119    
{ 
	USED(s, c, ox, oy); 
} 
                 
1993/0915    
void
1992/1119    
hwcursmove(int x, int y) 
{ 
	USED(x, y); 
} 
                 
/* 
 *  a fatter than usual cursor for the safari 
 */ 
Cursor fatarrow = { 
	{ -1, -1 }, 
	{ 
		0xff, 0xff, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0c,  
		0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04,  
		0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8c, 0x04,  
		0x92, 0x08, 0x91, 0x10, 0xa0, 0xa0, 0xc0, 0x40,  
	}, 
	{ 
		0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfc, 0x7f, 0xf0,  
		0x7f, 0xe0, 0x7f, 0xe0, 0x7f, 0xf0, 0x7f, 0xf8,  
		0x7f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfc, 0x73, 0xf8,  
		0x61, 0xf0, 0x60, 0xe0, 0x40, 0x40, 0x00, 0x00,  
	}, 
}; 
                 
void 
bigcursor(void) 
{ 
	memmove(&arrow, &fatarrow, sizeof(fatarrow)); 
	pixreverse(arrow.set, 2*16, 0); 
	pixreverse(arrow.clr, 2*16, 0); 
} 
                 
/* 
 *  Table for separating and reversing bits in a ldepth 1 bitmap. 
 *  This aids in coverting a little endian ldepth 1 bitmap into the 
 *  2 big-endian ldepth 0 bitmaps used for the VGA bit planes.
1993/0915/sys/src/9/pc/devvga.c:1063,1065 – 1993/1116/sys/src/9/pc/devvga.c:1196,1328
1992/1119    
 0x1010101, 0x1010103, 0x1010301, 0x1010303, 0x1030101, 0x1030103, 0x1030301, 0x1030303, 
 0x3010101, 0x3010103, 0x3010301, 0x3010303, 0x3030101, 0x3030103, 0x3030301, 0x3030303, 
};
1993/1116    
 
/* 
 *  reverse pixels into little endian order 
 */ 
uchar revtab0[] = { 
 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 
 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, 
 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 
 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 
 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 
 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, 
 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 
 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 
 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 
 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 
 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 
 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 
 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 
 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, 
 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 
 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 
 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 
 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, 
 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 
 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 
 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 
 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 
 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 
 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 
 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 
 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 
 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 
 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 
 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 
 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 
 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 
 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff, 
}; 
uchar revtab1[] = { 
 0x00, 0x40, 0x80, 0xc0, 0x10, 0x50, 0x90, 0xd0, 
 0x20, 0x60, 0xa0, 0xe0, 0x30, 0x70, 0xb0, 0xf0, 
 0x04, 0x44, 0x84, 0xc4, 0x14, 0x54, 0x94, 0xd4, 
 0x24, 0x64, 0xa4, 0xe4, 0x34, 0x74, 0xb4, 0xf4, 
 0x08, 0x48, 0x88, 0xc8, 0x18, 0x58, 0x98, 0xd8, 
 0x28, 0x68, 0xa8, 0xe8, 0x38, 0x78, 0xb8, 0xf8, 
 0x0c, 0x4c, 0x8c, 0xcc, 0x1c, 0x5c, 0x9c, 0xdc, 
 0x2c, 0x6c, 0xac, 0xec, 0x3c, 0x7c, 0xbc, 0xfc, 
 0x01, 0x41, 0x81, 0xc1, 0x11, 0x51, 0x91, 0xd1, 
 0x21, 0x61, 0xa1, 0xe1, 0x31, 0x71, 0xb1, 0xf1, 
 0x05, 0x45, 0x85, 0xc5, 0x15, 0x55, 0x95, 0xd5, 
 0x25, 0x65, 0xa5, 0xe5, 0x35, 0x75, 0xb5, 0xf5, 
 0x09, 0x49, 0x89, 0xc9, 0x19, 0x59, 0x99, 0xd9, 
 0x29, 0x69, 0xa9, 0xe9, 0x39, 0x79, 0xb9, 0xf9, 
 0x0d, 0x4d, 0x8d, 0xcd, 0x1d, 0x5d, 0x9d, 0xdd, 
 0x2d, 0x6d, 0xad, 0xed, 0x3d, 0x7d, 0xbd, 0xfd, 
 0x02, 0x42, 0x82, 0xc2, 0x12, 0x52, 0x92, 0xd2, 
 0x22, 0x62, 0xa2, 0xe2, 0x32, 0x72, 0xb2, 0xf2, 
 0x06, 0x46, 0x86, 0xc6, 0x16, 0x56, 0x96, 0xd6, 
 0x26, 0x66, 0xa6, 0xe6, 0x36, 0x76, 0xb6, 0xf6, 
 0x0a, 0x4a, 0x8a, 0xca, 0x1a, 0x5a, 0x9a, 0xda, 
 0x2a, 0x6a, 0xaa, 0xea, 0x3a, 0x7a, 0xba, 0xfa, 
 0x0e, 0x4e, 0x8e, 0xce, 0x1e, 0x5e, 0x9e, 0xde, 
 0x2e, 0x6e, 0xae, 0xee, 0x3e, 0x7e, 0xbe, 0xfe, 
 0x03, 0x43, 0x83, 0xc3, 0x13, 0x53, 0x93, 0xd3, 
 0x23, 0x63, 0xa3, 0xe3, 0x33, 0x73, 0xb3, 0xf3, 
 0x07, 0x47, 0x87, 0xc7, 0x17, 0x57, 0x97, 0xd7, 
 0x27, 0x67, 0xa7, 0xe7, 0x37, 0x77, 0xb7, 0xf7, 
 0x0b, 0x4b, 0x8b, 0xcb, 0x1b, 0x5b, 0x9b, 0xdb, 
 0x2b, 0x6b, 0xab, 0xeb, 0x3b, 0x7b, 0xbb, 0xfb, 
 0x0f, 0x4f, 0x8f, 0xcf, 0x1f, 0x5f, 0x9f, 0xdf, 
 0x2f, 0x6f, 0xaf, 0xef, 0x3f, 0x7f, 0xbf, 0xff, 
}; 
uchar revtab2[] = { 
 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 
 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 
 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, 
 0x81, 0x91, 0xa1, 0xb1, 0xc1, 0xd1, 0xe1, 0xf1, 
 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, 
 0x82, 0x92, 0xa2, 0xb2, 0xc2, 0xd2, 0xe2, 0xf2, 
 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73, 
 0x83, 0x93, 0xa3, 0xb3, 0xc3, 0xd3, 0xe3, 0xf3, 
 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74, 
 0x84, 0x94, 0xa4, 0xb4, 0xc4, 0xd4, 0xe4, 0xf4, 
 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, 
 0x85, 0x95, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5, 
 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76, 
 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6, 
 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, 
 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xd7, 0xe7, 0xf7, 
 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, 
 0x88, 0x98, 0xa8, 0xb8, 0xc8, 0xd8, 0xe8, 0xf8, 
 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, 
 0x89, 0x99, 0xa9, 0xb9, 0xc9, 0xd9, 0xe9, 0xf9, 
 0x0a, 0x1a, 0x2a, 0x3a, 0x4a, 0x5a, 0x6a, 0x7a, 
 0x8a, 0x9a, 0xaa, 0xba, 0xca, 0xda, 0xea, 0xfa, 
 0x0b, 0x1b, 0x2b, 0x3b, 0x4b, 0x5b, 0x6b, 0x7b, 
 0x8b, 0x9b, 0xab, 0xbb, 0xcb, 0xdb, 0xeb, 0xfb, 
 0x0c, 0x1c, 0x2c, 0x3c, 0x4c, 0x5c, 0x6c, 0x7c, 
 0x8c, 0x9c, 0xac, 0xbc, 0xcc, 0xdc, 0xec, 0xfc, 
 0x0d, 0x1d, 0x2d, 0x3d, 0x4d, 0x5d, 0x6d, 0x7d, 
 0x8d, 0x9d, 0xad, 0xbd, 0xcd, 0xdd, 0xed, 0xfd, 
 0x0e, 0x1e, 0x2e, 0x3e, 0x4e, 0x5e, 0x6e, 0x7e, 
 0x8e, 0x9e, 0xae, 0xbe, 0xce, 0xde, 0xee, 0xfe, 
 0x0f, 0x1f, 0x2f, 0x3f, 0x4f, 0x5f, 0x6f, 0x7f, 
 0x8f, 0x9f, 0xaf, 0xbf, 0xcf, 0xdf, 0xef, 0xff, 
}; 
 
void 
pixreverse(uchar *p, int len, int ldepth) 
{ 
	uchar *e; 
	uchar *tab; 
 
	switch(ldepth){ 
	case 0: 
		tab = revtab0; 
		break; 
	case 1: 
		tab = revtab1; 
		break; 
	case 2: 
		tab = revtab2; 
		break; 
	default: 
		return; 
	} 
 
	for(e = p + len; p < e; p++) 
		*p = tab[*p]; 
}


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)