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

2000/0401/alphapc/screen.c (diff list | history)

1999/0511/sys/src/9/alphapc/screen.c:13,38 – 2000/0401/sys/src/9/alphapc/screen.c:13,26 (short | long | prev | next)
1999/0415    
#include <cursor.h> 
#include "screen.h" 
 
static ulong onesbits = ~0; 
static Memdata onesdata = { 
	nil, 
	&onesbits, 
}; 
static Memimage xones = { 
	{ 0, 0, 1, 1 }, 
	{ -100000, -100000, 100000, 100000 }, 
	3, 
	1, 
	&onesdata, 
	0, 
	1 
}; 
Memimage *memones = &xones;
2000/0401    
#define RGB2K(r,g,b)	((156763*(r)+307758*(g)+59769*(b))>>19)
1999/0415    
 
Point ZP = {0, 0};
2000/0401    
Rectangle physgscreenr;
1999/0415    
Memdata gscreendata; 
Memimage gscreen;
2000/0401    
Memimage *gscreen;
1999/0415    
 
VGAscr vgascreen[1];
1999/0511/sys/src/9/alphapc/screen.c:51,60 – 2000/0401/sys/src/9/alphapc/screen.c:39,49
1999/0415    
}; 
 
int 
screensize(int x, int y, int z)
2000/0401    
screensize(int x, int y, int z, ulong chan)
1999/0415    
{ 
	VGAscr *scr;
2000/0401    
	memimageinit();
1999/0415    
	scr = &vgascreen[0]; 
 
	/*
1999/0511/sys/src/9/alphapc/screen.c:64,73 – 2000/0401/sys/src/9/alphapc/screen.c:53,62
1999/0415    
	if(scr->aperture == 0){ 
		int width = (x*(1<<z))/BI2WD; 
 
		gscreendata.data = xalloc(width*BY2WD*y); 
		if(gscreendata.data == 0)
2000/0401    
		gscreendata.bdata = xalloc(width*BY2WD*y); 
		if(gscreendata.bdata == 0)
1999/0415    
			error("screensize: vga soft memory"); 
		memset(gscreendata.data, Backgnd, width*BY2WD*y);
2000/0401    
		memset(gscreendata.bdata, Backgnd, width*BY2WD*y);
1999/0415    
		scr->useflush = 1;
1999/0511    
		scr->aperture = PADDR(arch->pcimem(0xA0000, 1<<16));
1999/0511/sys/src/9/alphapc/screen.c:74,97 – 2000/0401/sys/src/9/alphapc/screen.c:63,84
1999/0415    
		scr->apsize = 1<<16; 
	} 
	else 
		gscreendata.data = KADDR(scr->aperture);
2000/0401    
		gscreendata.bdata = KADDR(scr->aperture);
1999/0415    
 
	gscreen.data = &gscreendata; 
	gscreen.ldepth = z; 
	gscreen.width = (x*(1<<gscreen.ldepth)+31)/32; 
	gscreen.r.min = ZP; 
	gscreen.r.max = Pt(x, y); 
	gscreen.clipr = gscreen.r; 
	gscreen.repl = 0;
2000/0401    
	if(gscreen) 
		freememimage(gscreen);
1999/0415    
 
	scr->gscreendata = gscreen.data;
2000/0401    
	gscreen = allocmemimaged(Rect(0,0,x,y), chan, &gscreendata); 
	vgaimageinit(chan); 
	if(gscreen == nil) 
		return -1; 
 
	scr->palettedepth = 6;	/* default */ 
	scr->gscreendata = &gscreendata;
1999/0415    
	scr->memdefont = getmemdefont(); 
	scr->gscreen = &gscreen;
2000/0401    
	scr->gscreen = gscreen;
1999/0415    
 
//	memset(gscreen.data->data, Backgnd, scr->apsize); 
                 
	drawcmap(0); 
                 
2000/0401    
	drawcmap();
1999/0415    
	return 0; 
}
1999/0511/sys/src/9/alphapc/screen.c:131,138 – 2000/0401/sys/src/9/alphapc/screen.c:118,125
1999/0415    
	return 0; 
} 
 
ulong* 
attachscreen(Rectangle* r, int* ld, int* width, int *softscreen)
2000/0401    
uchar* 
attachscreen(Rectangle* r, ulong* chan, int* d, int* width, int *softscreen)
1999/0415    
{ 
	VGAscr *scr;
1999/0511/sys/src/9/alphapc/screen.c:141,153 – 2000/0401/sys/src/9/alphapc/screen.c:128,144
1999/0415    
		return nil; 
 
	*r = scr->gscreen->r; 
	*ld = scr->gscreen->ldepth;
2000/0401    
	*chan = scr->gscreen->chan; 
	*d = scr->gscreen->depth;
1999/0415    
	*width = scr->gscreen->width; 
	*softscreen = scr->useflush; 
 
	return scr->gscreendata->data;
2000/0401    
	return scr->gscreendata->bdata;
1999/0415    
}
2000/0401    
/* 
 * It would be fair to say that this doesn't work for >8-bit screens. 
 */
1999/0415    
void 
flushmemscreen(Rectangle r) 
{
1999/0511/sys/src/9/alphapc/screen.c:166,177 – 2000/0401/sys/src/9/alphapc/screen.c:157,168
1999/0415    
 
	incs = scr->gscreen->width * BY2WD; 
 
	switch(scr->gscreen->ldepth){
2000/0401    
	switch(scr->gscreen->depth){
1999/0415    
	default: 
		len = 0; 
		panic("flushmemscreen: ldepth\n");
2000/0401    
		panic("flushmemscreen: depth\n");
1999/0415    
		break; 
	case 3:
2000/0401    
	case 8:
1999/0415    
		len = Dx(r); 
		break; 
	}
1999/0511/sys/src/9/alphapc/screen.c:178,184 – 2000/0401/sys/src/9/alphapc/screen.c:169,175
1999/0415    
	if(len < 1) 
		return; 
 
	off = r.min.y*scr->gscreen->width*BY2WD+(r.min.x>>(3-scr->gscreen->ldepth));
2000/0401    
	off = r.min.y*scr->gscreen->width*BY2WD+(r.min.x*scr->gscreen->depth)/8;
1999/0415    
	page = off/scr->apsize; 
	off %= scr->apsize; 
	disp = KADDR(scr->aperture);
1999/0511/sys/src/9/alphapc/screen.c:185,193 – 2000/0401/sys/src/9/alphapc/screen.c:176,185
1999/0415    
	sdisp = disp+off; 
	edisp = disp+scr->apsize; 
 
	off = r.min.y*scr->gscreen->width*BY2WD+(r.min.x>>(3-scr->gscreen->ldepth)); 
	sp = ((uchar*)scr->gscreendata->data) + off;
2000/0401    
	off = r.min.y*scr->gscreen->width*BY2WD+(r.min.x*scr->gscreen->depth)/8;
1999/0415    
2000/0401    
	sp = scr->gscreendata->bdata + off;
1999/0415    
	scr->dev->page(scr, page); 
	for(y = r.min.y; y < r.max.y; y++) { 
		if(sdisp + incs < edisp) {
1999/0511/sys/src/9/alphapc/screen.c:225,240 – 2000/0401/sys/src/9/alphapc/screen.c:217,231
1999/0415    
	if(scr->gscreen == nil) 
		return; 
 
	switch(scr->gscreen->ldepth){
2000/0401    
	switch(scr->gscreen->depth){
1999/0415    
	default: 
		x = 0x0F; 
		break; 
	case 3:
2000/0401    
	case 8:
1999/0415    
		x = 0xFF; 
		break; 
	} 
	p &= x; 
	p ^= x; 
 
	lock(&cursor); 
	*pr = scr->colormap[p][0];
1999/0511/sys/src/9/alphapc/screen.c:244,280 – 2000/0401/sys/src/9/alphapc/screen.c:235,291
1999/0415    
} 
 
int
2000/0401    
setpalette(ulong p, ulong r, ulong g, ulong b) 
{ 
	VGAscr *scr; 
	int d; 
 
	scr = &vgascreen[0]; 
	d = scr->palettedepth; 
 
	lock(&cursor); 
	scr->colormap[p][0] = r; 
	scr->colormap[p][1] = g; 
	scr->colormap[p][2] = b; 
	vgao(PaddrW, p); 
	vgao(Pdata, r>>(32-d)); 
	vgao(Pdata, g>>(32-d)); 
	vgao(Pdata, b>>(32-d)); 
	unlock(&cursor); 
 
	return ~0; 
} 
 
/* 
 * On some video cards (e.g. Mach64), the palette is used as the  
 * DAC registers for >8-bit modes.  We don't want to set them when the user 
 * is trying to set a colormap and the card is in one of these modes. 
 */ 
int
1999/0415    
setcolor(ulong p, ulong r, ulong g, ulong b) 
{ 
	VGAscr *scr; 
	ulong x;
2000/0401    
	int x;
1999/0415    
 
	scr = &vgascreen[0]; 
	if(scr->gscreen == nil) 
		return 0; 
 
	switch(scr->gscreen->ldepth){ 
	default:
2000/0401    
	switch(scr->gscreen->depth){ 
	case 1: 
	case 2: 
	case 4:
1999/0415    
		x = 0x0F; 
		break; 
	case 3:
2000/0401    
	case 8:
1999/0415    
		x = 0xFF; 
		break;
2000/0401    
	default: 
		return 0;
1999/0415    
	} 
	p &= x; 
	p ^= x; 
 
	lock(&cursor); 
	scr->colormap[p][0] = r; 
	scr->colormap[p][1] = g; 
	scr->colormap[p][2] = b; 
	vgao(PaddrW, p); 
	vgao(Pdata, r>>(32-6)); 
	vgao(Pdata, g>>(32-6)); 
	vgao(Pdata, b>>(32-6)); 
	unlock(&cursor); 
                 
	return ~0;
2000/0401    
	return setpalette(p, r, g, b);
1999/0415    
} 
 
int
1999/0511/sys/src/9/alphapc/screen.c:311,314 – 2000/0401/sys/src/9/alphapc/screen.c:322,515
1999/0415    
		return; 
 
	scr->cur->load(scr, curs);
2000/0401    
} 
 
static ulong 
pixelbits(Memimage *i, Point pt) 
{ 
	uchar *p; 
	ulong val; 
	int off, bpp, npack; 
 
	val = 0; 
	p = byteaddr(i, pt); 
	switch(bpp=i->depth){ 
	case 1: 
	case 2: 
	case 4: 
		npack = 8/bpp; 
		off = pt.x%npack; 
		val = p[0] >> bpp*(npack-1-off); 
		val &= (1<<bpp)-1; 
		break; 
	case 8: 
		val = p[0]; 
		break; 
	case 16: 
		val = p[0]|(p[1]<<8); 
		break; 
	case 24: 
		val = p[0]|(p[1]<<8)|(p[2]<<16); 
		break; 
	case 32: 
		val = p[0]|(p[1]<<8)|(p[2]<<16)|(p[3]<<24); 
		break; 
	} 
	while(bpp<32){ 
		val |= val<<bpp; 
		bpp *= 2; 
	} 
	return val; 
} 
 
 
static ulong 
imgtorgba(Memimage *img, ulong val) 
{ 
	uchar r, g, b, a; 
	int nb, ov, v; 
	ulong chan; 
	uchar *p; 
 
	a = 0xFF; 
	r = g = b = 0xAA;	/* garbage */ 
	for(chan=img->chan; chan; chan>>=8){ 
		nb = NBITS(chan); 
		ov = v = val&((1<<nb)-1); 
		val >>= nb; 
 
		while(nb < 8){ 
			v |= v<<nb; 
			nb *= 2; 
		} 
		v >>= (nb-8); 
 
		switch(TYPE(chan)){ 
		case CRed: 
			r = v; 
			break; 
		case CGreen: 
			g = v; 
			break; 
		case CBlue: 
			b = v; 
			break; 
		case CAlpha: 
			a = v; 
			break; 
		case CGrey: 
			r = g = b = v; 
			break; 
		case CMap: 
			p = img->cmap->cmap2rgb+3*ov; 
			r = *p++; 
			g = *p++;	 
			b = *p; 
			break; 
		} 
	} 
	return (r<<24)|(g<<16)|(b<<8)|a;	 
} 
 
static ulong 
rgbatoimg(Memimage *img, ulong rgba) 
{ 
	ulong chan; 
	int d, nb; 
	ulong v; 
	uchar *p, r, g, b, a, m; 
 
	v = 0; 
	r = rgba>>24; 
	g = rgba>>16; 
	b = rgba>>8; 
	a = rgba; 
	d = 0; 
	for(chan=img->chan; chan; chan>>=8){ 
		nb = NBITS(chan); 
		switch(TYPE(chan)){ 
		case CRed: 
			v |= (r>>(8-nb))<<d; 
			break; 
		case CGreen: 
			v |= (g>>(8-nb))<<d; 
			break; 
		case CBlue: 
			v |= (b>>(8-nb))<<d; 
			break; 
		case CAlpha: 
			v |= (a>>(8-nb))<<d; 
			break; 
		case CMap: 
			p = img->cmap->rgb2cmap; 
			m = p[(r>>4)*256+(g>>4)*16+(b>>4)]; 
			v |= m<<d; 
			break; 
		case CGrey: 
			m = RGB2K(r,g,b); 
			v |= m<<d; 
			break; 
		} 
		d += nb; 
	} 
//	print("rgba2img %.8lux = %.*lux\n", rgba, 2*d/8, v); 
	return v; 
} 
 
Memimage *lastbadi; 
Memdata *lastbad; 
Memimage *lastbadsrc, *lastbaddst; 
int hwaccel = 1; 
 
int 
hwdraw(Memdrawparam *par) 
{ 
	VGAscr *scr; 
	Memimage *dst, *src; 
 
	if(hwaccel == 0) 
		return 0; 
 
	dst = par->dst; 
	scr = &vgascreen[0]; 
	if(dst == nil || dst->data == nil) 
		return 0; 
 
	if(dst->data->bdata != gscreendata.bdata) 
		return 0; 
 
//	if(dst->data != &gscreendata){ 
//		lastbad = dst->data; 
//		lastbadi = dst; 
//		return 0; 
//	} 
 
	if(scr->fill==nil && scr->scroll==nil) 
		return 0; 
 
	/* 
	 * If we have an opaque mask and source is one opaque 
	 * pixel we can convert to the destination format and just 
	 * replicate with memset. 
	 */ 
	if(scr->fill && (par->state&(Simplemask|Simplesrc|Fullmask))==(Simplemask|Simplesrc|Fullmask)) 
		return scr->fill(scr, par->r, par->sdval); 
 
	/* 
	 * If no source alpha, an opaque mask, we can just copy the 
	 * source onto the destination.  If the channels are the same and 
	 * the source is not replicated, memmove suffices. 
	 */ 
	src = par->src; 
	if(scr->scroll && src->data->bdata==dst->data->bdata && !(src->flags&Falpha) 
	&& (par->state&(Simplemask|Fullmask))==(Simplemask|Fullmask)){ 
//		if(src->zero != dst->zero){ 
//			lastbadsrc = src; 
//			lastbaddst = dst; 
//			iprint("#"); 
//		} 
		return scr->scroll(scr, par->r, par->sr); 
	} 
 
	return 0;
1999/0415    
}


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