Home | History | Annotate | Line # | Download | only in rasops
rasops.c revision 1.56
      1  1.56       mjf /*	 $NetBSD: rasops.c,v 1.56 2007/07/28 20:28:57 mjf Exp $	*/
      2   1.1        ad 
      3   1.9        ad /*-
      4   1.9        ad  * Copyright (c) 1999 The NetBSD Foundation, Inc.
      5   1.1        ad  * All rights reserved.
      6   1.1        ad  *
      7   1.9        ad  * This code is derived from software contributed to The NetBSD Foundation
      8  1.32        ad  * by Andrew Doran.
      9   1.9        ad  *
     10   1.1        ad  * Redistribution and use in source and binary forms, with or without
     11   1.1        ad  * modification, are permitted provided that the following conditions
     12   1.1        ad  * are met:
     13   1.1        ad  * 1. Redistributions of source code must retain the above copyright
     14   1.1        ad  *    notice, this list of conditions and the following disclaimer.
     15   1.1        ad  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1        ad  *    notice, this list of conditions and the following disclaimer in the
     17   1.1        ad  *    documentation and/or other materials provided with the distribution.
     18   1.9        ad  * 3. All advertising materials mentioning features or use of this software
     19   1.9        ad  *    must display the following acknowledgement:
     20   1.9        ad  *	This product includes software developed by the NetBSD
     21   1.9        ad  *	Foundation, Inc. and its contributors.
     22   1.9        ad  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23   1.9        ad  *    contributors may be used to endorse or promote products derived
     24   1.9        ad  *    from this software without specific prior written permission.
     25   1.1        ad  *
     26   1.9        ad  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27   1.9        ad  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28   1.9        ad  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29   1.9        ad  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30   1.9        ad  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31   1.9        ad  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32   1.9        ad  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33   1.9        ad  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34   1.9        ad  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35   1.9        ad  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36   1.9        ad  * POSSIBILITY OF SUCH DAMAGE.
     37   1.1        ad  */
     38   1.2        ad 
     39   1.1        ad #include <sys/cdefs.h>
     40  1.56       mjf __KERNEL_RCSID(0, "$NetBSD: rasops.c,v 1.56 2007/07/28 20:28:57 mjf Exp $");
     41   1.1        ad 
     42  1.18        ad #include "opt_rasops.h"
     43   1.4        ad #include "rasops_glue.h"
     44  1.47  macallan #include "opt_wsmsgattrs.h"
     45   1.1        ad 
     46   1.1        ad #include <sys/param.h>
     47   1.1        ad #include <sys/systm.h>
     48   1.1        ad #include <sys/time.h>
     49   1.1        ad 
     50  1.50       dsl #include <sys/bswap.h>
     51   1.4        ad #include <machine/endian.h>
     52   1.3        ad 
     53   1.1        ad #include <dev/wscons/wsdisplayvar.h>
     54   1.1        ad #include <dev/wscons/wsconsio.h>
     55   1.1        ad #include <dev/wsfont/wsfont.h>
     56   1.1        ad #include <dev/rasops/rasops.h>
     57   1.1        ad 
     58  1.11        ad #ifndef _KERNEL
     59  1.11        ad #include <errno.h>
     60  1.11        ad #endif
     61  1.11        ad 
     62   1.1        ad /* ANSI colormap (R,G,B). Upper 8 are high-intensity */
     63  1.23  drochner const u_char rasops_cmap[256*3] = {
     64   1.1        ad 	0x00, 0x00, 0x00, /* black */
     65   1.1        ad 	0x7f, 0x00, 0x00, /* red */
     66   1.1        ad 	0x00, 0x7f, 0x00, /* green */
     67   1.1        ad 	0x7f, 0x7f, 0x00, /* brown */
     68   1.1        ad 	0x00, 0x00, 0x7f, /* blue */
     69   1.1        ad 	0x7f, 0x00, 0x7f, /* magenta */
     70   1.1        ad 	0x00, 0x7f, 0x7f, /* cyan */
     71   1.1        ad 	0xc7, 0xc7, 0xc7, /* white - XXX too dim? */
     72   1.1        ad 
     73   1.1        ad 	0x7f, 0x7f, 0x7f, /* black */
     74   1.1        ad 	0xff, 0x00, 0x00, /* red */
     75   1.1        ad 	0x00, 0xff, 0x00, /* green */
     76   1.1        ad 	0xff, 0xff, 0x00, /* brown */
     77   1.1        ad 	0x00, 0x00, 0xff, /* blue */
     78   1.1        ad 	0xff, 0x00, 0xff, /* magenta */
     79   1.1        ad 	0x00, 0xff, 0xff, /* cyan */
     80   1.1        ad 	0xff, 0xff, 0xff, /* white */
     81  1.23  drochner 
     82  1.23  drochner 	/*
     83  1.23  drochner 	 * For the cursor, we need at least the last (255th)
     84  1.23  drochner 	 * color to be white. Fill up white completely for
     85  1.23  drochner 	 * simplicity.
     86  1.23  drochner 	 */
     87  1.23  drochner #define _CMWHITE 0xff, 0xff, 0xff,
     88  1.23  drochner #define _CMWHITE16	_CMWHITE _CMWHITE _CMWHITE _CMWHITE \
     89  1.23  drochner 			_CMWHITE _CMWHITE _CMWHITE _CMWHITE \
     90  1.23  drochner 			_CMWHITE _CMWHITE _CMWHITE _CMWHITE \
     91  1.23  drochner 			_CMWHITE _CMWHITE _CMWHITE _CMWHITE
     92  1.23  drochner 	_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
     93  1.23  drochner 	_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
     94  1.44       uwe 	_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 /* but not the last one */
     95  1.23  drochner #undef _CMWHITE16
     96  1.23  drochner #undef _CMWHITE
     97  1.44       uwe 
     98  1.44       uwe 	/*
     99  1.44       uwe 	 * For the cursor the fg/bg indices are bit inverted, so
    100  1.44       uwe 	 * provide complimentary colors in the upper 16 entries.
    101  1.44       uwe 	 */
    102  1.44       uwe 	0x7f, 0x7f, 0x7f, /* black */
    103  1.44       uwe 	0xff, 0x00, 0x00, /* red */
    104  1.44       uwe 	0x00, 0xff, 0x00, /* green */
    105  1.44       uwe 	0xff, 0xff, 0x00, /* brown */
    106  1.44       uwe 	0x00, 0x00, 0xff, /* blue */
    107  1.44       uwe 	0xff, 0x00, 0xff, /* magenta */
    108  1.44       uwe 	0x00, 0xff, 0xff, /* cyan */
    109  1.44       uwe 	0xff, 0xff, 0xff, /* white */
    110  1.44       uwe 
    111  1.44       uwe 	0x00, 0x00, 0x00, /* black */
    112  1.44       uwe 	0x7f, 0x00, 0x00, /* red */
    113  1.44       uwe 	0x00, 0x7f, 0x00, /* green */
    114  1.44       uwe 	0x7f, 0x7f, 0x00, /* brown */
    115  1.44       uwe 	0x00, 0x00, 0x7f, /* blue */
    116  1.44       uwe 	0x7f, 0x00, 0x7f, /* magenta */
    117  1.44       uwe 	0x00, 0x7f, 0x7f, /* cyan */
    118  1.44       uwe 	0xc7, 0xc7, 0xc7, /* white - XXX too dim? */
    119   1.1        ad };
    120   1.1        ad 
    121   1.1        ad /* True if color is gray */
    122  1.30        pk const u_char rasops_isgray[16] = {
    123  1.30        pk 	1, 0, 0, 0,
    124   1.1        ad 	0, 0, 0, 1,
    125   1.1        ad 	1, 0, 0, 0,
    126   1.1        ad 	0, 0, 0, 1
    127   1.1        ad };
    128   1.1        ad 
    129   1.4        ad /* Generic functions */
    130  1.45     perry static void	rasops_copyrows(void *, int, int, int);
    131  1.45     perry static int	rasops_mapchar(void *, int, u_int *);
    132  1.45     perry static void	rasops_cursor(void *, int, int, int);
    133  1.45     perry static int	rasops_allocattr_color(void *, int, int, int, long *);
    134  1.45     perry static int	rasops_allocattr_mono(void *, int, int, int, long *);
    135  1.45     perry static void	rasops_do_cursor(struct rasops_info *);
    136  1.45     perry static void	rasops_init_devcmap(struct rasops_info *);
    137   1.1        ad 
    138  1.55      ober #if NRASOPS_ROTATION > 0
    139  1.55      ober static void	rasops_copychar(void *, int, int, int, int);
    140  1.55      ober static void	rasops_copycols_rotated(void *, int, int, int, int);
    141  1.55      ober static void	rasops_copyrows_rotated(void *, int, int, int);
    142  1.55      ober static void	rasops_erasecols_rotated(void *, int, int, int, long);
    143  1.55      ober static void	rasops_eraserows_rotated(void *, int, int, long);
    144  1.55      ober static void	rasops_putchar_rotated(void *, int, int, u_int, long);
    145  1.55      ober static void	rasops_rotate_font(int *);
    146  1.55      ober 
    147  1.55      ober /*
    148  1.55      ober  * List of all rotated fonts
    149  1.55      ober  */
    150  1.55      ober SLIST_HEAD(, rotatedfont) rotatedfonts = SLIST_HEAD_INITIALIZER(rotatedfonts);
    151  1.55      ober struct rotatedfont {
    152  1.55      ober 	SLIST_ENTRY(rotatedfont) rf_next;
    153  1.55      ober 	int rf_cookie;
    154  1.55      ober 	int rf_rotated;
    155  1.55      ober };
    156  1.55      ober #endif	/* NRASOPS_ROTATION > 0 */
    157  1.55      ober 
    158   1.1        ad /*
    159  1.37       wiz  * Initialize a 'rasops_info' descriptor.
    160   1.1        ad  */
    161   1.1        ad int
    162  1.13        ad rasops_init(ri, wantrows, wantcols)
    163   1.1        ad 	struct rasops_info *ri;
    164  1.13        ad 	int wantrows, wantcols;
    165   1.1        ad {
    166  1.20        ad 
    167  1.30        pk #ifdef _KERNEL
    168   1.1        ad 	/* Select a font if the caller doesn't care */
    169   1.1        ad 	if (ri->ri_font == NULL) {
    170   1.1        ad 		int cookie;
    171  1.30        pk 
    172   1.1        ad 		wsfont_init();
    173   1.1        ad 
    174   1.1        ad 		/* Want 8 pixel wide, don't care about aestethics */
    175  1.39        ad 		cookie = wsfont_find(NULL, 8, 0, 0, WSDISPLAY_FONTORDER_L2R,
    176  1.39        ad 		    WSDISPLAY_FONTORDER_L2R);
    177  1.39        ad 		if (cookie <= 0)
    178  1.39        ad 			cookie = wsfont_find(NULL, 0, 0, 0,
    179  1.39        ad 			    WSDISPLAY_FONTORDER_L2R, WSDISPLAY_FONTORDER_L2R);
    180   1.1        ad 
    181   1.7        ad 		if (cookie <= 0) {
    182   1.1        ad 			printf("rasops_init: font table is empty\n");
    183   1.1        ad 			return (-1);
    184   1.1        ad 		}
    185  1.30        pk 
    186  1.55      ober #if NRASOPS_ROTATION > 0
    187  1.55      ober 		/*
    188  1.55      ober 		 * Pick the rotated version of this font. This will create it
    189  1.55      ober 		 * if necessary.
    190  1.55      ober 		 */
    191  1.55      ober 		if (ri->ri_flg & RI_ROTATE_CW)
    192  1.55      ober 			rasops_rotate_font(&cookie);
    193  1.55      ober #endif
    194  1.55      ober 
    195  1.39        ad 		if (wsfont_lock(cookie, &ri->ri_font)) {
    196   1.1        ad 			printf("rasops_init: couldn't lock font\n");
    197   1.1        ad 			return (-1);
    198   1.1        ad 		}
    199   1.8        ad 
    200   1.5        ad 		ri->ri_wsfcookie = cookie;
    201   1.1        ad 	}
    202   1.4        ad #endif
    203  1.30        pk 
    204   1.1        ad 	/* This should never happen in reality... */
    205   1.1        ad #ifdef DEBUG
    206  1.31  sommerfe 	if ((long)ri->ri_bits & 3) {
    207   1.1        ad 		printf("rasops_init: bits not aligned on 32-bit boundary\n");
    208   1.1        ad 		return (-1);
    209   1.1        ad 	}
    210   1.1        ad 
    211   1.1        ad 	if ((int)ri->ri_stride & 3) {
    212   1.1        ad 		printf("rasops_init: stride not aligned on 32-bit boundary\n");
    213   1.1        ad 		return (-1);
    214   1.1        ad 	}
    215   1.1        ad #endif
    216   1.4        ad 
    217  1.13        ad 	if (rasops_reconfig(ri, wantrows, wantcols))
    218   1.4        ad 		return (-1);
    219  1.46     perry 
    220   1.4        ad 	rasops_init_devcmap(ri);
    221   1.4        ad 	return (0);
    222   1.4        ad }
    223   1.4        ad 
    224   1.4        ad /*
    225  1.13        ad  * Reconfigure (because parameters have changed in some way).
    226   1.4        ad  */
    227   1.4        ad int
    228  1.13        ad rasops_reconfig(ri, wantrows, wantcols)
    229   1.4        ad 	struct rasops_info *ri;
    230  1.13        ad 	int wantrows, wantcols;
    231   1.4        ad {
    232  1.20        ad 	int bpp, s;
    233  1.30        pk 
    234  1.13        ad 	s = splhigh();
    235  1.30        pk 
    236   1.4        ad 	if (ri->ri_font->fontwidth > 32 || ri->ri_font->fontwidth < 4)
    237  1.42    provos 		panic("rasops_init: fontwidth assumptions botched!");
    238  1.30        pk 
    239   1.4        ad 	/* Need this to frob the setup below */
    240   1.4        ad 	bpp = (ri->ri_depth == 15 ? 16 : ri->ri_depth);
    241   1.4        ad 
    242  1.13        ad 	if ((ri->ri_flg & RI_CFGDONE) != 0)
    243   1.4        ad 		ri->ri_bits = ri->ri_origbits;
    244  1.30        pk 
    245   1.1        ad 	/* Don't care if the caller wants a hideously small console */
    246   1.1        ad 	if (wantrows < 10)
    247  1.13        ad 		wantrows = 10;
    248  1.30        pk 
    249   1.1        ad 	if (wantcols < 20)
    250  1.13        ad 		wantcols = 20;
    251  1.30        pk 
    252   1.1        ad 	/* Now constrain what they get */
    253   1.1        ad 	ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols;
    254   1.1        ad 	ri->ri_emuheight = ri->ri_font->fontheight * wantrows;
    255  1.30        pk 
    256   1.1        ad 	if (ri->ri_emuwidth > ri->ri_width)
    257   1.1        ad 		ri->ri_emuwidth = ri->ri_width;
    258  1.30        pk 
    259   1.1        ad 	if (ri->ri_emuheight > ri->ri_height)
    260   1.1        ad 		ri->ri_emuheight = ri->ri_height;
    261  1.30        pk 
    262   1.1        ad 	/* Reduce width until aligned on a 32-bit boundary */
    263  1.20        ad 	while ((ri->ri_emuwidth * bpp & 31) != 0)
    264   1.1        ad 		ri->ri_emuwidth--;
    265  1.30        pk 
    266  1.55      ober #if NRASOPS_ROTATION > 0
    267  1.55      ober 	if (ri->ri_flg & RI_ROTATE_CW) {
    268  1.55      ober 		ri->ri_rows = ri->ri_emuwidth / ri->ri_font->fontwidth;
    269  1.55      ober 		ri->ri_cols = ri->ri_emuheight / ri->ri_font->fontheight;
    270  1.55      ober 	} else
    271  1.55      ober #endif
    272  1.55      ober 	{
    273  1.55      ober 
    274  1.55      ober 		ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth;
    275  1.55      ober 		ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight;
    276  1.55      ober 	}
    277   1.4        ad 	ri->ri_emustride = ri->ri_emuwidth * bpp >> 3;
    278   1.1        ad 	ri->ri_delta = ri->ri_stride - ri->ri_emustride;
    279   1.1        ad 	ri->ri_ccol = 0;
    280   1.1        ad 	ri->ri_crow = 0;
    281   1.4        ad 	ri->ri_pelbytes = bpp >> 3;
    282  1.30        pk 
    283   1.4        ad 	ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3;
    284   1.1        ad 	ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride;
    285   1.1        ad 	ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride;
    286   1.1        ad 
    287  1.30        pk #ifdef DEBUG
    288  1.18        ad 	if ((ri->ri_delta & 3) != 0)
    289  1.13        ad 		panic("rasops_init: ri_delta not aligned on 32-bit boundary");
    290  1.30        pk #endif
    291   1.1        ad 	/* Clear the entire display */
    292  1.13        ad 	if ((ri->ri_flg & RI_CLEAR) != 0)
    293  1.13        ad 		memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);
    294  1.30        pk 
    295  1.30        pk 	/* Now centre our window if needs be */
    296   1.1        ad 	ri->ri_origbits = ri->ri_bits;
    297  1.30        pk 
    298  1.13        ad 	if ((ri->ri_flg & RI_CENTER) != 0) {
    299  1.46     perry 		ri->ri_bits += (((ri->ri_width * bpp >> 3) -
    300  1.36   nathanw 		    ri->ri_emustride) >> 1) & ~3;
    301  1.30        pk 		ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
    302   1.1        ad 		    ri->ri_stride;
    303  1.30        pk 
    304  1.30        pk 		ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits)
    305   1.5        ad 		   / ri->ri_stride;
    306  1.30        pk 		ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits)
    307  1.28   nathanw 		   % ri->ri_stride) * 8 / bpp);
    308   1.5        ad 	} else
    309   1.5        ad 		ri->ri_xorigin = ri->ri_yorigin = 0;
    310   1.4        ad 
    311  1.30        pk 	/*
    312   1.4        ad 	 * Fill in defaults for operations set.  XXX this nukes private
    313   1.4        ad 	 * routines used by accelerated fb drivers.
    314   1.4        ad 	 */
    315   1.1        ad 	ri->ri_ops.mapchar = rasops_mapchar;
    316   1.1        ad 	ri->ri_ops.copyrows = rasops_copyrows;
    317   1.1        ad 	ri->ri_ops.copycols = rasops_copycols;
    318   1.4        ad 	ri->ri_ops.erasecols = rasops_erasecols;
    319   1.4        ad 	ri->ri_ops.eraserows = rasops_eraserows;
    320   1.1        ad 	ri->ri_ops.cursor = rasops_cursor;
    321   1.4        ad 	ri->ri_do_cursor = rasops_do_cursor;
    322  1.30        pk 
    323  1.13        ad 	if (ri->ri_depth < 8 || (ri->ri_flg & RI_FORCEMONO) != 0) {
    324  1.41  junyoung 		ri->ri_ops.allocattr = rasops_allocattr_mono;
    325  1.24  drochner 		ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_REVERSE;
    326   1.4        ad 	} else {
    327  1.41  junyoung 		ri->ri_ops.allocattr = rasops_allocattr_color;
    328  1.30        pk 		ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_HILIT |
    329  1.24  drochner 		    WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
    330   1.4        ad 	}
    331   1.4        ad 
    332   1.1        ad 	switch (ri->ri_depth) {
    333  1.20        ad #if NRASOPS1 > 0
    334   1.1        ad 	case 1:
    335   1.1        ad 		rasops1_init(ri);
    336   1.1        ad 		break;
    337   1.1        ad #endif
    338  1.20        ad #if NRASOPS2 > 0
    339   1.4        ad 	case 2:
    340   1.4        ad 		rasops2_init(ri);
    341  1.34  takemura 		break;
    342  1.34  takemura #endif
    343  1.34  takemura #if NRASOPS4 > 0
    344  1.34  takemura 	case 4:
    345  1.34  takemura 		rasops4_init(ri);
    346   1.4        ad 		break;
    347   1.4        ad #endif
    348  1.20        ad #if NRASOPS8 > 0
    349   1.1        ad 	case 8:
    350   1.1        ad 		rasops8_init(ri);
    351   1.1        ad 		break;
    352   1.1        ad #endif
    353  1.20        ad #if NRASOPS15 > 0 || NRASOPS16 > 0
    354   1.1        ad 	case 15:
    355   1.1        ad 	case 16:
    356   1.1        ad 		rasops15_init(ri);
    357   1.1        ad 		break;
    358   1.1        ad #endif
    359  1.20        ad #if NRASOPS24 > 0
    360   1.1        ad 	case 24:
    361   1.1        ad 		rasops24_init(ri);
    362   1.1        ad 		break;
    363   1.1        ad #endif
    364  1.20        ad #if NRASOPS32 > 0
    365   1.1        ad 	case 32:
    366   1.1        ad 		rasops32_init(ri);
    367   1.1        ad 		break;
    368   1.1        ad #endif
    369   1.1        ad 	default:
    370  1.13        ad 		ri->ri_flg &= ~RI_CFGDONE;
    371  1.13        ad 		splx(s);
    372   1.1        ad 		return (-1);
    373   1.1        ad 	}
    374  1.30        pk 
    375  1.55      ober #if NRASOPS_ROTATION > 0
    376  1.55      ober 	if (ri->ri_flg & RI_ROTATE_CW) {
    377  1.55      ober 		ri->ri_real_ops = ri->ri_ops;
    378  1.55      ober 		ri->ri_ops.copycols = rasops_copycols_rotated;
    379  1.55      ober 		ri->ri_ops.copyrows = rasops_copyrows_rotated;
    380  1.55      ober 		ri->ri_ops.erasecols = rasops_erasecols_rotated;
    381  1.55      ober 		ri->ri_ops.eraserows = rasops_eraserows_rotated;
    382  1.55      ober 		ri->ri_ops.putchar = rasops_putchar_rotated;
    383  1.55      ober 	}
    384  1.55      ober #endif
    385  1.55      ober 
    386  1.13        ad 	ri->ri_flg |= RI_CFGDONE;
    387  1.13        ad 	splx(s);
    388   1.1        ad 	return (0);
    389   1.1        ad }
    390   1.1        ad 
    391   1.1        ad /*
    392   1.1        ad  * Map a character.
    393   1.1        ad  */
    394   1.1        ad static int
    395   1.1        ad rasops_mapchar(cookie, c, cp)
    396   1.1        ad 	void *cookie;
    397   1.1        ad 	int c;
    398   1.1        ad 	u_int *cp;
    399   1.1        ad {
    400   1.1        ad 	struct rasops_info *ri;
    401  1.30        pk 
    402   1.1        ad 	ri = (struct rasops_info *)cookie;
    403   1.8        ad 
    404  1.30        pk #ifdef DIAGNOSTIC
    405   1.8        ad 	if (ri->ri_font == NULL)
    406  1.42    provos 		panic("rasops_mapchar: no font selected");
    407  1.30        pk #endif
    408  1.39        ad 
    409  1.35    marcus 	if (ri->ri_font->encoding != WSDISPLAY_FONTENC_ISO) {
    410  1.35    marcus 		if ( (c = wsfont_map_unichar(ri->ri_font, c)) < 0) {
    411  1.35    marcus 			*cp = ' ';
    412  1.35    marcus 			return (0);
    413  1.35    marcus 
    414  1.35    marcus 		}
    415  1.35    marcus 	}
    416  1.30        pk 
    417   1.1        ad 	if (c < ri->ri_font->firstchar) {
    418   1.1        ad 		*cp = ' ';
    419   1.1        ad 		return (0);
    420   1.1        ad 	}
    421  1.30        pk 
    422   1.1        ad 	if (c - ri->ri_font->firstchar >= ri->ri_font->numchars) {
    423   1.1        ad 		*cp = ' ';
    424   1.1        ad 		return (0);
    425   1.1        ad 	}
    426  1.30        pk 
    427   1.1        ad 	*cp = c;
    428   1.1        ad 	return (5);
    429   1.1        ad }
    430   1.1        ad 
    431   1.1        ad /*
    432   1.1        ad  * Allocate a color attribute.
    433   1.1        ad  */
    434   1.1        ad static int
    435  1.54  christos rasops_allocattr_color(void *cookie, int fg, int bg, int flg,
    436  1.53  christos     long *attr)
    437   1.1        ad {
    438   1.1        ad 	int swap;
    439   1.1        ad 
    440  1.56       mjf 	if (__predict_false((unsigned int)fg >= sizeof(rasops_isgray) ||
    441  1.56       mjf 	    (unsigned int)bg >= sizeof(rasops_isgray)))
    442  1.56       mjf 		return (EINVAL);
    443  1.56       mjf 
    444   1.1        ad #ifdef RASOPS_CLIPPING
    445   1.1        ad 	fg &= 7;
    446   1.1        ad 	bg &= 7;
    447   1.1        ad #endif
    448  1.17        ad 	if ((flg & WSATTR_BLINK) != 0)
    449   1.1        ad 		return (EINVAL);
    450  1.23  drochner 
    451  1.23  drochner 	if ((flg & WSATTR_WSCOLORS) == 0) {
    452  1.48  macallan #ifdef WS_DEFAULT_FG
    453  1.48  macallan 		fg = WS_DEFAULT_FG;
    454  1.48  macallan #else
    455  1.48  macallan 		fg = WSCOL_WHITE;
    456  1.48  macallan #endif
    457  1.48  macallan #ifdef WS_DEFAULT_BG
    458  1.48  macallan 		bg = WS_DEFAULT_BG;
    459  1.48  macallan #else
    460  1.48  macallan 		bg = WSCOL_BLACK;
    461  1.48  macallan #endif
    462  1.23  drochner 	}
    463  1.23  drochner 
    464  1.17        ad 	if ((flg & WSATTR_REVERSE) != 0) {
    465   1.1        ad 		swap = fg;
    466   1.1        ad 		fg = bg;
    467   1.1        ad 		bg = swap;
    468   1.1        ad 	}
    469   1.1        ad 
    470  1.17        ad 	if ((flg & WSATTR_HILIT) != 0)
    471   1.1        ad 		fg += 8;
    472  1.30        pk 
    473   1.1        ad 	flg = ((flg & WSATTR_UNDERLINE) ? 1 : 0);
    474  1.30        pk 
    475   1.1        ad 	if (rasops_isgray[fg])
    476   1.1        ad 		flg |= 2;
    477   1.1        ad 
    478   1.1        ad 	if (rasops_isgray[bg])
    479   1.1        ad 		flg |= 4;
    480   1.1        ad 
    481   1.1        ad 	*attr = (bg << 16) | (fg << 24) | flg;
    482  1.17        ad 	return (0);
    483   1.1        ad }
    484   1.1        ad 
    485   1.1        ad /*
    486   1.1        ad  * Allocate a mono attribute.
    487   1.1        ad  */
    488   1.1        ad static int
    489  1.54  christos rasops_allocattr_mono(void *cookie, int fg, int bg, int flg,
    490  1.53  christos     long *attr)
    491   1.1        ad {
    492   1.1        ad 	int swap;
    493   1.1        ad 
    494  1.23  drochner 	if ((flg & (WSATTR_BLINK | WSATTR_HILIT | WSATTR_WSCOLORS)) != 0)
    495   1.1        ad 		return (EINVAL);
    496  1.23  drochner 
    497  1.23  drochner 	fg = 1;
    498  1.23  drochner 	bg = 0;
    499  1.23  drochner 
    500  1.17        ad 	if ((flg & WSATTR_REVERSE) != 0) {
    501   1.1        ad 		swap = fg;
    502   1.1        ad 		fg = bg;
    503   1.1        ad 		bg = swap;
    504   1.1        ad 	}
    505   1.1        ad 
    506   1.1        ad 	*attr = (bg << 16) | (fg << 24) | ((flg & WSATTR_UNDERLINE) ? 7 : 6);
    507  1.17        ad 	return (0);
    508   1.1        ad }
    509   1.1        ad 
    510   1.1        ad /*
    511   1.1        ad  * Copy rows.
    512   1.1        ad  */
    513   1.1        ad static void
    514   1.1        ad rasops_copyrows(cookie, src, dst, num)
    515   1.1        ad 	void *cookie;
    516   1.1        ad 	int src, dst, num;
    517   1.1        ad {
    518  1.51  jmcneill 	int32_t *sp, *dp, *hp, *srp, *drp, *hrp;
    519   1.1        ad 	struct rasops_info *ri;
    520  1.18        ad 	int n8, n1, cnt, delta;
    521  1.30        pk 
    522   1.1        ad 	ri = (struct rasops_info *)cookie;
    523  1.51  jmcneill 	hp = hrp = NULL;
    524   1.1        ad 
    525   1.1        ad #ifdef RASOPS_CLIPPING
    526   1.1        ad 	if (dst == src)
    527   1.1        ad 		return;
    528  1.30        pk 
    529   1.1        ad 	if (src < 0) {
    530   1.1        ad 		num += src;
    531   1.1        ad 		src = 0;
    532   1.1        ad 	}
    533   1.1        ad 
    534   1.1        ad 	if ((src + num) > ri->ri_rows)
    535   1.1        ad 		num = ri->ri_rows - src;
    536   1.1        ad 
    537   1.1        ad 	if (dst < 0) {
    538   1.1        ad 		num += dst;
    539   1.1        ad 		dst = 0;
    540   1.1        ad 	}
    541   1.1        ad 
    542   1.1        ad 	if ((dst + num) > ri->ri_rows)
    543   1.1        ad 		num = ri->ri_rows - dst;
    544  1.30        pk 
    545   1.1        ad 	if (num <= 0)
    546   1.1        ad 		return;
    547   1.1        ad #endif
    548   1.1        ad 
    549   1.1        ad 	num *= ri->ri_font->fontheight;
    550   1.1        ad 	n8 = ri->ri_emustride >> 5;
    551   1.1        ad 	n1 = (ri->ri_emustride >> 2) & 7;
    552  1.30        pk 
    553   1.1        ad 	if (dst < src) {
    554  1.18        ad 		srp = (int32_t *)(ri->ri_bits + src * ri->ri_yscale);
    555  1.18        ad 		drp = (int32_t *)(ri->ri_bits + dst * ri->ri_yscale);
    556  1.51  jmcneill 		if (ri->ri_hwbits)
    557  1.51  jmcneill 			hrp = (int32_t *)(ri->ri_hwbits + dst *
    558  1.51  jmcneill 			    ri->ri_yscale);
    559  1.18        ad 		delta = ri->ri_stride;
    560   1.1        ad 	} else {
    561   1.1        ad 		src = ri->ri_font->fontheight * src + num - 1;
    562   1.1        ad 		dst = ri->ri_font->fontheight * dst + num - 1;
    563   1.1        ad 		srp = (int32_t *)(ri->ri_bits + src * ri->ri_stride);
    564   1.1        ad 		drp = (int32_t *)(ri->ri_bits + dst * ri->ri_stride);
    565  1.51  jmcneill 		if (ri->ri_hwbits)
    566  1.51  jmcneill 			hrp = (int32_t *)(ri->ri_hwbits + dst *
    567  1.51  jmcneill 			    ri->ri_stride);
    568  1.51  jmcneill 
    569  1.18        ad 		delta = -ri->ri_stride;
    570  1.18        ad 	}
    571  1.30        pk 
    572  1.18        ad 	while (num--) {
    573  1.18        ad 		dp = drp;
    574  1.18        ad 		sp = srp;
    575  1.51  jmcneill 		if (ri->ri_hwbits)
    576  1.51  jmcneill 			hp = hrp;
    577  1.51  jmcneill 
    578  1.18        ad 		DELTA(drp, delta, int32_t *);
    579  1.18        ad 		DELTA(srp, delta, int32_t *);
    580  1.51  jmcneill 		if (ri->ri_hwbits)
    581  1.51  jmcneill 			DELTA(hrp, delta, int32_t *);
    582  1.18        ad 
    583  1.18        ad 		for (cnt = n8; cnt; cnt--) {
    584  1.52  jmcneill 			dp[0] = sp[0];
    585  1.52  jmcneill 			dp[1] = sp[1];
    586  1.52  jmcneill 			dp[2] = sp[2];
    587  1.52  jmcneill 			dp[3] = sp[3];
    588  1.52  jmcneill 			dp[4] = sp[4];
    589  1.52  jmcneill 			dp[5] = sp[5];
    590  1.52  jmcneill 			dp[6] = sp[6];
    591  1.52  jmcneill 			dp[7] = sp[7];
    592  1.18        ad 			dp += 8;
    593  1.18        ad 			sp += 8;
    594  1.52  jmcneill 		}
    595  1.52  jmcneill 		if (ri->ri_hwbits) {
    596  1.52  jmcneill 			sp -= (8 * n8);
    597  1.52  jmcneill 			for (cnt = n8; cnt; cnt--) {
    598  1.52  jmcneill 				hp[0] = sp[0];
    599  1.52  jmcneill 				hp[1] = sp[1];
    600  1.52  jmcneill 				hp[2] = sp[2];
    601  1.52  jmcneill 				hp[3] = sp[3];
    602  1.52  jmcneill 				hp[4] = sp[4];
    603  1.52  jmcneill 				hp[5] = sp[5];
    604  1.52  jmcneill 				hp[6] = sp[6];
    605  1.52  jmcneill 				hp[7] = sp[7];
    606  1.51  jmcneill 				hp += 8;
    607  1.52  jmcneill 				sp += 8;
    608  1.52  jmcneill 			}
    609  1.18        ad 		}
    610  1.30        pk 
    611  1.51  jmcneill 		for (cnt = n1; cnt; cnt--) {
    612  1.18        ad 			*dp++ = *sp++;
    613  1.51  jmcneill 			if (ri->ri_hwbits)
    614  1.51  jmcneill 				*hp++ = *(sp - 1);
    615  1.51  jmcneill 		}
    616   1.1        ad 	}
    617   1.1        ad }
    618   1.1        ad 
    619   1.1        ad /*
    620   1.1        ad  * Copy columns. This is slow, and hard to optimize due to alignment,
    621   1.1        ad  * and the fact that we have to copy both left->right and right->left.
    622  1.43       uwe  * We simply cop-out here and use memmove(), since it handles all of
    623   1.1        ad  * these cases anyway.
    624   1.1        ad  */
    625   1.4        ad void
    626   1.1        ad rasops_copycols(cookie, row, src, dst, num)
    627   1.1        ad 	void *cookie;
    628   1.1        ad 	int row, src, dst, num;
    629   1.1        ad {
    630   1.1        ad 	struct rasops_info *ri;
    631  1.51  jmcneill 	u_char *sp, *dp, *hp;
    632   1.1        ad 	int height;
    633  1.30        pk 
    634   1.1        ad 	ri = (struct rasops_info *)cookie;
    635  1.51  jmcneill 	hp = NULL;
    636   1.1        ad 
    637   1.1        ad #ifdef RASOPS_CLIPPING
    638   1.1        ad 	if (dst == src)
    639   1.1        ad 		return;
    640  1.30        pk 
    641   1.3        ad 	/* Catches < 0 case too */
    642   1.3        ad 	if ((unsigned)row >= (unsigned)ri->ri_rows)
    643   1.1        ad 		return;
    644  1.30        pk 
    645   1.1        ad 	if (src < 0) {
    646   1.1        ad 		num += src;
    647   1.1        ad 		src = 0;
    648   1.1        ad 	}
    649   1.1        ad 
    650   1.1        ad 	if ((src + num) > ri->ri_cols)
    651   1.1        ad 		num = ri->ri_cols - src;
    652   1.1        ad 
    653   1.1        ad 	if (dst < 0) {
    654   1.1        ad 		num += dst;
    655   1.1        ad 		dst = 0;
    656   1.1        ad 	}
    657   1.1        ad 
    658   1.1        ad 	if ((dst + num) > ri->ri_cols)
    659   1.1        ad 		num = ri->ri_cols - dst;
    660  1.30        pk 
    661   1.1        ad 	if (num <= 0)
    662   1.1        ad 		return;
    663   1.1        ad #endif
    664  1.30        pk 
    665   1.1        ad 	num *= ri->ri_xscale;
    666   1.1        ad 	row *= ri->ri_yscale;
    667   1.1        ad 	height = ri->ri_font->fontheight;
    668  1.30        pk 
    669   1.1        ad 	sp = ri->ri_bits + row + src * ri->ri_xscale;
    670   1.1        ad 	dp = ri->ri_bits + row + dst * ri->ri_xscale;
    671  1.51  jmcneill 	if (ri->ri_hwbits)
    672  1.51  jmcneill 		hp = ri->ri_hwbits + row + dst * ri->ri_xscale;
    673  1.30        pk 
    674   1.1        ad 	while (height--) {
    675  1.43       uwe 		memmove(dp, sp, num);
    676  1.51  jmcneill 		if (ri->ri_hwbits) {
    677  1.51  jmcneill 			memcpy(hp, sp, num);
    678  1.51  jmcneill 			hp += ri->ri_stride;
    679  1.51  jmcneill 		}
    680   1.1        ad 		dp += ri->ri_stride;
    681   1.1        ad 		sp += ri->ri_stride;
    682   1.1        ad 	}
    683   1.1        ad }
    684   1.1        ad 
    685   1.1        ad /*
    686   1.1        ad  * Turn cursor off/on.
    687   1.1        ad  */
    688   1.1        ad static void
    689   1.1        ad rasops_cursor(cookie, on, row, col)
    690   1.1        ad 	void *cookie;
    691   1.1        ad 	int on, row, col;
    692   1.1        ad {
    693   1.1        ad 	struct rasops_info *ri;
    694  1.30        pk 
    695   1.1        ad 	ri = (struct rasops_info *)cookie;
    696  1.30        pk 
    697   1.1        ad 	/* Turn old cursor off */
    698  1.13        ad 	if ((ri->ri_flg & RI_CURSOR) != 0)
    699  1.30        pk #ifdef RASOPS_CLIPPING
    700  1.13        ad 		if ((ri->ri_flg & RI_CURSORCLIP) == 0)
    701   1.1        ad #endif
    702   1.1        ad 			ri->ri_do_cursor(ri);
    703   1.1        ad 
    704   1.1        ad 	/* Select new cursor */
    705   1.1        ad #ifdef RASOPS_CLIPPING
    706  1.13        ad 	ri->ri_flg &= ~RI_CURSORCLIP;
    707  1.30        pk 
    708   1.1        ad 	if (row < 0 || row >= ri->ri_rows)
    709  1.13        ad 		ri->ri_flg |= RI_CURSORCLIP;
    710   1.1        ad 	else if (col < 0 || col >= ri->ri_cols)
    711  1.13        ad 		ri->ri_flg |= RI_CURSORCLIP;
    712   1.1        ad #endif
    713   1.1        ad 	ri->ri_crow = row;
    714   1.1        ad 	ri->ri_ccol = col;
    715   1.1        ad 
    716   1.1        ad 	if (on) {
    717  1.13        ad 		ri->ri_flg |= RI_CURSOR;
    718  1.30        pk #ifdef RASOPS_CLIPPING
    719  1.13        ad 		if ((ri->ri_flg & RI_CURSORCLIP) == 0)
    720   1.1        ad #endif
    721   1.1        ad 			ri->ri_do_cursor(ri);
    722  1.30        pk 	} else
    723  1.13        ad 		ri->ri_flg &= ~RI_CURSOR;
    724   1.1        ad }
    725   1.1        ad 
    726   1.1        ad /*
    727   1.1        ad  * Make the device colormap
    728   1.1        ad  */
    729   1.4        ad static void
    730   1.1        ad rasops_init_devcmap(ri)
    731   1.1        ad 	struct rasops_info *ri;
    732   1.1        ad {
    733  1.23  drochner 	const u_char *p;
    734   1.1        ad 	int i, c;
    735  1.30        pk 
    736   1.4        ad 	switch (ri->ri_depth) {
    737   1.4        ad 	case 1:
    738   1.4        ad 		ri->ri_devcmap[0] = 0;
    739   1.4        ad 		for (i = 1; i < 16; i++)
    740   1.4        ad 			ri->ri_devcmap[i] = -1;
    741   1.4        ad 		return;
    742   1.4        ad 
    743   1.4        ad 	case 2:
    744   1.4        ad 		for (i = 1; i < 15; i++)
    745   1.4        ad 			ri->ri_devcmap[i] = 0xaaaaaaaa;
    746  1.30        pk 
    747   1.4        ad 		ri->ri_devcmap[0] = 0;
    748   1.4        ad 		ri->ri_devcmap[8] = 0x55555555;
    749   1.4        ad 		ri->ri_devcmap[15] = -1;
    750   1.4        ad 		return;
    751   1.4        ad 
    752   1.4        ad 	case 8:
    753   1.4        ad 		for (i = 0; i < 16; i++)
    754   1.4        ad 			ri->ri_devcmap[i] = i | (i<<8) | (i<<16) | (i<<24);
    755   1.4        ad 		return;
    756   1.4        ad 	}
    757  1.30        pk 
    758   1.1        ad 	p = rasops_cmap;
    759  1.30        pk 
    760  1.29   nathanw 	for (i = 0; i < 16; i++) {
    761   1.1        ad 		if (ri->ri_rnum <= 8)
    762  1.12        ad 			c = (*p >> (8 - ri->ri_rnum)) << ri->ri_rpos;
    763  1.30        pk 		else
    764  1.12        ad 			c = (*p << (ri->ri_rnum - 8)) << ri->ri_rpos;
    765  1.29   nathanw 		p++;
    766   1.1        ad 
    767   1.1        ad 		if (ri->ri_gnum <= 8)
    768  1.12        ad 			c |= (*p >> (8 - ri->ri_gnum)) << ri->ri_gpos;
    769  1.30        pk 		else
    770  1.12        ad 			c |= (*p << (ri->ri_gnum - 8)) << ri->ri_gpos;
    771  1.29   nathanw 		p++;
    772   1.1        ad 
    773   1.1        ad 		if (ri->ri_bnum <= 8)
    774  1.12        ad 			c |= (*p >> (8 - ri->ri_bnum)) << ri->ri_bpos;
    775  1.30        pk 		else
    776  1.12        ad 			c |= (*p << (ri->ri_bnum - 8)) << ri->ri_bpos;
    777  1.29   nathanw 		p++;
    778   1.4        ad 
    779   1.4        ad 		/* Fill the word for generic routines, which want this */
    780   1.4        ad 		if (ri->ri_depth == 24)
    781   1.4        ad 			c = c | ((c & 0xff) << 24);
    782   1.4        ad 		else if (ri->ri_depth <= 16)
    783   1.4        ad 			c = c | (c << 16);
    784   1.1        ad 
    785   1.4        ad 		/* 24bpp does bswap on the fly. {32,16,15}bpp do it here. */
    786  1.13        ad 		if ((ri->ri_flg & RI_BSWAP) == 0)
    787   1.3        ad 			ri->ri_devcmap[i] = c;
    788   1.4        ad 		else if (ri->ri_depth == 32)
    789   1.3        ad 			ri->ri_devcmap[i] = bswap32(c);
    790   1.4        ad 		else if (ri->ri_depth == 16 || ri->ri_depth == 15)
    791   1.3        ad 			ri->ri_devcmap[i] = bswap16(c);
    792   1.4        ad 		else
    793   1.4        ad 			ri->ri_devcmap[i] = c;
    794   1.1        ad 	}
    795   1.1        ad }
    796   1.1        ad 
    797   1.1        ad /*
    798   1.1        ad  * Unpack a rasops attribute
    799   1.1        ad  */
    800   1.1        ad void
    801   1.1        ad rasops_unpack_attr(attr, fg, bg, underline)
    802   1.1        ad 	long attr;
    803   1.1        ad 	int *fg, *bg, *underline;
    804   1.1        ad {
    805  1.30        pk 
    806  1.30        pk 	*fg = ((u_int)attr >> 24) & 0xf;
    807  1.30        pk 	*bg = ((u_int)attr >> 16) & 0xf;
    808  1.25        ad 	if (underline != NULL)
    809  1.24  drochner 		*underline = (u_int)attr & 1;
    810   1.4        ad }
    811   1.4        ad 
    812   1.4        ad /*
    813   1.4        ad  * Erase rows. This isn't static, since 24-bpp uses it in special cases.
    814   1.4        ad  */
    815   1.4        ad void
    816   1.4        ad rasops_eraserows(cookie, row, num, attr)
    817   1.4        ad 	void *cookie;
    818   1.4        ad 	int row, num;
    819   1.4        ad 	long attr;
    820   1.4        ad {
    821   1.4        ad 	struct rasops_info *ri;
    822  1.14        ad 	int np, nw, cnt, delta;
    823  1.51  jmcneill 	int32_t *dp, *hp, clr;
    824  1.51  jmcneill 	int i;
    825  1.30        pk 
    826   1.4        ad 	ri = (struct rasops_info *)cookie;
    827  1.51  jmcneill 	hp = NULL;
    828   1.4        ad 
    829   1.4        ad #ifdef RASOPS_CLIPPING
    830   1.4        ad 	if (row < 0) {
    831   1.4        ad 		num += row;
    832   1.4        ad 		row = 0;
    833   1.4        ad 	}
    834   1.4        ad 
    835   1.4        ad 	if ((row + num) > ri->ri_rows)
    836   1.4        ad 		num = ri->ri_rows - row;
    837  1.30        pk 
    838   1.4        ad 	if (num <= 0)
    839   1.4        ad 		return;
    840   1.4        ad #endif
    841   1.4        ad 
    842  1.30        pk 	clr = ri->ri_devcmap[(attr >> 16) & 0xf];
    843   1.4        ad 
    844  1.30        pk 	/*
    845  1.20        ad 	 * XXX The wsdisplay_emulops interface seems a little deficient in
    846  1.30        pk 	 * that there is no way to clear the *entire* screen. We provide a
    847  1.30        pk 	 * workaround here: if the entire console area is being cleared, and
    848  1.13        ad 	 * the RI_FULLCLEAR flag is set, clear the entire display.
    849  1.30        pk 	 */
    850  1.13        ad 	if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) {
    851  1.13        ad 		np = ri->ri_stride >> 5;
    852  1.13        ad 		nw = (ri->ri_stride >> 2) & 7;
    853  1.13        ad 		num = ri->ri_height;
    854  1.14        ad 		dp = (int32_t *)ri->ri_origbits;
    855  1.51  jmcneill 		if (ri->ri_hwbits)
    856  1.51  jmcneill 			hp = (int32_t *)ri->ri_hwbits;
    857  1.14        ad 		delta = 0;
    858  1.13        ad 	} else {
    859  1.13        ad 		np = ri->ri_emustride >> 5;
    860  1.13        ad 		nw = (ri->ri_emustride >> 2) & 7;
    861  1.13        ad 		num *= ri->ri_font->fontheight;
    862  1.14        ad 		dp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale);
    863  1.51  jmcneill 		if (ri->ri_hwbits)
    864  1.51  jmcneill 			hp = (int32_t *)(ri->ri_hwbits + row *
    865  1.51  jmcneill 			    ri->ri_yscale);
    866  1.14        ad 		delta = ri->ri_delta;
    867  1.13        ad 	}
    868  1.30        pk 
    869   1.4        ad 	while (num--) {
    870   1.4        ad 		for (cnt = np; cnt; cnt--) {
    871  1.51  jmcneill 			for (i = 0; i < 8; i++) {
    872  1.51  jmcneill 				dp[i] = clr;
    873  1.51  jmcneill 				if (ri->ri_hwbits)
    874  1.51  jmcneill 					hp[i] = clr;
    875  1.51  jmcneill 			}
    876   1.4        ad 			dp += 8;
    877  1.51  jmcneill 			if (ri->ri_hwbits)
    878  1.51  jmcneill 				hp += 8;
    879   1.4        ad 		}
    880  1.30        pk 
    881   1.4        ad 		for (cnt = nw; cnt; cnt--) {
    882   1.4        ad 			*(int32_t *)dp = clr;
    883   1.4        ad 			DELTA(dp, 4, int32_t *);
    884  1.51  jmcneill 			if (ri->ri_hwbits) {
    885  1.51  jmcneill 				*(int32_t *)hp = clr;
    886  1.51  jmcneill 				DELTA(hp, 4, int32_t *);
    887  1.51  jmcneill 			}
    888  1.30        pk 		}
    889  1.30        pk 
    890  1.14        ad 		DELTA(dp, delta, int32_t *);
    891  1.51  jmcneill 		if (ri->ri_hwbits)
    892  1.51  jmcneill 			DELTA(hp, delta, int32_t *);
    893   1.4        ad 	}
    894   1.4        ad }
    895   1.4        ad 
    896   1.4        ad /*
    897   1.4        ad  * Actually turn the cursor on or off. This does the dirty work for
    898   1.4        ad  * rasops_cursor().
    899   1.4        ad  */
    900   1.4        ad static void
    901   1.4        ad rasops_do_cursor(ri)
    902   1.4        ad 	struct rasops_info *ri;
    903   1.4        ad {
    904  1.21        ad 	int full1, height, cnt, slop1, slop2, row, col;
    905  1.51  jmcneill 	u_char *dp, *rp, *hrp, *hp;
    906  1.51  jmcneill 
    907  1.51  jmcneill 	hrp = hp = NULL;
    908  1.30        pk 
    909  1.55      ober #if NRASOPS_ROTATION > 0
    910  1.55      ober 	if (ri->ri_flg & RI_ROTATE_CW) {
    911  1.55      ober 		/* Rotate rows/columns */
    912  1.55      ober 		row = ri->ri_ccol;
    913  1.55      ober 		col = ri->ri_rows - ri->ri_crow - 1;
    914  1.55      ober 	} else
    915  1.55      ober #endif
    916  1.55      ober 	{
    917  1.55      ober 		row = ri->ri_crow;
    918  1.55      ober 		col = ri->ri_ccol;
    919  1.55      ober 	}
    920  1.30        pk 
    921   1.4        ad 	rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
    922  1.51  jmcneill 	if (ri->ri_hwbits)
    923  1.51  jmcneill 		hrp = ri->ri_hwbits + row * ri->ri_yscale + col
    924  1.51  jmcneill 		    * ri->ri_xscale;
    925   1.4        ad 	height = ri->ri_font->fontheight;
    926  1.27  nisimura 	slop1 = (4 - ((long)rp & 3)) & 3;
    927  1.30        pk 
    928   1.4        ad 	if (slop1 > ri->ri_xscale)
    929   1.4        ad 		slop1 = ri->ri_xscale;
    930  1.30        pk 
    931   1.4        ad 	slop2 = (ri->ri_xscale - slop1) & 3;
    932   1.4        ad 	full1 = (ri->ri_xscale - slop1 - slop2) >> 2;
    933  1.30        pk 
    934   1.4        ad 	if ((slop1 | slop2) == 0) {
    935   1.4        ad 		/* A common case */
    936   1.4        ad 		while (height--) {
    937   1.4        ad 			dp = rp;
    938   1.4        ad 			rp += ri->ri_stride;
    939  1.51  jmcneill 			if (ri->ri_hwbits) {
    940  1.51  jmcneill 				hp = hrp;
    941  1.51  jmcneill 				hrp += ri->ri_stride;
    942  1.51  jmcneill 			}
    943  1.30        pk 
    944   1.4        ad 			for (cnt = full1; cnt; cnt--) {
    945  1.21        ad 				*(int32_t *)dp ^= ~0;
    946   1.4        ad 				dp += 4;
    947  1.51  jmcneill 				if (ri->ri_hwbits) {
    948  1.51  jmcneill 					*(int32_t *)hp ^= ~0;
    949  1.51  jmcneill 					hp += 4;
    950  1.51  jmcneill 				}
    951   1.4        ad 			}
    952   1.4        ad 		}
    953   1.4        ad 	} else {
    954   1.4        ad 		/* XXX this is stupid.. use masks instead */
    955   1.4        ad 		while (height--) {
    956   1.4        ad 			dp = rp;
    957   1.4        ad 			rp += ri->ri_stride;
    958  1.51  jmcneill 			if (ri->ri_hwbits) {
    959  1.51  jmcneill 				hp = hrp;
    960  1.51  jmcneill 				hrp += ri->ri_stride;
    961  1.51  jmcneill 			}
    962  1.30        pk 
    963  1.51  jmcneill 			if (slop1 & 1) {
    964  1.22     enami 				*dp++ ^= ~0;
    965  1.51  jmcneill 				if (ri->ri_hwbits)
    966  1.51  jmcneill 					*hp++ ^= ~0;
    967  1.51  jmcneill 			}
    968   1.4        ad 
    969   1.4        ad 			if (slop1 & 2) {
    970  1.21        ad 				*(int16_t *)dp ^= ~0;
    971   1.4        ad 				dp += 2;
    972  1.51  jmcneill 				if (ri->ri_hwbits) {
    973  1.51  jmcneill 					*(int16_t *)hp ^= ~0;
    974  1.51  jmcneill 					hp += 2;
    975  1.51  jmcneill 				}
    976   1.4        ad 			}
    977  1.30        pk 
    978   1.4        ad 			for (cnt = full1; cnt; cnt--) {
    979  1.21        ad 				*(int32_t *)dp ^= ~0;
    980   1.4        ad 				dp += 4;
    981  1.51  jmcneill 				if (ri->ri_hwbits) {
    982  1.51  jmcneill 					*(int32_t *)hp ^= ~0;
    983  1.51  jmcneill 					hp += 4;
    984  1.51  jmcneill 				}
    985   1.4        ad 			}
    986   1.4        ad 
    987  1.51  jmcneill 			if (slop2 & 1) {
    988  1.21        ad 				*dp++ ^= ~0;
    989  1.51  jmcneill 				if (ri->ri_hwbits)
    990  1.51  jmcneill 					*hp++ ^= ~0;
    991  1.51  jmcneill 			}
    992   1.4        ad 
    993  1.51  jmcneill 			if (slop2 & 2) {
    994  1.21        ad 				*(int16_t *)dp ^= ~0;
    995  1.51  jmcneill 				if (ri->ri_hwbits)
    996  1.51  jmcneill 					*(int16_t *)hp ^= ~0;
    997  1.51  jmcneill 			}
    998   1.4        ad 		}
    999   1.4        ad 	}
   1000   1.4        ad }
   1001   1.4        ad 
   1002   1.4        ad /*
   1003   1.4        ad  * Erase columns.
   1004   1.4        ad  */
   1005   1.4        ad void
   1006   1.4        ad rasops_erasecols(cookie, row, col, num, attr)
   1007   1.4        ad 	void *cookie;
   1008   1.4        ad 	int row, col, num;
   1009   1.4        ad 	long attr;
   1010   1.4        ad {
   1011   1.4        ad 	int n8, height, cnt, slop1, slop2, clr;
   1012   1.4        ad 	struct rasops_info *ri;
   1013  1.51  jmcneill 	int32_t *rp, *dp, *hrp, *hp;
   1014  1.51  jmcneill 	int i;
   1015  1.30        pk 
   1016   1.4        ad 	ri = (struct rasops_info *)cookie;
   1017  1.51  jmcneill 	hrp = hp = NULL;
   1018  1.30        pk 
   1019  1.30        pk #ifdef RASOPS_CLIPPING
   1020   1.4        ad 	if ((unsigned)row >= (unsigned)ri->ri_rows)
   1021   1.4        ad 		return;
   1022   1.4        ad 
   1023   1.4        ad 	if (col < 0) {
   1024   1.4        ad 		num += col;
   1025   1.4        ad 		col = 0;
   1026   1.4        ad 	}
   1027   1.4        ad 
   1028   1.4        ad 	if ((col + num) > ri->ri_cols)
   1029   1.4        ad 		num = ri->ri_cols - col;
   1030  1.30        pk 
   1031   1.4        ad 	if (num <= 0)
   1032   1.4        ad 		return;
   1033   1.4        ad #endif
   1034  1.30        pk 
   1035   1.4        ad 	num = num * ri->ri_xscale;
   1036   1.4        ad 	rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
   1037  1.51  jmcneill 	if (ri->ri_hwbits)
   1038  1.51  jmcneill 		hrp = (int32_t *)(ri->ri_hwbits + row*ri->ri_yscale +
   1039  1.51  jmcneill 		    col*ri->ri_xscale);
   1040   1.4        ad 	height = ri->ri_font->fontheight;
   1041  1.30        pk 	clr = ri->ri_devcmap[(attr >> 16) & 0xf];
   1042  1.30        pk 
   1043   1.4        ad 	/* Don't bother using the full loop for <= 32 pels */
   1044   1.4        ad 	if (num <= 32) {
   1045   1.6        ad 		if (((num | ri->ri_xscale) & 3) == 0) {
   1046   1.6        ad 			/* Word aligned blt */
   1047   1.6        ad 			num >>= 2;
   1048   1.6        ad 
   1049   1.6        ad 			while (height--) {
   1050   1.6        ad 				dp = rp;
   1051   1.6        ad 				DELTA(rp, ri->ri_stride, int32_t *);
   1052  1.51  jmcneill 				if (ri->ri_hwbits) {
   1053  1.51  jmcneill 					hp = hrp;
   1054  1.51  jmcneill 					DELTA(hrp, ri->ri_stride, int32_t *);
   1055  1.51  jmcneill 				}
   1056  1.30        pk 
   1057  1.51  jmcneill 				for (cnt = num; cnt; cnt--) {
   1058   1.6        ad 					*dp++ = clr;
   1059  1.51  jmcneill 					if (ri->ri_hwbits)
   1060  1.51  jmcneill 						*hp++ = clr;
   1061  1.51  jmcneill 				}
   1062   1.6        ad 			}
   1063   1.6        ad 		} else if (((num | ri->ri_xscale) & 1) == 0) {
   1064  1.30        pk 			/*
   1065   1.4        ad 			 * Halfword aligned blt. This is needed so the
   1066  1.30        pk 			 * 15/16 bit ops can use this function.
   1067   1.4        ad 			 */
   1068   1.4        ad 			num >>= 1;
   1069   1.4        ad 
   1070   1.4        ad 			while (height--) {
   1071   1.4        ad 				dp = rp;
   1072   1.4        ad 				DELTA(rp, ri->ri_stride, int32_t *);
   1073  1.51  jmcneill 				if (ri->ri_hwbits) {
   1074  1.51  jmcneill 					hp = hrp;
   1075  1.51  jmcneill 					DELTA(hrp, ri->ri_stride, int32_t *);
   1076  1.51  jmcneill 				}
   1077   1.4        ad 
   1078   1.4        ad 				for (cnt = num; cnt; cnt--) {
   1079   1.4        ad 					*(int16_t *)dp = clr;
   1080   1.4        ad 					DELTA(dp, 2, int32_t *);
   1081  1.51  jmcneill 					if (ri->ri_hwbits) {
   1082  1.51  jmcneill 						*(int16_t *)hp = clr;
   1083  1.51  jmcneill 						DELTA(hp, 2, int32_t *);
   1084  1.51  jmcneill 					}
   1085   1.4        ad 				}
   1086   1.4        ad 			}
   1087   1.4        ad 		} else {
   1088   1.4        ad 			while (height--) {
   1089   1.4        ad 				dp = rp;
   1090   1.4        ad 				DELTA(rp, ri->ri_stride, int32_t *);
   1091  1.51  jmcneill 				if (ri->ri_hwbits) {
   1092  1.51  jmcneill 					hp = hrp;
   1093  1.51  jmcneill 					DELTA(hrp, ri->ri_stride, int32_t *);
   1094  1.51  jmcneill 				}
   1095   1.4        ad 
   1096   1.4        ad 				for (cnt = num; cnt; cnt--) {
   1097   1.4        ad 					*(u_char *)dp = clr;
   1098   1.4        ad 					DELTA(dp, 1, int32_t *);
   1099  1.51  jmcneill 					if (ri->ri_hwbits) {
   1100  1.51  jmcneill 						*(u_char *)hp = clr;
   1101  1.51  jmcneill 						DELTA(hp, 1, int32_t *);
   1102  1.51  jmcneill 					}
   1103   1.4        ad 				}
   1104   1.4        ad 			}
   1105   1.4        ad 		}
   1106  1.30        pk 
   1107   1.4        ad 		return;
   1108   1.4        ad 	}
   1109  1.30        pk 
   1110  1.27  nisimura 	slop1 = (4 - ((long)rp & 3)) & 3;
   1111   1.4        ad 	slop2 = (num - slop1) & 3;
   1112   1.4        ad 	num -= slop1 + slop2;
   1113   1.4        ad 	n8 = num >> 5;
   1114   1.4        ad 	num = (num >> 2) & 7;
   1115   1.4        ad 
   1116   1.4        ad 	while (height--) {
   1117   1.4        ad 		dp = rp;
   1118   1.4        ad 		DELTA(rp, ri->ri_stride, int32_t *);
   1119  1.51  jmcneill 		if (ri->ri_hwbits) {
   1120  1.51  jmcneill 			hp = hrp;
   1121  1.51  jmcneill 			DELTA(hrp, ri->ri_stride, int32_t *);
   1122  1.51  jmcneill 		}
   1123  1.30        pk 
   1124   1.4        ad 		/* Align span to 4 bytes */
   1125   1.4        ad 		if (slop1 & 1) {
   1126   1.4        ad 			*(u_char *)dp = clr;
   1127   1.4        ad 			DELTA(dp, 1, int32_t *);
   1128  1.51  jmcneill 			if (ri->ri_hwbits) {
   1129  1.51  jmcneill 				*(u_char *)hp = clr;
   1130  1.51  jmcneill 				DELTA(hp, 1, int32_t *);
   1131  1.51  jmcneill 			}
   1132   1.4        ad 		}
   1133   1.4        ad 
   1134   1.4        ad 		if (slop1 & 2) {
   1135   1.4        ad 			*(int16_t *)dp = clr;
   1136   1.4        ad 			DELTA(dp, 2, int32_t *);
   1137  1.51  jmcneill 			if (ri->ri_hwbits) {
   1138  1.51  jmcneill 				*(int16_t *)hp = clr;
   1139  1.51  jmcneill 				DELTA(hp, 2, int32_t *);
   1140  1.51  jmcneill 			}
   1141   1.4        ad 		}
   1142  1.30        pk 
   1143   1.4        ad 		/* Write 32 bytes per loop */
   1144   1.4        ad 		for (cnt = n8; cnt; cnt--) {
   1145  1.51  jmcneill 			for (i = 0; i < 8; i++) {
   1146  1.51  jmcneill 				dp[i] = clr;
   1147  1.51  jmcneill 				if (ri->ri_hwbits)
   1148  1.51  jmcneill 					hp[i] = clr;
   1149  1.51  jmcneill 			}
   1150   1.4        ad 			dp += 8;
   1151  1.51  jmcneill 			if (ri->ri_hwbits)
   1152  1.51  jmcneill 				hp += 8;
   1153   1.4        ad 		}
   1154  1.30        pk 
   1155  1.30        pk 		/* Write 4 bytes per loop */
   1156  1.51  jmcneill 		for (cnt = num; cnt; cnt--) {
   1157   1.4        ad 			*dp++ = clr;
   1158  1.51  jmcneill 			if (ri->ri_hwbits)
   1159  1.51  jmcneill 				*hp++ = clr;
   1160  1.51  jmcneill 		}
   1161  1.30        pk 
   1162  1.30        pk 		/* Write unaligned trailing slop */
   1163   1.4        ad 		if (slop2 & 1) {
   1164   1.4        ad 			*(u_char *)dp = clr;
   1165   1.4        ad 			DELTA(dp, 1, int32_t *);
   1166  1.51  jmcneill 			if (ri->ri_hwbits) {
   1167  1.51  jmcneill 				*(u_char *)hp = clr;
   1168  1.51  jmcneill 				DELTA(hp, 1, int32_t *);
   1169  1.51  jmcneill 			}
   1170   1.4        ad 		}
   1171   1.4        ad 
   1172  1.51  jmcneill 		if (slop2 & 2) {
   1173   1.4        ad 			*(int16_t *)dp = clr;
   1174  1.51  jmcneill 			if (ri->ri_hwbits)
   1175  1.51  jmcneill 				*(int16_t *)hp = clr;
   1176  1.51  jmcneill 		}
   1177   1.4        ad 	}
   1178   1.1        ad }
   1179  1.55      ober 
   1180  1.55      ober #if NRASOPS_ROTATION > 0
   1181  1.55      ober /*
   1182  1.55      ober  * Quarter clockwise rotation routines (originally intended for the
   1183  1.55      ober  * built-in Zaurus C3x00 display in 16bpp).
   1184  1.55      ober  */
   1185  1.55      ober 
   1186  1.55      ober #include <sys/malloc.h>
   1187  1.55      ober 
   1188  1.55      ober static void
   1189  1.55      ober rasops_rotate_font(int *cookie)
   1190  1.55      ober {
   1191  1.55      ober 	struct rotatedfont *f;
   1192  1.55      ober 	int ncookie;
   1193  1.55      ober 
   1194  1.55      ober 	SLIST_FOREACH(f, &rotatedfonts, rf_next) {
   1195  1.55      ober 		if (f->rf_cookie == *cookie) {
   1196  1.55      ober 			*cookie = f->rf_rotated;
   1197  1.55      ober 			return;
   1198  1.55      ober 		}
   1199  1.55      ober 	}
   1200  1.55      ober 
   1201  1.55      ober 	/*
   1202  1.55      ober 	 * We did not find a rotated version of this font. Ask the wsfont
   1203  1.55      ober 	 * code to compute one for us.
   1204  1.55      ober 	 */
   1205  1.55      ober 
   1206  1.55      ober 	f = malloc(sizeof(struct rotatedfont), M_DEVBUF, M_WAITOK);
   1207  1.55      ober 	if (f == NULL)
   1208  1.55      ober 		return;
   1209  1.55      ober 
   1210  1.55      ober 	if ((ncookie = wsfont_rotate(*cookie)) == -1)
   1211  1.55      ober 		return;
   1212  1.55      ober 
   1213  1.55      ober 	f->rf_cookie = *cookie;
   1214  1.55      ober 	f->rf_rotated = ncookie;
   1215  1.55      ober 	SLIST_INSERT_HEAD(&rotatedfonts, f, rf_next);
   1216  1.55      ober 
   1217  1.55      ober 	*cookie = ncookie;
   1218  1.55      ober }
   1219  1.55      ober 
   1220  1.55      ober static void
   1221  1.55      ober rasops_copychar(cookie, srcrow, dstrow, srccol, dstcol)
   1222  1.55      ober 	void *cookie;
   1223  1.55      ober 	int srcrow, dstrow, srccol, dstcol;
   1224  1.55      ober {
   1225  1.55      ober 	struct rasops_info *ri;
   1226  1.55      ober 	u_char *sp, *dp;
   1227  1.55      ober 	int height;
   1228  1.55      ober 	int r_srcrow, r_dstrow, r_srccol, r_dstcol;
   1229  1.55      ober 
   1230  1.55      ober 	ri = (struct rasops_info *)cookie;
   1231  1.55      ober 
   1232  1.55      ober 	r_srcrow = srccol;
   1233  1.55      ober 	r_dstrow = dstcol;
   1234  1.55      ober 	r_srccol = ri->ri_rows - srcrow - 1;
   1235  1.55      ober 	r_dstcol = ri->ri_rows - dstrow - 1;
   1236  1.55      ober 
   1237  1.55      ober 	r_srcrow *= ri->ri_yscale;
   1238  1.55      ober 	r_dstrow *= ri->ri_yscale;
   1239  1.55      ober 	height = ri->ri_font->fontheight;
   1240  1.55      ober 
   1241  1.55      ober 	sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale;
   1242  1.55      ober 	dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale;
   1243  1.55      ober 
   1244  1.55      ober 	while (height--) {
   1245  1.55      ober 		memmove(dp, sp, ri->ri_xscale);
   1246  1.55      ober 		dp += ri->ri_stride;
   1247  1.55      ober 		sp += ri->ri_stride;
   1248  1.55      ober 	}
   1249  1.55      ober }
   1250  1.55      ober 
   1251  1.55      ober static void
   1252  1.55      ober rasops_putchar_rotated(cookie, row, col, uc, attr)
   1253  1.55      ober 	void *cookie;
   1254  1.55      ober 	int row, col;
   1255  1.55      ober 	u_int uc;
   1256  1.55      ober 	long attr;
   1257  1.55      ober {
   1258  1.55      ober 	struct rasops_info *ri;
   1259  1.55      ober 	u_char *rp;
   1260  1.55      ober 	int height;
   1261  1.55      ober 
   1262  1.55      ober 	ri = (struct rasops_info *)cookie;
   1263  1.55      ober 
   1264  1.56       mjf 	if (__predict_false((unsigned int)row > ri->ri_rows ||
   1265  1.56       mjf 	    (unsigned int)col > ri->ri_cols))
   1266  1.56       mjf 		return;
   1267  1.56       mjf 
   1268  1.56       mjf 	/* Avoid underflow */
   1269  1.56       mjf 	if ((ri->ri_rows - row - 1) < 0)
   1270  1.56       mjf 		return;
   1271  1.56       mjf 
   1272  1.55      ober 	/* Do rotated char sans (side)underline */
   1273  1.55      ober 	ri->ri_real_ops.putchar(cookie, col, ri->ri_rows - row - 1, uc,
   1274  1.55      ober 	    attr & ~1);
   1275  1.55      ober 
   1276  1.55      ober 	/* Do rotated underline */
   1277  1.55      ober 	rp = ri->ri_bits + col * ri->ri_yscale + (ri->ri_rows - row - 1) *
   1278  1.55      ober 	    ri->ri_xscale;
   1279  1.55      ober 	height = ri->ri_font->fontheight;
   1280  1.55      ober 
   1281  1.55      ober 	/* XXX this assumes 16-bit color depth */
   1282  1.55      ober 	if ((attr & 1) != 0) {
   1283  1.55      ober 		int16_t c = (int16_t)ri->ri_devcmap[((u_int)attr >> 24) & 0xf];
   1284  1.55      ober 
   1285  1.55      ober 		while (height--) {
   1286  1.55      ober 			*(int16_t *)rp = c;
   1287  1.55      ober 			rp += ri->ri_stride;
   1288  1.55      ober 		}
   1289  1.55      ober 	}
   1290  1.55      ober }
   1291  1.55      ober 
   1292  1.55      ober static void
   1293  1.55      ober rasops_erasecols_rotated(cookie, row, col, num, attr)
   1294  1.55      ober 	void *cookie;
   1295  1.55      ober 	int row, col, num;
   1296  1.55      ober 	long attr;
   1297  1.55      ober {
   1298  1.55      ober 	struct rasops_info *ri;
   1299  1.55      ober 	int i;
   1300  1.55      ober 
   1301  1.55      ober 	ri = (struct rasops_info *)cookie;
   1302  1.55      ober 
   1303  1.55      ober 	for (i = col; i < col + num; i++)
   1304  1.55      ober 		ri->ri_ops.putchar(cookie, row, i, ' ', attr);
   1305  1.55      ober }
   1306  1.55      ober 
   1307  1.55      ober /* XXX: these could likely be optimised somewhat. */
   1308  1.55      ober static void
   1309  1.55      ober rasops_copyrows_rotated(cookie, src, dst, num)
   1310  1.55      ober 	void *cookie;
   1311  1.55      ober 	int src, dst, num;
   1312  1.55      ober {
   1313  1.55      ober 	struct rasops_info *ri = (struct rasops_info *)cookie;
   1314  1.55      ober 	int col, roff;
   1315  1.55      ober 
   1316  1.55      ober 	if (src > dst)
   1317  1.55      ober 		for (roff = 0; roff < num; roff++)
   1318  1.55      ober 			for (col = 0; col < ri->ri_cols; col++)
   1319  1.55      ober 				rasops_copychar(cookie, src + roff, dst + roff,
   1320  1.55      ober 				    col, col);
   1321  1.55      ober 	else
   1322  1.55      ober 		for (roff = num - 1; roff >= 0; roff--)
   1323  1.55      ober 			for (col = 0; col < ri->ri_cols; col++)
   1324  1.55      ober 				rasops_copychar(cookie, src + roff, dst + roff,
   1325  1.55      ober 				    col, col);
   1326  1.55      ober }
   1327  1.55      ober 
   1328  1.55      ober static void
   1329  1.55      ober rasops_copycols_rotated(cookie, row, src, dst, num)
   1330  1.55      ober 	void *cookie;
   1331  1.55      ober 	int row, src, dst, num;
   1332  1.55      ober {
   1333  1.55      ober 	int coff;
   1334  1.55      ober 
   1335  1.55      ober 	if (src > dst)
   1336  1.55      ober 		for (coff = 0; coff < num; coff++)
   1337  1.55      ober 			rasops_copychar(cookie, row, row, src + coff, dst + coff);
   1338  1.55      ober 	else
   1339  1.55      ober 		for (coff = num - 1; coff >= 0; coff--)
   1340  1.55      ober 			rasops_copychar(cookie, row, row, src + coff, dst + coff);
   1341  1.55      ober }
   1342  1.55      ober 
   1343  1.55      ober static void
   1344  1.55      ober rasops_eraserows_rotated(cookie, row, num, attr)
   1345  1.55      ober 	void *cookie;
   1346  1.55      ober 	int row, num;
   1347  1.55      ober 	long attr;
   1348  1.55      ober {
   1349  1.55      ober 	struct rasops_info *ri;
   1350  1.55      ober 	int col, rn;
   1351  1.55      ober 
   1352  1.55      ober 	ri = (struct rasops_info *)cookie;
   1353  1.55      ober 
   1354  1.55      ober 	for (rn = row; rn < row + num; rn++)
   1355  1.55      ober 		for (col = 0; col < ri->ri_cols; col++)
   1356  1.55      ober 			ri->ri_ops.putchar(cookie, rn, col, ' ', attr);
   1357  1.55      ober }
   1358  1.55      ober #endif	/* NRASOPS_ROTATION */
   1359