fb_start.c

早期freebsd实现

			y += sdata->dy;
		}
#ifdef IPC_MRX
		fb->cache_off = 0;
#endif

		break;

	case ROM_KANJI:
#ifdef IPC_MRX
		if (fb->type == FB_NWB251)
			fb->cache_off = 1;
#endif
		while (len > 1) {
			c = *str++;
			c <<= 8;
			c |= *str++;
			dp.x = x >> 16;
			dp.y = y >> 16;
			srec.origin.x = srec.origin.y = 0;

			if (fontBM->type == BM_MEM) {
				/*
				 * KANJI ROM except pop[cm]fb
				 */
				f_addr = fbbm_Krom_addr(fb, c, &srec);
				rommap.fm_vaddr = f_addr;
				rommap.fm_offset = 0;
#ifdef IPC_MRX
				iopmemfbmap(f_addr, flen, &rommap);
#endif
			} else {
				/*
				 * XXX
				 * fontBM->type == BM_FB ---> fbbm_pop[cm]
				 *
				 * see fbpop[cm]_setup() in fbbm_pop[cm].c
				 */
				bzero((caddr_t)fontBM->base,
						sizeof (struct fb_map));
				fbbm_Krom_addr(fb, c, &srec);
				fontBM->rect.origin = srec.origin;
			}

			if (ex_factor == 1) {
				(*bltfunc)(fb, fontBM, &srec, &sdata->drawBM,
					&dp, &cr);
			} else {
				srec.extent.x = 1;
				for (i = 0; i < sdata->width; i++) {
					for (j = 0; j < ex_factor; j++) {
						(*bltfunc)(fb, fontBM, &srec,
							&sdata->drawBM,
							&dp, &cr);
						dp.x++;
					}
					srec.origin.x++;
				}
				srec.extent.x = save.extent.x;
			}
			PRE_EMPT;
			x += sdata->dx;
			y += sdata->dy;
			len -= 2;
		}
#ifdef IPC_MRX
		fb->cache_off = 0;
#endif
		break;

	default:
		cursorOn(fb);
		return (FB_RERROR);
	}

	cursorOn(fb);

	return (FB_ROK);
}

void
linerop(fb, func, fore, aux, trans)
	struct fbdev	*fb;
	register unsigned func;
	register int fore;
	register int aux;
	int trans;
{
	register char *funcv;
	register int i;
	char tmp[4];

	/* set rop function register */
	func &= 0xf;
	tmp[0] = TRANS(trans, (func & 0x0c) | (func >> 2));
	tmp[1] = TRANS(trans, (func >> 2) | ((func << 2) & 0x0c));
	tmp[2] = TRANS(trans, func);
	tmp[3] = TRANS(trans, (func << 2) & 0x0c | func & 3);

	funcv = fb->funcvec;
	for (i = fb->fbNplane; --i >= 0;) {
		*funcv++ = tmp[((fore & 1) << 1) | (aux & 1)];
		fore >>= 1; aux >>= 1;
	}
}

/*
 * line clipping routine
 *
 *	DRAW	visual
 *	NODRAW	not visual
 */
lineclip(p0, p1, r)
	register lPoint *p0;
	register lPoint *p1;
	register lRectangle *r;		/* clipping rectangle */
{
	register lPoint *ptmp;
	register int d0, d1, d2, limit;

	/* sort 2 points by x-coordinate */
	if (p0->x > p1->x) {
		ptmp = p1;
		p1 = p0;
		p0 = ptmp;
	}
	limit = r->origin.x;
	d0 = p1->y - p0->y;
	d1 = p1->x - p0->x;
	if ((d2 = limit - p0->x) > 0) {
		if (p1->x < limit)
			return (NODRAW);
		p0->y += d2 * d0 / d1;
		p0->x = limit;
	}
	limit += r->extent.x - 1;
	if ((d2 = limit - p1->x) < 0) {
		if (p0->x > limit)
			return (NODRAW);
		p1->y += d2 * d0 / d1;
		p1->x = limit;
	}

	/* sort 2 points by y-coordinate */
	if (p0->y > p1->y) {
		ptmp = p1;
		p1 = p0;
		p0 = ptmp;
	}
	limit = r->origin.y;
	d0 = p1->x - p0->x;
	d1 = p1->y - p0->y;
	if ((d2 = limit - p0->y) > 0) {
		if (p1->y < limit)
			return (NODRAW);
		p0->x += d2 * d0 / d1;
		p0->y = limit;
	}
	limit += r->extent.y - 1;
	if ((d2 = limit - p1->y) < 0) {
		if (p0->y > limit)
			return (NODRAW);
		p1->x += d2 * d0 / d1;
		p1->y = limit;
	}
	return (DRAW);
}

#ifndef CPU_DOUBLE
/*
void
point(p, x, s, fp)
	register char *p;
	register int x;
	register int s;
	register char *fp;
{
	x = 7 - (x & 7);
	if ((1 << (3 - (((s & 1) << 1) | ((*p >> x) & 1)))) & *fp)
		*p |= (1 << x);
	else
		*p &= ~(1 << x);
}
*/
#define point(p, x, s, fp) { \
	int xx = 7 - ((x) & 7); \
	if ((1 << (3 - ((((s) & 1) << 1) | ((*(p) >> xx) & 1)))) & *(fp)) \
		*(p) |= (1 << xx); \
	else \
		*(p) &= ~(1 << xx); \
}

mem_vector(fb, p0, p1, mask, dbmp, lpf)
	struct fbdev	*fb;
	lPoint *p0, *p1;
	int mask;		/* plane mask */
	lBitmap *dbmp;		/* drawing bitmap */
	int lpf;		/* if 0, don't draw last point */
{
	register struct fb_map *map = (struct fb_map *)dbmp->base;
	register char *funcv = fb->funcvec;		/* rop function */
	int p = (int)map->fm_offset;
	register int pmask;
	register unsigned int pat;
	register int x = p0->x;
	register int y = p0->y;
	register char *fp;
	int width = dbmp->width << 1;
	int lim;
	int size = width * dbmp->rect.extent.y;
	int ddx, ddy;
	int s, d, c;
	int dx = p1->x - x;
	int dy = p1->y - y;
	int i, j;
	int depth = dbmp->depth;

	/* transformation */
	x -= dbmp->rect.origin.x;
	y -= dbmp->rect.origin.y;

	pat = fb->pat;

	ddx = 1;
	ddy = dbmp->width << 1;
	y = (int)p + y * ddy;

	if (dx == 0)
		ddx = 0;
	else if (dx < 0) {
		dx = -dx;
		ddx = -ddx;
	}

	if (dy == 0)
		ddy = 0;
	else if (dy < 0) {
		dy = -dy;
		ddy = -ddy;
	}
	
	if (dx > dy) {	/* case x */
		lim = dx;
		if (lpf)
			lim++;

		s = -dx;
		d = dx << 1;
		c = dy << 1;

		for (i = lim; i > 0; i--) {
			(int)p = y + (x >> 3);

			pat = (pat << 1) | ((pat & 0x80000000) ? 1: 0);

			fp = funcv;
			pmask = mask;

			for (j = depth; j > 0; j--) {
				if (pmask & 1) {
					point(_TypeAt(map, p), x, pat, fp);
				}

				p += size;
				pmask >>= 1;
				fp++;
			}

			if ((s += c) >= 0) {
				s -= d;
				y += ddy;
			}

			x += ddx;
		}
	} else {			/* case y */
		lim = dy;
		if (lpf)
			lim++;
		s = -dy;
		d = dy << 1;
		c = dx << 1;

		for (i = lim; i > 0; i--) {
			(int)p = y + (x >> 3);
			pat = (pat << 1) | ((pat & 0x80000000) ? 1: 0);

			fp = funcv;
			pmask = mask;

			for (j = depth; j > 0; j--) {
				if (pmask & 1) {
					point(_TypeAt(map, p), x, pat, fp);
				}

				p += size;
				pmask >>= 1;
				fp++;
			}

			if ((s += c) >= 0) {
				s -= d;
				x += ddx;
			}

			y += ddy;
		}
	}
	
	/* rotate pattern */
	pat = fb->pat;

	{
		register int tmp;

		tmp = lim & 31;
		pat = (pat << tmp) | (pat >> (32 - tmp));
	}

	fb->pat = pat;
}
#endif /* !CPU_DOUBLE */

/* polyline drawing */
draw_polyline(fb, dp)
	struct fbdev *fb;
	register lPrimLine *dp;
{
	register lPoint *ps;
	lPoint p0, p1;
	register int np;
	lRectangle clip, *clipp;
#ifdef CPU_SINGLE
	struct fb_map *map;
	unsigned int p;
#endif

	/* clip rectangle */
	clip = dp->clip;

	if (clip.origin.x == -1)
		clipp = 0;
	else {
		clipp = &clip;
		if (!getclip(fb, &dp->drawBM, clipp)) return 0;
	}
#ifdef CPU_SINGLE
	map = (struct fb_map *)(dp->plist);
	p = map->fm_offset;
	ps = (lPoint *)TypeAt(map, p);
#else
	ps = dp->plist;
#endif
	if (dp->drawBM.type == BM_FB) {

		cursorCheck(fb, ~BM_FB, 0, dp->drawBM.type, clipp);
		fbbm_rop_vect(fb, clipp, dp->func, dp->fore_color,
				dp->aux_color, dp->transp, dp->planemask,
				dp->np, ps, dp->lptn, (dp->dlpf)?1:0, 1);
		cursorOn(fb);

		return(FB_ROK);
	}
#ifndef CPU_DOUBLE
	linerop(fb, dp->func, dp->fore_color, dp->aux_color, dp->transp);
	p0 = *ps++;
	np = dp->np - 1;
	fb->pat = dp->lptn;
	if (clipp) {
		while (--np > 0) {
			p1 = *ps;
			if (lineclip(&p0, &p1, clipp)) {
				mem_vector(fb, &p0, &p1,
					dp->planemask, &dp->drawBM,
					ps->x != p1.x || ps->y != p1.y);
				PRE_EMPT;
			}
			p0 = *ps++;
		}
		p1 = *ps;
		if (lineclip(&p0, &p1, clipp)) {
			mem_vector(fb, &p0, &p1, dp->planemask, &dp->drawBM,
				ps->x != p1.x || ps->y != p1.y || dp->dlpf);
		}
	} else {
		while (--np > 0) {
			p1 = *ps;
			mem_vector(fb, &p0, &p1, dp->planemask, &dp->drawBM, 0);
			PRE_EMPT;
			p0 = *ps++;
		}
		p1 = *ps;
		mem_vector(fb, &p0, &p1, dp->planemask, &dp->drawBM, dp->dlpf);
	}
#endif /* !CPU_DOUBLE */
	return (FB_ROK);
}

/* disjoint polyline drawing */

draw_dj_polyline(fb, dp)
	struct fbdev *fb;
	register lPrimLine *dp;
{
	register lPoint *ps;
	lPoint p0, p1;
	register int np;
	lRectangle clip, *clipp;
#ifdef CPU_SINGLE
	struct fb_map *map;
	unsigned int p;
#endif

	int lpf = (dp->dlpf)?1:0;

	/* clip rectangle */
	clip = dp->clip;

	if (clip.origin.x == -1)
		clipp = 0;
	else {
		clipp = &clip;
		if(!getclip(fb, &dp->drawBM, clipp)) return (0);
	}
#ifdef CPU_SINGLE
	map = (struct fb_map *)(dp->plist);
	p = map->fm_offset;
	ps = (lPoint *)TypeAt(map, p);
#else
	ps = dp->plist;
#endif
	if (dp->drawBM.type == BM_FB) {

		cursorCheck(fb, ~BM_FB, 0, dp->drawBM.type, clipp);
		fbbm_rop_vect(fb, clipp, dp->func, dp->fore_color,
				dp->aux_color, dp->transp, dp->planemask,
						dp->np, ps, dp->lptn, lpf, 0);
		cursorOn(fb);
		PRE_EMPT;

		return (FB_ROK);
	}
#ifndef CPU_DOUBLE
	linerop(fb, dp->func, dp->fore_color, dp->aux_color, dp->transp);
	np = dp->np >> 1;
	if (lpf) {
		if (clipp) {
			while (--np >= 0) {
				p0 = *ps++;
				p1 = *ps++;
				fb->pat = dp->lptn;
				if (lineclip(&p0, &p1, clipp)) {
					mem_vector(fb, &p0, &p1,
						dp->planemask, &dp->drawBM, 1);
					PRE_EMPT;
				}
			}
		} else {
			while (--np >= 0) {
				p0 = *ps++;
				p1 = *ps++;
				fb->pat = dp->lptn;
				mem_vector(fb, &p0, &p1,
					dp->planemask, &dp->drawBM, 1);
				PRE_EMPT;
			}
		}
	} else {
		if (clipp) {
			while (--np >= 0) {
				p0 = *ps++;
				p1 = *ps;
				fb->pat = dp->lptn;
				if (lineclip(&p0, &p1, clipp)) {
					mem_vector(fb, &p0, &p1,
						dp->planemask, &dp->drawBM,
						ps->x != p1.x || ps->y != p1.y);
					PRE_EMPT;
				}
				ps++;
			}
		} else {
			while (--np >= 0) {
				p0 = *ps++;
				p1 = *ps++;
				fb->pat = dp->lptn;
				mem_vector(fb, &p0, &p1,
					dp->planemask, &dp->drawBM, 0);
				PRE_EMPT;
			}
		}
	}
#endif /* !CPU_DOUBLE */
	return (FB_ROK);
}

static lRectangle	dotRect = {{ 0, 0 }, { 1, 1 }};

emulate_polydot(fb, dp)
	struct fbdev *fb;
	register lPrimDot *dp;
{
	lPrimMarker marker;
	lPrimMarker *cmdp;
	register lPoint *ps;
	register int np;
	lRectangle cr;
	register int (*blt)();
#ifdef CPU_SINGLE
	struct fb_map *map;
	unsigned int p;
#endif

	cmdp = &marker;

	cmdp->func = dp->func;
        cmdp->transp = dp->transp;
        cmdp->fore_color = dp->fore_color;
        cmdp->aux_color = dp->aux_color;
        cmdp->planemask = dp->planemask;
        cmdp->ptnRect = dotRect;
        cmdp->ptnBM.type = BM_1;
        cmdp->ptnBM.depth = 1;
        cmdp->ptnBM.rect = dotRect;
        cmdp->drawBM = dp->drawBM;
        cmdp->clip = dp->clip;
        cmdp->np = dp->np;
        cmdp->plist = dp->plist;

	return (draw_polymarker(fb, cmdp));
}

#ifndef CPU_DOUBLE
mem_dot(fb, p0, mask, dbmp)
	struct fbdev	*fb;
	lPoint		*p0;
	register int	mask;		/* plane mask */
	lBitmap		*dbmp;		/* drawing bitmap */
{
	register struct fb_map *map = (struct fb_map *)dbmp->base;
	register char *funcv;	/* rop function */
	register int p = (int)map->fm_offset;
	register int depth;
	int size;
	int x, y;

	x = p0->x - dbmp->rect.origin.x;
	y = p0->y - dbmp->rect.origin.y;

	size = (dbmp->width * dbmp->rect.extent.y) << 1;

	p += y * (dbmp->width << 1) + (x >> 3);

	funcv = fb->funcvec;
	for (depth = dbmp->depth; --depth >= 0;) {
		if (mask & 1) {
			point(_TypeAt(map, p), x, ~0, funcv);
		}
		p += size;
		mask >>= 1;
		funcv++;
	}
}
#endif /* !CPU_DOUBLE */

draw_polydot(fb, dp)
	struct fbdev *fb;
	register lPrimDot *dp;
{
	register lPoint *ps;
	lRectangle clip, *clipp;
	register int np;
#ifdef CPU_SINGLE
	struct fb_map *map;
	unsigned int p;
#endif

	if (fb->fbbm_op->fb_rop_dot == (void (*)())nofunc)
		return (emulate_polydot(fb, dp));
		
	/* clip rectangle */
	clip = dp->clip;

	if (clip.origin.x == -1)
		clipp = 0;
	else {
		clipp = &clip;
		if (!getclip(fb, &dp->drawBM, clipp)) return 0;
	}

#ifdef CPU_SINGLE
	map = (struct fb_map *)(dp->plist);
	p = map->fm_offset;
	ps = (lPoint *)TypeAt(map, p);
#else
	ps = dp->plist;
#endif

	if (dp->drawBM.type == BM_FB) {
		cursorCheck(fb, ~BM_FB, 0, dp->drawBM.type, clipp);
		fbbm_rop_dot(fb, clipp, dp->func, dp->fore_color,
				dp->aux_color, dp->transp, dp->planemask,
				dp->np, ps);
		cursorOn(fb);

		return(FB_ROK);
	}
#ifndef CPU_DOUBLE
	linerop(fb, dp->func, dp->fore_color, dp->aux_color, dp->transp);

	np = dp->np;
	if (clipp) {
		register int x0, y0, x1, y1;

		x0 = clipp->origin.x;
		y0 = clipp->origin.y;
		x1 = x0 + clipp->extent.x - 1;
		y1 = y0 + clipp->extent.y - 1;
		if (x1 <= 0 || y1 <= 0) return;

		while (--np >= 0) {
			if ((ps->x >= x0) && (ps->y >= y0) &&
			    (ps->x <= x1) && (ps->y <= y1)) {
				mem_dot(fb, ps, dp->planemask, &dp->drawBM);
				PRE_EMPT;
			}
			ps++;
		}
	} else {
		while (--np >= 0) {
			mem_dot(fb, ps, dp->planemask, &dp->drawBM);
			PRE_EMPT;
			ps++;
		}
	}
#endif /* !CPU_DOUBLE */
	return (FB_ROK);
}

get_scrtype(fb, cmd)
	register struct fbdev *fb;
	register lScrType *cmd;
{
	cmd->colorwidth = fb->Colorwidth;
	cmd->plane = fb->fbNplane;
	cmd->bu