#include "u.h"#include "../port/lib.h"#include "mem.h"#include "dat.h"#include "fns.h"#include "io.h"#include "ureg.h"#include "../port/error.h" #include <draw.h>#include <memdraw.h>#include <cursor.h>#include "screen.h" #define RGB2K(r,g,b)	((156763*(r)+307758*(g)+59769*(b))>>19) Point ZP = {0, 0}; Rectangle physgscreenr;Cursorinfo cursor;	/* TO DO */ Memdata gscreendata;Memimage *gscreen; VGAscr vgascreen[1]; Cursor	arrow = {	{ -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, 	},}; intscreensize(int x, int y, int z, ulong chan){	VGAscr *scr; 	memimageinit();	scr = &vgascreen[0]; 	/*	 * BUG: need to check if any xalloc'ed memory needs to	 * be given back if aperture is set.	 */	if(scr->aperture == 0){		int width = (x*z)/BI2WD; 		gscreendata.bdata = xalloc(width*BY2WD*y);		if(gscreendata.bdata == 0)			error("screensize: vga soft memory");/*		memset(gscreendata.bdata, 0x72, width*BY2WD*y);	/* not really black */		scr->useflush = 1;		scr->aperture = VGAMEM();		scr->apsize = 1<<16;	}	else		gscreendata.bdata = KADDR(scr->aperture); 	if(gscreen)		freememimage(gscreen); 	gscreen = allocmemimaged(Rect(0,0,x,y), chan, &gscreendata);	vgaimageinit(chan);	if(gscreen == nil)		return -1; 	if(scr->dev && scr->dev->flush)		scr->useflush = 1; 	scr->palettedepth = 6;	/* default */	scr->gscreendata = &gscreendata;	scr->memdefont = getmemdefont();	scr->gscreen = gscreen; 	physgscreenr = gscreen->r; 	drawcmap();	return 0;} intscreenaperture(int size, int align){	VGAscr *scr;	ulong aperture; 	scr = &vgascreen[0]; 	if(size == 0){		if(scr->aperture && scr->isupamem)			upafree(scr->aperture, scr->apsize);		scr->aperture = 0;		scr->isupamem = 0;		return 0;	}	if(scr->dev && scr->dev->linear){		aperture = scr->dev->linear(scr, &size, &align);		if(aperture == 0)			return 1;	}else{		aperture = upamalloc(0, size, align);		if(aperture == 0)			return 1; 		if(scr->aperture && scr->isupamem)			upafree(scr->aperture, scr->apsize);		scr->isupamem = 1;	} 	scr->aperture = aperture;	scr->apsize = size; 	return 0;} uchar*attachscreen(Rectangle* r, ulong* chan, int* d, int* width, int *softscreen){	VGAscr *scr; 	scr = &vgascreen[0];	if(scr->gscreen == nil || scr->gscreendata == nil)		return nil; 	*r = scr->gscreen->clipr;	*chan = scr->gscreen->chan;	*d = scr->gscreen->depth;	*width = scr->gscreen->width;	*softscreen = scr->useflush; 	return scr->gscreendata->bdata;} /* * It would be fair to say that this doesn't work for >8-bit screens. */voidflushmemscreen(Rectangle r){	VGAscr *scr;	uchar *sp, *disp, *sdisp, *edisp;	int y, len, incs, off, page; 	scr = &vgascreen[0];	if(scr->dev && scr->dev->flush){		scr->dev->flush(scr, r);		return;	}	if(scr->gscreen == nil || scr->useflush == 0)		return;	if(scr->dev == nil || scr->dev->page == nil)		return; 	if(rectclip(&r, scr->gscreen->r) == 0)		return; 	incs = scr->gscreen->width * BY2WD; 	switch(scr->gscreen->depth){	default:		len = 0;		panic("flushmemscreen: depth\n");		break;	case 8:		len = Dx(r);		break;	}	if(len < 1)		return; 	off = r.min.y*scr->gscreen->width*BY2WD+(r.min.x*scr->gscreen->depth)/8;	page = off/scr->apsize;	off %= scr->apsize;	disp = KADDR(scr->aperture);	sdisp = disp+off;	edisp = disp+scr->apsize; 	off = r.min.y*scr->gscreen->width*BY2WD+(r.min.x*scr->gscreen->depth)/8; 	sp = scr->gscreendata->bdata + off; 	scr->dev->page(scr, page);	for(y = r.min.y; y < r.max.y; y++) {		if(sdisp + incs < edisp) {			memmove(sdisp, sp, len);			sp += incs;			sdisp += incs;		}		else {			off = edisp - sdisp;			page++;			if(off <= len){				if(off > 0)					memmove(sdisp, sp, off);				scr->dev->page(scr, page);				if(len - off > 0)					memmove(disp, sp+off, len - off);			}			else {				memmove(sdisp, sp, len);				scr->dev->page(scr, page);			}			sp += incs;			sdisp += incs - scr->apsize;		}	}} voidgetcolor(ulong p, ulong* pr, ulong* pg, ulong* pb){	VGAscr *scr;	ulong x; 	scr = &vgascreen[0];	if(scr->gscreen == nil)		return; 	switch(scr->gscreen->depth){	default:		x = 0x0F;		break;	case 8:		x = 0xFF;		break;	}	p &= x; 	lock(&cursor);	*pr = scr->colormap[p][0];	*pg = scr->colormap[p][1];	*pb = scr->colormap[p][2];	unlock(&cursor);} intsetpalette(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. */intsetcolor(ulong p, ulong r, ulong g, ulong b){	VGAscr *scr;	int x; 	scr = &vgascreen[0];	if(scr->gscreen == nil)		return 0; 	switch(scr->gscreen->depth){	case 1:	case 2:	case 4:		x = 0x0F;		break;	case 8:		x = 0xFF;		break;	default:		return 0;	}	p &= x; 	return setpalette(p, r, g, b);} intcursoron(int dolock){	VGAscr *scr;	int v; 	scr = &vgascreen[0];	if(scr->cur == nil || scr->cur->move == nil)		return 0; 	if(dolock)		lock(&cursor);	v = scr->cur->move(scr, mousexy());	if(dolock)		unlock(&cursor); 	return v;} voidcursoroff(int){} voidsetcursor(Cursor* curs){	VGAscr *scr; 	scr = &vgascreen[0];	if(scr->cur == nil || scr->cur->load == nil)		return; 	scr->cur->load(scr, curs);} int hwaccel = 1;int hwblank = 0;	/* turned on by drivers that are known good */int panning = 0; inthwdraw(Memdrawparam *par){	VGAscr *scr;	Memimage *dst, *src;	int m; 	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(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.	 */	m = Simplesrc|Simplemask|Fullmask;	if(scr->fill	&& (par->state&m)==m	&& ((par->srgba&0xFF) == 0xFF)	&& (par->op&S) == S)		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.	 */	m = Simplemask|Fullmask;	src = par->src;	if(scr->scroll	&& src->data->bdata==dst->data->bdata	&& !(src->flags&Falpha)	&& (par->state&m)==m	&& (par->op&S) == S)		return scr->scroll(scr, par->r, par->sr); 	return 0;	} voidblankscreen(int blank){	VGAscr *scr; 	scr = &vgascreen[0];	if(hwblank){		if(scr->blank)			scr->blank(scr, blank);		else			vgablank(scr, blank);	}} voidcursorenable(void){} voidcursordisable(void){}