xref: /src/sys/dev/rasops/rasops.c

/*	 $NetBSD: rasops.c,v 1.102 2019/07/31 00:14:25 rin Exp $	*/

/*-
 * Copyright (c) 1999 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Andrew Doran.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rasops.c,v 1.102 2019/07/31 00:14:25 rin Exp $");

#include "opt_rasops.h"
#include "rasops_glue.h"
#include "opt_wsmsgattrs.h"

#include <sys/param.h>
#include <sys/bswap.h>
#include <sys/kmem.h>
#include <sys/systm.h>
#include <sys/time.h>

#include <machine/endian.h>

#include <dev/wscons/wsdisplayvar.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wsfont/wsfont.h>

#define	_RASOPS_PRIVATE
#include <dev/rasops/rasops.h>

#ifndef _KERNEL
#include <errno.h>
#endif

#ifdef RASOPS_DEBUG
#define DPRINTF(...) aprint_error(...)
#else
#define DPRINTF(...) __nothing
#endif

struct rasops_matchdata {
	struct rasops_info *ri;
	int wantcols, wantrows;
	int bestscore;
	struct wsdisplay_font *pick;
	int ident;
};

/* ANSI colormap (R,G,B). Upper 8 are high-intensity */
const uint8_t rasops_cmap[256 * 3] = {
	0x00, 0x00, 0x00, /* black */
	0x7f, 0x00, 0x00, /* red */
	0x00, 0x7f, 0x00, /* green */
	0x7f, 0x7f, 0x00, /* brown */
	0x00, 0x00, 0x7f, /* blue */
	0x7f, 0x00, 0x7f, /* magenta */
	0x00, 0x7f, 0x7f, /* cyan */
	0xc7, 0xc7, 0xc7, /* white - XXX too dim? */

	0x7f, 0x7f, 0x7f, /* black */
	0xff, 0x00, 0x00, /* red */
	0x00, 0xff, 0x00, /* green */
	0xff, 0xff, 0x00, /* brown */
	0x00, 0x00, 0xff, /* blue */
	0xff, 0x00, 0xff, /* magenta */
	0x00, 0xff, 0xff, /* cyan */
	0xff, 0xff, 0xff, /* white */

	/*
	 * For the cursor, we need at least the last (255th)
	 * color to be white. Fill up white completely for
	 * simplicity.
	 */
#define _CMWHITE 0xff, 0xff, 0xff,
#define _CMWHITE16	_CMWHITE _CMWHITE _CMWHITE _CMWHITE \
			_CMWHITE _CMWHITE _CMWHITE _CMWHITE \
			_CMWHITE _CMWHITE _CMWHITE _CMWHITE \
			_CMWHITE _CMWHITE _CMWHITE _CMWHITE
	_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
	_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
	_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 /* but not the last one */
#undef _CMWHITE16
#undef _CMWHITE

	/*
	 * For the cursor the fg/bg indices are bit inverted, so
	 * provide complimentary colors in the upper 16 entries.
	 */
	0x7f, 0x7f, 0x7f, /* black */
	0xff, 0x00, 0x00, /* red */
	0x00, 0xff, 0x00, /* green */
	0xff, 0xff, 0x00, /* brown */
	0x00, 0x00, 0xff, /* blue */
	0xff, 0x00, 0xff, /* magenta */
	0x00, 0xff, 0xff, /* cyan */
	0xff, 0xff, 0xff, /* white */

	0x00, 0x00, 0x00, /* black */
	0x7f, 0x00, 0x00, /* red */
	0x00, 0x7f, 0x00, /* green */
	0x7f, 0x7f, 0x00, /* brown */
	0x00, 0x00, 0x7f, /* blue */
	0x7f, 0x00, 0x7f, /* magenta */
	0x00, 0x7f, 0x7f, /* cyan */
	0xc7, 0xc7, 0xc7, /* white - XXX too dim? */
};

/* True if color is gray */
static const uint8_t rasops_isgray[16] = {
	1, 0, 0, 0, 0, 0, 0, 1,
	1, 0, 0, 0, 0, 0, 0, 1,
};

#ifdef RASOPS_APPLE_PALETTE
/*
 * Approximate ANSI colormap for legacy Apple color palettes
 */
static const uint8_t apple8_devcmap[16] = {
	0xff,	/* black	0x00, 0x00, 0x00 */
	0x6b,	/* red		0x99, 0x00, 0x00 */
	0xc5,	/* green	0x00, 0x99, 0x00 */
	0x59,	/* yellow	0x99, 0x99, 0x00 */
	0xd4,	/* blue		0x00, 0x00, 0x99 */
	0x68,	/* magenta	0x99, 0x00, 0x99 */
	0xc2,	/* cyan		0x00, 0x99, 0x99 */
	0x2b,	/* white	0xcc, 0xcc, 0xcc */

	0x56,	/* black	0x99, 0x99, 0x99 */
	0x23,	/* red		0xff, 0x00, 0x00 */
	0xb9,	/* green	0x00, 0xff, 0x00 */
	0x05,	/* yellow	0xff, 0xff, 0x00 */
	0xd2,	/* blue		0x00, 0x00, 0xff */
	0x1e,	/* magenta	0xff, 0x00, 0xff */
	0xb4,	/* cyan		0x00, 0xff, 0xff */
	0x00,	/* white	0xff, 0xff, 0xff */
};

static const uint8_t apple4_devcmap[16] = {
	15,	/* black	*/
	 3,	/* red		*/
	 8,	/* green	*/
	 1,	/* yellow	*/
	 6,	/* blue		*/
	 4,	/* magenta	*/
	 7,	/* cyan		*/
	12,	/* light grey	*/

	13,	/* medium grey	*/
	 3,	/* red		*/
	 8,	/* green	*/
	 1,	/* yellow	*/
	 6,	/* blue		*/
	 4,	/* magenta	*/
	 7,	/* cyan		*/
	 0,	/* white	*/
};
#endif

/* Generic functions */
static void	rasops_copyrows(void *, int, int, int);
static void	rasops_copycols(void *, int, int, int, int);
static int	rasops_mapchar(void *, int, u_int *);
static void	rasops_cursor(void *, int, int, int);
static int	rasops_allocattr_color(void *, int, int, int, long *);
static int	rasops_allocattr_mono(void *, int, int, int, long *);
static void	rasops_do_cursor(struct rasops_info *);
static void	rasops_init_devcmap(struct rasops_info *);

#if NRASOPS_ROTATION > 0
static void	rasops_rotate_font(int *, int);
static void	rasops_copychar(void *, int, int, int, int);

/* rotate clockwise */
static void	rasops_copycols_rotated_cw(void *, int, int, int, int);
static void	rasops_copyrows_rotated_cw(void *, int, int, int);
static void	rasops_erasecols_rotated_cw(void *, int, int, int, long);
static void	rasops_eraserows_rotated_cw(void *, int, int, long);
static void	rasops_putchar_rotated_cw(void *, int, int, u_int, long);

/* rotate counter-clockwise */
static void	rasops_copychar_ccw(void *, int, int, int, int);
static void	rasops_copycols_rotated_ccw(void *, int, int, int, int);
static void	rasops_copyrows_rotated_ccw(void *, int, int, int);
#define rasops_erasecols_rotated_ccw rasops_erasecols_rotated_cw
#define rasops_eraserows_rotated_ccw rasops_eraserows_rotated_cw
static void	rasops_putchar_rotated_ccw(void *, int, int, u_int, long);

/*
 * List of all rotated fonts
 */
SLIST_HEAD(, rotatedfont) rotatedfonts = SLIST_HEAD_INITIALIZER(rotatedfonts);
struct rotatedfont {
	SLIST_ENTRY(rotatedfont) rf_next;
	int rf_cookie;
	int rf_rotated;
};
#endif	/* NRASOPS_ROTATION > 0 */

void	rasops_make_box_chars_8(struct rasops_info *);
void	rasops_make_box_chars_16(struct rasops_info *);
void	rasops_make_box_chars_32(struct rasops_info *);
void	rasops_make_box_chars_alpha(struct rasops_info *);

/*
 * Initialize a 'rasops_info' descriptor.
 */
int
rasops_init(struct rasops_info *ri, int wantrows, int wantcols)
{

	memset(&ri->ri_optfont, 0, sizeof(ri->ri_optfont));
#ifdef _KERNEL
	/* Select a font if the caller doesn't care */
	if (ri->ri_font == NULL) {
		int cookie = -1;
		int flags;

		wsfont_init();

		/*
		 * first, try to find something that's as close as possible
		 * to the caller's requested terminal size
		 */
		if (wantrows == 0)
			wantrows = RASOPS_DEFAULT_HEIGHT;
		if (wantcols == 0)
			wantcols = RASOPS_DEFAULT_WIDTH;

		flags = WSFONT_FIND_BESTWIDTH | WSFONT_FIND_BITMAP;
		if ((ri->ri_flg & RI_ENABLE_ALPHA) != 0)
			flags |= WSFONT_FIND_ALPHA;
		if ((ri->ri_flg & RI_PREFER_ALPHA) != 0)
			flags |= WSFONT_PREFER_ALPHA;
		cookie = wsfont_find(NULL,
			ri->ri_width / wantcols,
			0,
			0,
			WSDISPLAY_FONTORDER_L2R,
			WSDISPLAY_FONTORDER_L2R,
			flags);

		/*
		 * this means there is no supported font in the list
		 */
		if (cookie <= 0) {
			aprint_error("%s: font table is empty\n", __func__);
			return -1;
		}

#if NRASOPS_ROTATION > 0
		/*
		 * Pick the rotated version of this font. This will create it
		 * if necessary.
		 */
		if (ri->ri_flg & RI_ROTATE_MASK) {
			if (ri->ri_flg & RI_ROTATE_CW)
				rasops_rotate_font(&cookie, WSFONT_ROTATE_CW);
			else if (ri->ri_flg & RI_ROTATE_CCW)
				rasops_rotate_font(&cookie, WSFONT_ROTATE_CCW);
		}
#endif

		if (wsfont_lock(cookie, &ri->ri_font)) {
			aprint_error("%s: couldn't lock font\n", __func__);
			return -1;
		}

		ri->ri_wsfcookie = cookie;
	}
#endif

	/* This should never happen in reality... */
	if ((uintptr_t)ri->ri_bits & 3) {
		aprint_error("%s: bits not aligned on 32-bit boundary\n",
		    __func__);
		return -1;
	}

	if (ri->ri_stride & 3) {
		aprint_error("%s: stride not aligned on 32-bit boundary\n",
		    __func__);
		return -1;
	}

	if (rasops_reconfig(ri, wantrows, wantcols))
		return -1;

	rasops_init_devcmap(ri);
	return 0;
}

/*
 * Reconfigure (because parameters have changed in some way).
 */
int
rasops_reconfig(struct rasops_info *ri, int wantrows, int wantcols)
{
	int bpp, s;
	size_t len;

	s = splhigh();

	if (wantrows == 0)
		wantrows = RASOPS_DEFAULT_HEIGHT;
	if (wantcols == 0)
		wantcols = RASOPS_DEFAULT_WIDTH;

	/* throw away old line drawing character bitmaps, if we have any */
	if (ri->ri_optfont.data != NULL) {
		kmem_free(ri->ri_optfont.data, ri->ri_optfont.stride *
		    ri->ri_optfont.fontheight * ri->ri_optfont.numchars);
		ri->ri_optfont.data = NULL;
	}

	/* autogenerate box drawing characters */
	ri->ri_optfont.firstchar = WSFONT_FLAG_OPT;
	ri->ri_optfont.numchars = 16;
	ri->ri_optfont.fontwidth = ri->ri_font->fontwidth;
	ri->ri_optfont.fontheight = ri->ri_font->fontheight;
	ri->ri_optfont.stride = ri->ri_font->stride;
	len = ri->ri_optfont.fontheight * ri->ri_optfont.stride *
	    ri->ri_optfont.numchars;

	if (ri->ri_font->fontwidth > 32 || ri->ri_font->fontwidth < 4) {
		aprint_error("%s: fontwidth assumptions botched", __func__);
		splx(s);
		return -1;
	}

	if ((ri->ri_flg & RI_NO_AUTO) == 0) {
		ri->ri_optfont.data = kmem_zalloc(len, KM_SLEEP);
		if (FONT_IS_ALPHA(&ri->ri_optfont))
			rasops_make_box_chars_alpha(ri);
		else {
			switch (ri->ri_optfont.stride) {
			case 1:
				rasops_make_box_chars_8(ri);
				break;
			case 2:
				rasops_make_box_chars_16(ri);
				break;
			case 4:
				rasops_make_box_chars_32(ri);
				break;
			default:
				aprint_error(
				    "%s: font stride assumptions botched",
				    __func__);
				splx(s);
				return -1;
			}
		}
	} else
		memset(&ri->ri_optfont, 0, sizeof(ri->ri_optfont));

	/* Need this to frob the setup below */
	bpp = (ri->ri_depth == 15 ? 16 : ri->ri_depth);

	if ((ri->ri_flg & RI_CFGDONE) != 0) {
		ri->ri_bits = ri->ri_origbits;
		ri->ri_hwbits = ri->ri_hworigbits;
	}

	/* Don't care if the caller wants a hideously small console */
	if (wantrows < 10)
		wantrows = 10;

	if (wantcols < 20)
		wantcols = 20;

	/* Now constrain what they get */
	ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols;
	ri->ri_emuheight = ri->ri_font->fontheight * wantrows;

	if (ri->ri_emuwidth > ri->ri_width)
		ri->ri_emuwidth = ri->ri_width;

	if (ri->ri_emuheight > ri->ri_height)
		ri->ri_emuheight = ri->ri_height;

	/* Reduce width until aligned on a 32-bit boundary */
	while ((ri->ri_emuwidth * bpp & 31) != 0)
		ri->ri_emuwidth--;

#if NRASOPS_ROTATION > 0
	if (ri->ri_flg & (RI_ROTATE_CW|RI_ROTATE_CCW)) {
		ri->ri_rows = ri->ri_emuwidth / ri->ri_font->fontwidth;
		ri->ri_cols = ri->ri_emuheight / ri->ri_font->fontheight;
	} else
#endif
	{

		ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth;
		ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight;
	}
	ri->ri_emustride = ri->ri_emuwidth * bpp >> 3;
	ri->ri_delta = ri->ri_stride - ri->ri_emustride;
	ri->ri_ccol = 0;
	ri->ri_crow = 0;
	ri->ri_pelbytes = bpp >> 3;

	ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3;
	ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride;
	ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride;

	if ((ri->ri_delta & 3) != 0) {
		aprint_error(
		    "%s: ri_delta not aligned on 32-bit boundary", __func__);
		splx(s);
		return -1;
	}
	ri->ri_origbits = ri->ri_bits;
	ri->ri_hworigbits = ri->ri_hwbits;

	/* Clear the entire display */
	if ((ri->ri_flg & RI_CLEAR) != 0)
		memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);

	/* Now centre our window if needs be */
	if ((ri->ri_flg & RI_CENTER) != 0) {
		ri->ri_bits += (((ri->ri_width * bpp >> 3) -
		    ri->ri_emustride) >> 1) & ~3;
		ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
		    ri->ri_stride;
		if (ri->ri_hwbits != NULL) {
			ri->ri_hwbits += (((ri->ri_width * bpp >> 3) -
			    ri->ri_emustride) >> 1) & ~3;
			ri->ri_hwbits +=
			    ((ri->ri_height - ri->ri_emuheight) >> 1) *
			    ri->ri_stride;
		}
		ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits) /
		    ri->ri_stride;
		ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits) %
		    ri->ri_stride) * 8 / bpp);
	} else
		ri->ri_xorigin = ri->ri_yorigin = 0;

	/*
	 * Fill in defaults for operations set.  XXX this nukes private
	 * routines used by accelerated fb drivers.
	 */
	ri->ri_ops.mapchar = rasops_mapchar;
	ri->ri_ops.copyrows = rasops_copyrows;
	ri->ri_ops.copycols = rasops_copycols;
	ri->ri_ops.erasecols = rasops_erasecols;
	ri->ri_ops.eraserows = rasops_eraserows;
	ri->ri_ops.cursor = rasops_cursor;
	ri->ri_do_cursor = rasops_do_cursor;

	ri->ri_caps &= ~(WSSCREEN_UNDERLINE | WSSCREEN_HILIT |
		    WSSCREEN_WSCOLORS | WSSCREEN_REVERSE);

	if ((ri->ri_flg & RI_FORCEMONO) != 0 ||
#ifdef RASOPS_APPLE_PALETTE
	    ri->ri_depth == 1
#else
	    ri->ri_depth < 8
#endif
	) {
		ri->ri_ops.allocattr = rasops_allocattr_mono;
		ri->ri_caps |= WSSCREEN_UNDERLINE | WSSCREEN_REVERSE;
	} else {
		ri->ri_ops.allocattr = rasops_allocattr_color;
		ri->ri_caps |= WSSCREEN_UNDERLINE | WSSCREEN_HILIT |
		    WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
	}

	switch (ri->ri_depth) {
#if NRASOPS1 > 0
	case 1:
		rasops1_init(ri);
		break;
#endif
#if NRASOPS2 > 0
	case 2:
		rasops2_init(ri);
		break;
#endif
#if NRASOPS4 > 0
	case 4:
		rasops4_init(ri);
		break;
#endif
#if NRASOPS8 > 0
	case 8:
		rasops8_init(ri);
		break;
#endif
#if (NRASOPS15 + NRASOPS16) > 0
	case 15:
	case 16:
		rasops15_init(ri);
		break;
#endif
#if NRASOPS24 > 0
	case 24:
		rasops24_init(ri);
		break;
#endif
#if NRASOPS32 > 0
	case 32:
		rasops32_init(ri);
		break;
#endif
	default:
		ri->ri_flg &= ~RI_CFGDONE;
		aprint_error("%s: depth not supported\n", __func__);
		splx(s);
		return -1;
	}

#if NRASOPS_ROTATION > 0
	if (ri->ri_flg & RI_ROTATE_MASK) {
		if (ri->ri_flg & RI_ROTATE_CW) {
			ri->ri_real_ops = ri->ri_ops;
			ri->ri_ops.copycols = rasops_copycols_rotated_cw;
			ri->ri_ops.copyrows = rasops_copyrows_rotated_cw;
			ri->ri_ops.erasecols = rasops_erasecols_rotated_cw;
			ri->ri_ops.eraserows = rasops_eraserows_rotated_cw;
			ri->ri_ops.putchar = rasops_putchar_rotated_cw;
		} else if (ri->ri_flg & RI_ROTATE_CCW) {
			ri->ri_real_ops = ri->ri_ops;
			ri->ri_ops.copycols = rasops_copycols_rotated_ccw;
			ri->ri_ops.copyrows = rasops_copyrows_rotated_ccw;
			ri->ri_ops.erasecols = rasops_erasecols_rotated_ccw;
			ri->ri_ops.eraserows = rasops_eraserows_rotated_ccw;
			ri->ri_ops.putchar = rasops_putchar_rotated_ccw;
		}
	}
#endif

	ri->ri_flg |= RI_CFGDONE;
	splx(s);
	return 0;
}

/*
 * Map a character.
 */
static int
rasops_mapchar(void *cookie, int c, u_int *cp)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;

	KASSERT(ri->ri_font != NULL);

	if ((c = wsfont_map_unichar(ri->ri_font, c)) < 0 ||
	    c < ri->ri_font->firstchar) {
		*cp = ' ';
		return 0;
	}

#if 0 /* XXXRO */
	if (CHAR_IN_FONT(c, ri->ri_font)) {
		*cp = ' ';
		return 0;
	}
#endif

	*cp = c;
	return 5;
}

/*
 * Allocate a color attribute.
 */
static int
rasops_allocattr_color(void *cookie, int fg0, int bg0, int flg, long *attr)
{
	uint32_t fg = fg0, bg = bg0;

	if (__predict_false(fg >= sizeof(rasops_isgray) ||
	    bg >= sizeof(rasops_isgray)))
		return EINVAL;

#ifdef RASOPS_CLIPPING
	fg &= 7;
	bg &= 7;
#endif
	if ((flg & WSATTR_BLINK) != 0)
		return EINVAL;

	if ((flg & WSATTR_WSCOLORS) == 0) {
#ifdef WS_DEFAULT_FG
		fg = WS_DEFAULT_FG;
#else
		fg = WSCOL_WHITE;
#endif
#ifdef WS_DEFAULT_BG
		bg = WS_DEFAULT_BG;
#else
		bg = WSCOL_BLACK;
#endif
	}

	if ((flg & WSATTR_HILIT) != 0)
		fg += 8;

	if ((flg & WSATTR_REVERSE) != 0) {
		uint32_t swap = fg;
		fg = bg;
		bg = swap;
	}

	flg &= WSATTR_USERMASK;

	if (rasops_isgray[fg])
		flg |= WSATTR_PRIVATE1;

	if (rasops_isgray[bg])
		flg |= WSATTR_PRIVATE2;

	*attr = (bg << 16) | (fg << 24) | flg;
	return 0;
}

/*
 * Allocate a mono attribute.
 */
static int
rasops_allocattr_mono(void *cookie, int fg0, int bg0, int flg, long *attr)
{
	uint32_t fg = fg0, bg = bg0;

	if ((flg & (WSATTR_BLINK | WSATTR_HILIT | WSATTR_WSCOLORS)) != 0)
		return EINVAL;

	fg = 1;
	bg = 0;

	if ((flg & WSATTR_REVERSE) != 0) {
		uint32_t swap = fg;
		fg = bg;
		bg = swap;
	}

	*attr = (bg << 16) | (fg << 24) | flg;
	return 0;
}

/*
 * Copy rows.
 */
static void
rasops_copyrows(void *cookie, int src, int dst, int num)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	uint8_t *sp, *dp, *hp;
	int n, stride;

	hp = NULL;	/* XXX GCC */

	if (__predict_false(dst == src))
		return;

#ifdef RASOPS_CLIPPING
	if (src < 0) {
		num += src;
		src = 0;
	}

	if (src + num > ri->ri_rows)
		num = ri->ri_rows - src;

	if (dst < 0) {
		num += dst;
		dst = 0;
	}

	if (dst + num > ri->ri_rows)
		num = ri->ri_rows - dst;

	if (num <= 0)
		return;
#endif

	num *= ri->ri_font->fontheight;
	n = ri->ri_emustride;
	stride = ri->ri_stride;

	sp = ri->ri_bits + src * ri->ri_yscale;
	dp = ri->ri_bits + dst * ri->ri_yscale;
	if (ri->ri_hwbits)
		hp = ri->ri_hwbits + dst * ri->ri_yscale;

	while (num--) {
		memcpy(dp, sp, n);
		dp += stride;
		if (ri->ri_hwbits) {
			memcpy(hp, sp, n);
			hp += stride;
		}
		sp += stride;
	}
}

/*
 * Copy columns. This is slow, and hard to optimize due to alignment,
 * and the fact that we have to copy both left->right and right->left.
 * We simply cop-out here and use memmove(), since it handles all of
 * these cases anyway.
 */
static void
rasops_copycols(void *cookie, int row, int src, int dst, int num)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	uint8_t *sp, *dp, *hp;
	int height;

	hp = NULL;	/* XXX GCC */

	if (__predict_false(dst == src))
		return;

#ifdef RASOPS_CLIPPING
	/* Catches < 0 case too */
	if ((unsigned)row >= (unsigned)ri->ri_rows)
		return;

	if (src < 0) {
		num += src;
		src = 0;
	}

	if (src + num > ri->ri_cols)
		num = ri->ri_cols - src;

	if (dst < 0) {
		num += dst;
		dst = 0;
	}

	if (dst + num > ri->ri_cols)
		num = ri->ri_cols - dst;

	if (num <= 0)
		return;
#endif

	num *= ri->ri_xscale;
	row *= ri->ri_yscale;
	height = ri->ri_font->fontheight;

	sp = ri->ri_bits + row + src * ri->ri_xscale;
	dp = ri->ri_bits + row + dst * ri->ri_xscale;
	if (ri->ri_hwbits)
		hp = ri->ri_hwbits + row + dst * ri->ri_xscale;

	while (height--) {
		memcpy(dp, sp, num);
		dp += ri->ri_stride;
		if (ri->ri_hwbits) {
			memcpy(hp, sp, num);
			hp += ri->ri_stride;
		}
		sp += ri->ri_stride;
	}
}

/*
 * Turn cursor off/on.
 */
static void
rasops_cursor(void *cookie, int on, int row, int col)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;

	/* Turn old cursor off */
	if ((ri->ri_flg & RI_CURSOR) != 0)
#ifdef RASOPS_CLIPPING
		if ((ri->ri_flg & RI_CURSORCLIP) == 0)
#endif
			ri->ri_do_cursor(ri);

	/* Select new cursor */
#ifdef RASOPS_CLIPPING
	ri->ri_flg &= ~RI_CURSORCLIP;

	if (row < 0 || row >= ri->ri_rows)
		ri->ri_flg |= RI_CURSORCLIP;
	else if (col < 0 || col >= ri->ri_cols)
		ri->ri_flg |= RI_CURSORCLIP;
#endif
	ri->ri_crow = row;
	ri->ri_ccol = col;

	if (on) {
		ri->ri_flg |= RI_CURSOR;
#ifdef RASOPS_CLIPPING
		if ((ri->ri_flg & RI_CURSORCLIP) == 0)
#endif
			ri->ri_do_cursor(ri);
	} else
		ri->ri_flg &= ~RI_CURSOR;
}

/*
 * Make the device colormap
 */
static void
rasops_init_devcmap(struct rasops_info *ri)
{
	int i;
	uint32_t c;
	const uint8_t *p;

	switch (ri->ri_depth) {
	case 1:
		ri->ri_devcmap[0] = 0;
		for (i = 1; i < 16; i++)
			ri->ri_devcmap[i] = -1;
		return;

	case 2:
		for (i = 1; i < 15; i++)
			ri->ri_devcmap[i] = 0xaaaaaaaa;

		ri->ri_devcmap[0] = 0;
		ri->ri_devcmap[8] = 0x55555555;
		ri->ri_devcmap[15] = -1;
		return;

#ifdef RASOPS_APPLE_PALETTE
	case 4:
		for (i = 0; i < 16; i++) {
			c = apple4_devcmap[i];
			ri->ri_devcmap[i] =
			    (c <<  0) | (c <<  4) | (c <<  8) | (c << 12) |
			    (c << 16) | (c << 20) | (c << 24) | (c << 28);
		}
		return;
#else
	/* XXXRO What should we do here? */
#endif

	case 8:
		if ((ri->ri_flg & RI_8BIT_IS_RGB) == 0) {
			for (i = 0; i < 16; i++) {
#ifdef RASOPS_APPLE_PALETTE
				c = apple8_devcmap[i];
#else
				c = i;
#endif
				ri->ri_devcmap[i] =
				    c | (c << 8) | (c << 16) | (c << 24);
			}
			return;
		}
	}

	p = rasops_cmap;

	for (i = 0; i < 16; i++) {
		if (ri->ri_rnum <= 8)
			c = (uint32_t)(*p >> (8 - ri->ri_rnum)) << ri->ri_rpos;
		else
			c = (uint32_t)(*p << (ri->ri_rnum - 8)) << ri->ri_rpos;
		p++;

		if (ri->ri_gnum <= 8)
			c |= (uint32_t)(*p >> (8 - ri->ri_gnum)) << ri->ri_gpos;
		else
			c |= (uint32_t)(*p << (ri->ri_gnum - 8)) << ri->ri_gpos;
		p++;

		if (ri->ri_bnum <= 8)
			c |= (uint32_t)(*p >> (8 - ri->ri_bnum)) << ri->ri_bpos;
		else
			c |= (uint32_t)(*p << (ri->ri_bnum - 8)) << ri->ri_bpos;
		p++;

		/* Fill the word for generic routines, which want this */
		if (ri->ri_depth == 8) {
			c |= c << 8;
			c |= c << 16;
		} else if (ri->ri_depth == 15 || ri->ri_depth == 16)
			c |= c << 16;
		else if (ri->ri_depth == 24) {
#if BYTE_ORDER == LITTLE_ENDIAN
#  ifndef RASOPS_SMALL
			if (ri->ri_font->fontwidth != 12)
#  endif
				c = (c & 0x0000ff) << 16 | (c & 0x00ff00) |
				    (c & 0xff0000) >> 16;
#  ifndef RASOPS_SMALL
			else
				c = (c & 0x0000ff) | (c & 0x00ff00) << 8 |
				    (c & 0xff0000) >> 8;
#  endif
#else
			/* XXXRO What should we do here? */
#endif
			c |= (c & 0xff) << 24;
		}

		/* 24bpp does bswap on the fly. {32,16,15}bpp do it here. */
		if ((ri->ri_flg & RI_BSWAP) == 0)
			ri->ri_devcmap[i] = c;
		else if (ri->ri_depth == 15 || ri->ri_depth == 16)
			ri->ri_devcmap[i] = bswap16(c);
		else if (ri->ri_depth == 32)
			ri->ri_devcmap[i] = bswap32(c);
		else /* 8, 24 */
			ri->ri_devcmap[i] = c;
	}
}

/*
 * Unpack a rasops attribute
 */
void
rasops_unpack_attr(long attr, int *fg, int *bg, int *underline)
{

	*fg = ((uint32_t)attr >> 24) & 0xf;
	*bg = ((uint32_t)attr >> 16) & 0xf;
	if (underline != NULL)
		*underline = (uint32_t)attr & WSATTR_UNDERLINE;
}

/*
 * Erase rows. This isn't static, since 24-bpp uses it in special cases.
 */
void
rasops_eraserows(void *cookie, int row, int num, long attr)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	uint32_t *rp, *dp, *hp, clr;
	int n, cnt;

	hp = NULL;	/* XXX GCC */

#ifdef RASOPS_CLIPPING
	if (row < 0) {
		num += row;
		row = 0;
	}

	if (row + num > ri->ri_rows)
		num = ri->ri_rows - row;

	if (num <= 0)
		return;
#endif

	clr = ri->ri_devcmap[((uint32_t)attr >> 16) & 0xf];

	/*
	 * XXX The wsdisplay_emulops interface seems a little deficient in
	 * that there is no way to clear the *entire* screen. We provide a
	 * workaround here: if the entire console area is being cleared, and
	 * the RI_FULLCLEAR flag is set, clear the entire display.
	 */
	if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) {
		n = ri->ri_stride >> 2;
		num = ri->ri_height;
		rp = (uint32_t *)ri->ri_origbits;
		if (ri->ri_hwbits)
			hp = (uint32_t *)ri->ri_hworigbits;
	} else {
		n = ri->ri_emustride >> 2;
		num *= ri->ri_font->fontheight;
		rp = (uint32_t *)(ri->ri_bits + row * ri->ri_yscale);
		if (ri->ri_hwbits)
			hp = (uint32_t *)(ri->ri_hwbits + row * ri->ri_yscale);
	}

	while (num--) {
		dp = rp;
		for (cnt = n; cnt; cnt--)
			*dp++ = clr;
		if (ri->ri_hwbits) {
			memcpy(hp, rp, n << 2);
			DELTA(hp, ri->ri_stride, uint32_t *);
		}
		DELTA(rp, ri->ri_stride, uint32_t *);
	}
}

/*
 * Actually turn the cursor on or off. This does the dirty work for
 * rasops_cursor().
 */
static void
rasops_do_cursor(struct rasops_info *ri)
{
	int full, height, cnt, slop1, slop2, row, col;
	uint32_t tmp32, msk1, msk2;
	uint8_t tmp8;
	uint8_t *dp, *rp, *hp;

	hp = NULL;	/* XXX GCC */

#if NRASOPS_ROTATION > 0
	if (ri->ri_flg & RI_ROTATE_MASK) {
		if (ri->ri_flg & RI_ROTATE_CW) {
			/* Rotate rows/columns */
			row = ri->ri_ccol;
			col = ri->ri_rows - ri->ri_crow - 1;
		} else if (ri->ri_flg & RI_ROTATE_CCW) {
			/* Rotate rows/columns */
			row = ri->ri_cols - ri->ri_ccol - 1;
			col = ri->ri_crow;
		} else {	/* upside-down */
			row = ri->ri_crow;
			col = ri->ri_ccol;
		}
	} else
#endif
	{
		row = ri->ri_crow;
		col = ri->ri_ccol;
	}

	rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
	if (ri->ri_hwbits)
		hp = ri->ri_hwbits + row * ri->ri_yscale + col * ri->ri_xscale;
	height = ri->ri_font->fontheight;

	/*
	 * For ri_xscale = 1:
	 *
	 * Logic below does not work for ri_xscale = 1, e.g.,
	 * fontwidth = 8 and bpp = 1. So we take care of it.
	 */
	if (ri->ri_xscale == 1) {
		while (height--) {
			tmp8 = ~*rp;

			*rp = tmp8;
			rp += ri->ri_stride;

			if (ri->ri_hwbits) {
				*hp = tmp8;
				hp += ri->ri_stride;
			}
		}
		return;
	}

	/*
	 * For ri_xscale = 2, 3, 4, ...:
	 *
	 * Note that siop1 <= ri_xscale even for ri_xscale = 2,
	 * since rp % 3 = 0 or 2 (ri_stride % 4 = 0).
	 */
	slop1 = (4 - ((uintptr_t)rp & 3)) & 3;
	slop2 = (ri->ri_xscale - slop1) & 3;
	full = (ri->ri_xscale - slop1 /* - slop2 */) >> 2;

	rp = (uint8_t *)((uintptr_t)rp & ~3);
	hp = (uint8_t *)((uintptr_t)hp & ~3);

	msk1 = !slop1 ? 0 : be32toh(0xffffffffU >> (32 - (8 * slop1)));
	msk2 = !slop2 ? 0 : be32toh(0xffffffffU << (32 - (8 * slop2)));

	while (height--) {
		dp = rp;

		if (slop1) {
			tmp32 = *(uint32_t *)dp ^ msk1;
			*(uint32_t *)dp = tmp32;
			dp += 4;
		}

		for (cnt = full; cnt; cnt--) {
			tmp32 = ~*(uint32_t *)dp;
			*(uint32_t *)dp = tmp32;
			dp += 4;
		}

		if (slop2) {
			tmp32 = *(uint32_t *)dp ^ msk2;
			*(uint32_t *)dp = tmp32;
		}

		if (ri->ri_hwbits) {
			memcpy(hp, rp, ((slop1 != 0) + full +
			    (slop2 != 0)) << 2);
			hp += ri->ri_stride;
		}
		rp += ri->ri_stride;
	}
}

/*
 * Erase columns.
 */
void
rasops_erasecols(void *cookie, int row, int col, int num, long attr)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int height, cnt, slop1, slop2, clr;
	uint32_t *rp, *dp, *hp;

	hp = NULL;	/* XXX GCC */

#ifdef RASOPS_CLIPPING
	if ((unsigned)row >= (unsigned)ri->ri_rows)
		return;

	if (col < 0) {
		num += col;
		col = 0;
	}

	if (col + num > ri->ri_cols)
		num = ri->ri_cols - col;

	if (num <= 0)
		return;
#endif

	num *= ri->ri_xscale;
	rp = (uint32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
	if (ri->ri_hwbits)
		hp = (uint32_t *)(ri->ri_hwbits + row*ri->ri_yscale +
		    col*ri->ri_xscale);
	height = ri->ri_font->fontheight;
	clr = ri->ri_devcmap[((uint32_t)attr >> 16) & 0xf];

	/* Don't bother using the full loop for <= 32 pels */
	if (num <= 32) {
		if (((num | ri->ri_xscale) & 3) == 0) {
			/* Word aligned blt */
			num >>= 2;

			while (height--) {
				dp = rp;
				for (cnt = num; cnt; cnt--)
					*dp++ = clr;
				if (ri->ri_hwbits) {
					memcpy(hp, rp, num << 2);
					DELTA(hp, ri->ri_stride, uint32_t *);
				}
				DELTA(rp, ri->ri_stride, uint32_t *);
			}
		} else if (((num | ri->ri_xscale) & 1) == 0) {
			/*
			 * Halfword aligned blt. This is needed so the
			 * 15/16 bit ops can use this function.
			 */
			num >>= 1;

			while (height--) {
				dp = rp;
				for (cnt = num; cnt; cnt--) {
					*(uint16_t *)dp = clr;
					DELTA(dp, 2, uint32_t *);
				}
				if (ri->ri_hwbits) {
					memcpy(hp, rp, num << 1);
					DELTA(hp, ri->ri_stride, uint32_t *);
				}
				DELTA(rp, ri->ri_stride, uint32_t *);
			}
		} else {
			while (height--) {
				dp = rp;
				for (cnt = num; cnt; cnt--) {
					*(uint8_t *)dp = clr;
					DELTA(dp, 1, uint32_t *);
				}
				if (ri->ri_hwbits) {
					memcpy(hp, rp, num);
					DELTA(hp, ri->ri_stride, uint32_t *);
				}
				DELTA(rp, ri->ri_stride, uint32_t *);
			}
		}

		return;
	}

	slop1 = (4 - ((uintptr_t)rp & 3)) & 3;
	slop2 = (num - slop1) & 3;
	num = (num - slop1 /* - slop2 */) >> 2;

	while (height--) {
		dp = rp;

		/* Align span to 4 bytes */
		if (slop1 & 1) {
			*(uint8_t *)dp = clr;
			DELTA(dp, 1, uint32_t *);
		}

		if (slop1 & 2) {
			*(uint16_t *)dp = clr;
			DELTA(dp, 2, uint32_t *);
		}

		/* Write 4 bytes per loop */
		for (cnt = num; cnt; cnt--)
			*dp++ = clr;

		/* Write unaligned trailing slop */
		if (slop2 & 1) {
			*(uint8_t *)dp = clr;
			DELTA(dp, 1, uint32_t *);
		}

		if (slop2 & 2)
			*(uint16_t *)dp = clr;

		if (ri->ri_hwbits) {
			memcpy(hp, rp, slop1 + (num << 2) + slop2);
			DELTA(hp, ri->ri_stride, uint32_t *);
		}
		DELTA(rp, ri->ri_stride, uint32_t *);
	}
}

#if NRASOPS_ROTATION > 0
/*
 * Quarter clockwise rotation routines (originally intended for the
 * built-in Zaurus C3x00 display in 16bpp).
 */

static void
rasops_rotate_font(int *cookie, int rotate)
{
	struct rotatedfont *f;
	int ncookie;

	SLIST_FOREACH(f, &rotatedfonts, rf_next) {
		if (f->rf_cookie == *cookie) {
			*cookie = f->rf_rotated;
			return;
		}
	}

	/*
	 * We did not find a rotated version of this font. Ask the wsfont
	 * code to compute one for us.
	 */

	f = kmem_alloc(sizeof(*f), KM_SLEEP);

	if ((ncookie = wsfont_rotate(*cookie, rotate)) == -1)
		goto fail;

	f->rf_cookie = *cookie;
	f->rf_rotated = ncookie;
	SLIST_INSERT_HEAD(&rotatedfonts, f, rf_next);

	*cookie = ncookie;
	return;

fail:	kmem_free(f, sizeof(*f));
	return;
}

static void
rasops_copychar(void *cookie, int srcrow, int dstrow, int srccol, int dstcol)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int height;
	int r_srcrow, r_dstrow, r_srccol, r_dstcol;
	uint8_t *sp, *dp;

	r_srcrow = srccol;
	r_dstrow = dstcol;
	r_srccol = ri->ri_rows - srcrow - 1;
	r_dstcol = ri->ri_rows - dstrow - 1;

	r_srcrow *= ri->ri_yscale;
	r_dstrow *= ri->ri_yscale;
	height = ri->ri_font->fontheight;

	sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale;
	dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale;

	while (height--) {
		memmove(dp, sp, ri->ri_xscale);
		dp += ri->ri_stride;
		sp += ri->ri_stride;
	}
}

static void
rasops_putchar_rotated_cw(void *cookie, int row, int col, u_int uc, long attr)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int height;
	uint8_t *rp;

	if (__predict_false((unsigned int)row > ri->ri_rows ||
	    (unsigned int)col > ri->ri_cols))
		return;

	/* Avoid underflow */
	if (ri->ri_rows - row - 1 < 0)
		return;

	/* Do rotated char sans (side)underline */
	ri->ri_real_ops.putchar(cookie, col, ri->ri_rows - row - 1, uc,
	    attr & ~WSATTR_UNDERLINE);

	/* Do rotated underline */
	rp = ri->ri_bits + col * ri->ri_yscale + (ri->ri_rows - row - 1) *
	    ri->ri_xscale;
	height = ri->ri_font->fontheight;

	/* XXX this assumes 16-bit color depth */
	if ((attr & WSATTR_UNDERLINE) != 0) {
		uint16_t c =
		    (uint16_t)ri->ri_devcmap[((uint32_t)attr >> 24) & 0xf];

		while (height--) {
			*(uint16_t *)rp = c;
			rp += ri->ri_stride;
		}
	}
}

static void
rasops_erasecols_rotated_cw(void *cookie, int row, int col, int num, long attr)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int i;

	for (i = col; i < col + num; i++)
		ri->ri_ops.putchar(cookie, row, i, ' ', attr);
}

/* XXX: these could likely be optimised somewhat. */
static void
rasops_copyrows_rotated_cw(void *cookie, int src, int dst, int num)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int col, roff;

	if (src > dst)
		for (roff = 0; roff < num; roff++)
			for (col = 0; col < ri->ri_cols; col++)
				rasops_copychar(cookie, src + roff, dst + roff,
				    col, col);
	else
		for (roff = num - 1; roff >= 0; roff--)
			for (col = 0; col < ri->ri_cols; col++)
				rasops_copychar(cookie, src + roff, dst + roff,
				    col, col);
}

static void
rasops_copycols_rotated_cw(void *cookie, int row, int src, int dst, int num)
{
	int coff;

	if (src > dst)
		for (coff = 0; coff < num; coff++)
			rasops_copychar(cookie, row, row, src + coff,
			    dst + coff);
	else
		for (coff = num - 1; coff >= 0; coff--)
			rasops_copychar(cookie, row, row, src + coff,
			    dst + coff);
}

static void
rasops_eraserows_rotated_cw(void *cookie, int row, int num, long attr)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int col, rn;

	for (rn = row; rn < row + num; rn++)
		for (col = 0; col < ri->ri_cols; col++)
			ri->ri_ops.putchar(cookie, rn, col, ' ', attr);
}

/*
 * Quarter counter-clockwise rotation routines (originally intended for the
 * built-in Sharp W-ZERO3 display in 16bpp).
 */
static void
rasops_copychar_ccw(void *cookie, int srcrow, int dstrow, int srccol,
    int dstcol)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int height, r_srcrow, r_dstrow, r_srccol, r_dstcol;
	uint8_t *sp, *dp;

	r_srcrow = ri->ri_cols - srccol - 1;
	r_dstrow = ri->ri_cols - dstcol - 1;
	r_srccol = srcrow;
	r_dstcol = dstrow;

	r_srcrow *= ri->ri_yscale;
	r_dstrow *= ri->ri_yscale;
	height = ri->ri_font->fontheight;

	sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale;
	dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale;

	while (height--) {
		memmove(dp, sp, ri->ri_xscale);
		dp += ri->ri_stride;
		sp += ri->ri_stride;
	}
}

static void
rasops_putchar_rotated_ccw(void *cookie, int row, int col, u_int uc, long attr)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int height;
	uint8_t *rp;

	if (__predict_false((unsigned int)row > ri->ri_rows ||
	    (unsigned int)col > ri->ri_cols))
		return;

	/* Avoid underflow */
	if (ri->ri_cols - col - 1 < 0)
		return;

	/* Do rotated char sans (side)underline */
	ri->ri_real_ops.putchar(cookie, ri->ri_cols - col - 1, row, uc,
	    attr & ~WSATTR_UNDERLINE);

	/* Do rotated underline */
	rp = ri->ri_bits + (ri->ri_cols - col - 1) * ri->ri_yscale +
	    row * ri->ri_xscale +
	    (ri->ri_font->fontwidth - 1) * ri->ri_pelbytes;
	height = ri->ri_font->fontheight;

	/* XXX this assumes 16-bit color depth */
	if ((attr & WSATTR_UNDERLINE) != 0) {
		uint16_t c =
		    (uint16_t)ri->ri_devcmap[((uint32_t)attr >> 24) & 0xf];

		while (height--) {
			*(uint16_t *)rp = c;
			rp += ri->ri_stride;
		}
	}
}

/* XXX: these could likely be optimised somewhat. */
static void
rasops_copyrows_rotated_ccw(void *cookie, int src, int dst, int num)
{
	struct rasops_info *ri = (struct rasops_info *)cookie;
	int col, roff;

	if (src > dst)
		for (roff = 0; roff < num; roff++)
			for (col = 0; col < ri->ri_cols; col++)
				rasops_copychar_ccw(cookie,
				    src + roff, dst + roff, col, col);
	else
		for (roff = num - 1; roff >= 0; roff--)
			for (col = 0; col < ri->ri_cols; col++)
				rasops_copychar_ccw(cookie,
				    src + roff, dst + roff, col, col);
}

static void
rasops_copycols_rotated_ccw(void *cookie, int row, int src, int dst, int num)
{
	int coff;

	if (src > dst)
		for (coff = 0; coff < num; coff++)
			rasops_copychar_ccw(cookie, row, row,
			    src + coff, dst + coff);
	else
		for (coff = num - 1; coff >= 0; coff--)
			rasops_copychar_ccw(cookie, row, row,
			    src + coff, dst + coff);
}
#endif	/* NRASOPS_ROTATION */

void
rasops_make_box_chars_16(struct rasops_info *ri)
{
	int c, i, mid;
	uint16_t vert_mask, hmask_left, hmask_right;
	uint16_t *data = (uint16_t *)ri->ri_optfont.data;

	vert_mask = 0xc000U >> ((ri->ri_font->fontwidth >> 1) - 1);
	hmask_left = 0xff00U << (8 - (ri->ri_font->fontwidth >> 1));
	hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1);
	mid = (ri->ri_font->fontheight + 1) >> 1;

	/* 0x00 would be empty anyway so don't bother */
	for (c = 1; c < 16; c++) {
		data += ri->ri_font->fontheight;
		if (c & 1) {
			/* upper segment */
			for (i = 0; i < mid; i++)
				data[i] = vert_mask;
		}
		if (c & 4) {
			/* lower segment */
			for (i = mid; i < ri->ri_font->fontheight; i++)
				data[i] = vert_mask;
		}
		if (c & 2) {
			/* right segment */
			i = ri->ri_font->fontheight >> 1;
			data[mid - 1] |= hmask_right;
			data[mid] |= hmask_right;
		}
		if (c & 8) {
			/* left segment */
			data[mid - 1] |= hmask_left;
			data[mid] |= hmask_left;
		}
	}
}

void
rasops_make_box_chars_8(struct rasops_info *ri)
{
	int c, i, mid;
	uint8_t vert_mask, hmask_left, hmask_right;
	uint8_t *data = (uint8_t *)ri->ri_optfont.data;

	vert_mask = 0xc0U >> ((ri->ri_font->fontwidth >> 1) - 1);
	hmask_left = 0xf0U << (4 - (ri->ri_font->fontwidth >> 1));
	hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1);
	mid = (ri->ri_font->fontheight + 1) >> 1;

	/* 0x00 would be empty anyway so don't bother */
	for (c = 1; c < 16; c++) {
		data += ri->ri_font->fontheight;
		if (c & 1) {
			/* upper segment */
			for (i = 0; i < mid; i++)
				data[i] = vert_mask;
		}
		if (c & 4) {
			/* lower segment */
			for (i = mid; i < ri->ri_font->fontheight; i++)
				data[i] = vert_mask;
		}
		if (c & 2) {
			/* right segment */
			i = ri->ri_font->fontheight >> 1;
			data[mid - 1] |= hmask_right;
			data[mid] |= hmask_right;
		}
		if (c & 8) {
			/* left segment */
			data[mid - 1] |= hmask_left;
			data[mid] |= hmask_left;
		}
	}
}

void
rasops_make_box_chars_32(struct rasops_info *ri)
{
	int c, i, mid;
	uint32_t vert_mask, hmask_left, hmask_right;
	uint32_t *data = (uint32_t *)ri->ri_optfont.data;

	vert_mask = 0xc0000000U >> ((ri->ri_font->fontwidth >> 1) - 1);
	hmask_left = 0xffff0000U << (16 - (ri->ri_font->fontwidth >> 1));
	hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1);
	mid = (ri->ri_font->fontheight + 1) >> 1;

	/* 0x00 would be empty anyway so don't bother */
	for (c = 1; c < 16; c++) {
		data += ri->ri_font->fontheight;
		if (c & 1) {
			/* upper segment */
			for (i = 0; i < mid; i++)
				data[i] = vert_mask;
		}
		if (c & 4) {
			/* lower segment */
			for (i = mid; i < ri->ri_font->fontheight; i++)
				data[i] = vert_mask;
		}
		if (c & 2) {
			/* right segment */
			i = ri->ri_font->fontheight >> 1;
			data[mid - 1] |= hmask_right;
			data[mid] |= hmask_right;
		}
		if (c & 8) {
			/* left segment */
			data[mid - 1] |= hmask_left;
			data[mid] |= hmask_left;
		}
	}
}

void
rasops_make_box_chars_alpha(struct rasops_info *ri)
{
	int c, i, hmid, vmid, wi, he;
	uint8_t *data = (uint8_t *)ri->ri_optfont.data;
	uint8_t *ddata;

	he = ri->ri_font->fontheight;
	wi = ri->ri_font->fontwidth;

	vmid = (he + 1) >> 1;
	hmid = (wi + 1) >> 1;

	/* 0x00 would be empty anyway so don't bother */
	for (c = 1; c < 16; c++) {
		data += ri->ri_fontscale;
		if (c & 1) {
			/* upper segment */
			ddata = data + hmid;
			for (i = 0; i <= vmid; i++) {
				*ddata = 0xff;
				ddata += wi;
			}
		}
		if (c & 4) {
			/* lower segment */
			ddata = data + wi * vmid + hmid;
			for (i = vmid; i < he; i++) {
				*ddata = 0xff;
				ddata += wi;
			}
		}
		if (c & 2) {
			/* right segment */
			ddata = data + wi * vmid + hmid;
			for (i = hmid; i < wi; i++) {
				*ddata = 0xff;
				ddata++;
			}
		}
		if (c & 8) {
			/* left segment */
			ddata = data + wi * vmid;
			for (i = 0; i <= hmid; i++) {
				*ddata = 0xff;
				ddata++;
			}
		}
	}
}

/*
 * Return a colour map appropriate for the given struct rasops_info in the
 * same form used by rasops_cmap[]
 * For now this is either a copy of rasops_cmap[] or an R3G3B2 map, it should
 * probably be a linear ( or gamma corrected? ) ramp for higher depths.
 */

int
rasops_get_cmap(struct rasops_info *ri, uint8_t *palette, size_t bytes)
{

	if ((ri->ri_depth == 8) && ((ri->ri_flg & RI_8BIT_IS_RGB) != 0)) {
		/* generate an R3G3B2 palette */
		int i, idx = 0;
		uint8_t tmp;

		if (bytes < 768)
			return EINVAL;
		for (i = 0; i < 256; i++) {
			tmp = i & 0xe0;
			/*
			 * replicate bits so 0xe0 maps to a red value of 0xff
			 * in order to make white look actually white
			 */
			tmp |= (tmp >> 3) | (tmp >> 6);
			palette[idx] = tmp;
			idx++;

			tmp = (i & 0x1c) << 3;
			tmp |= (tmp >> 3) | (tmp >> 6);
			palette[idx] = tmp;
			idx++;

			tmp = (i & 0x03) << 6;
			tmp |= tmp >> 2;
			tmp |= tmp >> 4;
			palette[idx] = tmp;
			idx++;
		}
	} else
		memcpy(palette, rasops_cmap, uimin(bytes, sizeof(rasops_cmap)));
	return 0;
}