Home | History | Annotate | Line # | Download | only in rasops
rasops4.c revision 1.3
      1 /* 	$NetBSD: rasops4.c,v 1.3 2001/11/13 07:00:23 lukem Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1999 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Andrew Doran.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *	This product includes software developed by the NetBSD
     21  *	Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 #include <sys/cdefs.h>
     40 __KERNEL_RCSID(0, "$NetBSD: rasops4.c,v 1.3 2001/11/13 07:00:23 lukem Exp $");
     41 
     42 #include "opt_rasops.h"
     43 
     44 #include <sys/types.h>
     45 #include <sys/param.h>
     46 #include <sys/systm.h>
     47 #include <sys/time.h>
     48 #include <machine/endian.h>
     49 
     50 #include <dev/wscons/wsdisplayvar.h>
     51 #include <dev/wscons/wsconsio.h>
     52 #include <dev/rasops/rasops.h>
     53 #include <dev/rasops/rasops_masks.h>
     54 
     55 static void	rasops4_copycols __P((void *, int, int, int, int));
     56 static void	rasops4_erasecols __P((void *, int, int, int, long));
     57 static void	rasops4_do_cursor __P((struct rasops_info *));
     58 static void	rasops4_putchar __P((void *, int, int col, u_int, long));
     59 #ifndef RASOPS_SMALL
     60 static void	rasops4_putchar8 __P((void *, int, int col, u_int, long));
     61 static void	rasops4_putchar12 __P((void *, int, int col, u_int, long));
     62 static void	rasops4_putchar16 __P((void *, int, int col, u_int, long));
     63 static void	rasops4_makestamp __P((struct rasops_info *, long));
     64 
     65 /*
     66  * 4x1 stamp for optimized character blitting
     67  */
     68 static u_int16_t	stamp[16];
     69 static long	stamp_attr;
     70 static int	stamp_mutex;	/* XXX see note in README */
     71 #endif
     72 
     73 /*
     74  * Initialize rasops_info struct for this colordepth.
     75  */
     76 void
     77 rasops4_init(ri)
     78 	struct rasops_info *ri;
     79 {
     80 
     81 	switch (ri->ri_font->fontwidth) {
     82 #ifndef RASOPS_SMALL
     83 	case 8:
     84 		ri->ri_ops.putchar = rasops4_putchar8;
     85 		break;
     86 	case 12:
     87 		ri->ri_ops.putchar = rasops4_putchar12;
     88 		break;
     89 	case 16:
     90 		ri->ri_ops.putchar = rasops4_putchar16;
     91 		break;
     92 #endif	/* !RASOPS_SMALL */
     93 	default:
     94 		panic("fontwidth not 8/12/16 or RASOPS_SMALL - fixme!");
     95 		ri->ri_ops.putchar = rasops4_putchar;
     96 		break;
     97 	}
     98 
     99 	if ((ri->ri_font->fontwidth & 1) != 0) {
    100 		ri->ri_ops.erasecols = rasops4_erasecols;
    101 		ri->ri_ops.copycols = rasops4_copycols;
    102 		ri->ri_do_cursor = rasops4_do_cursor;
    103 	}
    104 }
    105 
    106 #ifdef notyet
    107 /*
    108  * Paint a single character. This is the generic version, this is ugly.
    109  */
    110 static void
    111 rasops4_putchar(cookie, row, col, uc, attr)
    112 	void *cookie;
    113 	int row, col;
    114 	u_int uc;
    115 	long attr;
    116 {
    117 	int height, width, fs, rs, fb, bg, fg, lmask, rmask;
    118 	struct rasops_info *ri;
    119 	int32_t *rp;
    120 	u_char *fr;
    121 
    122 	ri = (struct rasops_info *)cookie;
    123 
    124 #ifdef RASOPS_CLIPPING
    125 	/* Catches 'row < 0' case too */
    126 	if ((unsigned)row >= (unsigned)ri->ri_rows)
    127 		return;
    128 
    129 	if ((unsigned)col >= (unsigned)ri->ri_cols)
    130 		return;
    131 #endif
    132 
    133 	width = ri->ri_font->fontwidth << 1;
    134 	height = ri->ri_font->fontheight;
    135 	col *= width;
    136 	rp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale + ((col >> 3) & ~3));
    137 	col = col & 31;
    138 	rs = ri->ri_stride;
    139 
    140 	bg = ri->ri_devcmap[(attr >> 16) & 0xf];
    141 	fg = ri->ri_devcmap[(attr >> 24) & 0xf];
    142 
    143 	/* If fg and bg match this becomes a space character */
    144 	if (fg == bg || uc == ' ') {
    145 		uc = (u_int)-1;
    146 		fr = 0;		/* shutup gcc */
    147 		fs = 0;		/* shutup gcc */
    148 	} else {
    149 		uc -= ri->ri_font->firstchar;
    150 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    151 		fs = ri->ri_font->stride;
    152 	}
    153 
    154 	/* Single word, one mask */
    155 	if ((col + width) <= 32) {
    156 		rmask = rasops_pmask[col][width];
    157 		lmask = ~rmask;
    158 
    159 		if (uc == (u_int)-1) {
    160 			bg &= rmask;
    161 
    162 			while (height--) {
    163 				*rp = (*rp & lmask) | bg;
    164 				DELTA(rp, rs, int32_t *);
    165 			}
    166 		} else {
    167 			while (height--) {
    168 				/* get bits, mask */
    169 				/* compose sl */
    170 				/* mask sl */
    171 				/* put word */
    172 			}
    173 		}
    174 
    175 		/* Do underline */
    176 		if (attr & 1) {
    177 			DELTA(rp, -(ri->ri_stride << 1), int32_t *);
    178 			*rp = (*rp & lmask) | (fg & rmask);
    179 		}
    180 	} else {
    181 		lmask = ~rasops_lmask[col];
    182 		rmask = ~rasops_rmask[(col + width) & 31];
    183 
    184 		if (uc == (u_int)-1) {
    185 			bg = bg & ~lmask;
    186 			width = bg & ~rmask;
    187 
    188 			while (height--) {
    189 				rp[0] = (rp[0] & lmask) | bg;
    190 				rp[1] = (rp[1] & rmask) | width;
    191 				DELTA(rp, rs, int32_t *);
    192 			}
    193 		} else {
    194 			width = 32 - col;
    195 
    196 			/* NOT fontbits if bg is white */
    197 			while (height--) {
    198 				fb = ~(fr[3] | (fr[2] << 8) |
    199 				    (fr[1] << 16) | (fr[0] << 24));
    200 
    201 				rp[0] = (rp[0] & lmask)
    202 				    | MBE((u_int)fb >> col);
    203 
    204 				rp[1] = (rp[1] & rmask)
    205 				   | (MBE((u_int)fb << width) & ~rmask);
    206 
    207 				fr += fs;
    208 				DELTA(rp, rs, int32_t *);
    209 			}
    210 		}
    211 
    212 		/* Do underline */
    213 		if (attr & 1) {
    214 			DELTA(rp, -(ri->ri_stride << 1), int32_t *);
    215 			rp[0] = (rp[0] & lmask) | (fg & ~lmask);
    216 			rp[1] = (rp[1] & rmask) | (fg & ~rmask);
    217 		}
    218 	}
    219 }
    220 #endif
    221 
    222 /*
    223  * Put a single character. This is the generic version.
    224  */
    225 static void
    226 rasops4_putchar(cookie, row, col, uc, attr)
    227 	void *cookie;
    228 	int row, col;
    229 	u_int uc;
    230 	long attr;
    231 {
    232 
    233 	/* XXX punt */
    234 }
    235 
    236 #ifndef RASOPS_SMALL
    237 /*
    238  * Recompute the blitting stamp.
    239  */
    240 static void
    241 rasops4_makestamp(ri, attr)
    242 	struct rasops_info *ri;
    243 	long attr;
    244 {
    245 	int i, fg, bg;
    246 
    247 	fg = ri->ri_devcmap[(attr >> 24) & 0xf] & 0xf;
    248 	bg = ri->ri_devcmap[(attr >> 16) & 0xf] & 0xf;
    249 	stamp_attr = attr;
    250 
    251 	for (i = 0; i < 16; i++) {
    252 		stamp[i] =  (i & 1 ? fg : bg) << 8;
    253 		stamp[i] |= (i & 2 ? fg : bg) << 12;
    254 		stamp[i] |= (i & 4 ? fg : bg) << 0;
    255 		stamp[i] |= (i & 8 ? fg : bg) << 4;
    256 	}
    257 }
    258 
    259 /*
    260  * Put a single character. This is for 8-pixel wide fonts.
    261  */
    262 static void
    263 rasops4_putchar8(cookie, row, col, uc, attr)
    264 	void *cookie;
    265 	int row, col;
    266 	u_int uc;
    267 	long attr;
    268 {
    269 	struct rasops_info *ri;
    270 	int height, fs, rs;
    271 	u_char *fr;
    272 	u_int16_t *rp;
    273 
    274 	/* Can't risk remaking the stamp if it's already in use */
    275 	if (stamp_mutex++) {
    276 		stamp_mutex--;
    277 		rasops4_putchar(cookie, row, col, uc, attr);
    278 		return;
    279 	}
    280 
    281 	ri = (struct rasops_info *)cookie;
    282 
    283 #ifdef RASOPS_CLIPPING
    284 	/* Catches 'row < 0' case too */
    285 	if ((unsigned)row >= (unsigned)ri->ri_rows) {
    286 		stamp_mutex--;
    287 		return;
    288 	}
    289 
    290 	if ((unsigned)col >= (unsigned)ri->ri_cols) {
    291 		stamp_mutex--;
    292 		return;
    293 	}
    294 #endif
    295 
    296 	rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
    297 	height = ri->ri_font->fontheight;
    298 	rs = ri->ri_stride / sizeof(*rp);
    299 
    300 	/* Recompute stamp? */
    301 	if (attr != stamp_attr)
    302 		rasops4_makestamp(ri, attr);
    303 
    304 	if (uc == ' ') {
    305 		u_int16_t c = stamp[0];
    306 		while (height--) {
    307 			rp[0] = c;
    308 			rp[1] = c;
    309 			rp += rs;
    310 		}
    311 	} else {
    312 		uc -= ri->ri_font->firstchar;
    313 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    314 		fs = ri->ri_font->stride;
    315 
    316 		while (height--) {
    317 			rp[0] = stamp[(*fr >> 4) & 0xf];
    318 			rp[1] = stamp[*fr & 0xf];
    319 			fr += fs;
    320 			rp += rs;
    321 		}
    322 	}
    323 
    324 	/* Do underline */
    325 	if ((attr & 1) != 0) {
    326 		rp -= (rs << 1);
    327 		rp[0] = stamp[15];
    328 		rp[1] = stamp[15];
    329 	}
    330 
    331 	stamp_mutex--;
    332 }
    333 
    334 /*
    335  * Put a single character. This is for 12-pixel wide fonts.
    336  */
    337 static void
    338 rasops4_putchar12(cookie, row, col, uc, attr)
    339 	void *cookie;
    340 	int row, col;
    341 	u_int uc;
    342 	long attr;
    343 {
    344 	struct rasops_info *ri;
    345 	int height, fs, rs;
    346 	u_char *fr;
    347 	u_int16_t *rp;
    348 
    349 	/* Can't risk remaking the stamp if it's already in use */
    350 	if (stamp_mutex++) {
    351 		stamp_mutex--;
    352 		rasops4_putchar(cookie, row, col, uc, attr);
    353 		return;
    354 	}
    355 
    356 	ri = (struct rasops_info *)cookie;
    357 
    358 #ifdef RASOPS_CLIPPING
    359 	/* Catches 'row < 0' case too */
    360 	if ((unsigned)row >= (unsigned)ri->ri_rows) {
    361 		stamp_mutex--;
    362 		return;
    363 	}
    364 
    365 	if ((unsigned)col >= (unsigned)ri->ri_cols) {
    366 		stamp_mutex--;
    367 		return;
    368 	}
    369 #endif
    370 
    371 	rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
    372 	height = ri->ri_font->fontheight;
    373 	rs = ri->ri_stride / sizeof(*rp);
    374 
    375 	/* Recompute stamp? */
    376 	if (attr != stamp_attr)
    377 		rasops4_makestamp(ri, attr);
    378 
    379 	if (uc == ' ') {
    380 		u_int16_t c = stamp[0];
    381 		while (height--) {
    382 			rp[0] = c;
    383 			rp[1] = c;
    384 			rp[2] = c;
    385 			rp += rs;
    386 		}
    387 	} else {
    388 		uc -= ri->ri_font->firstchar;
    389 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    390 		fs = ri->ri_font->stride;
    391 
    392 		while (height--) {
    393 			rp[0] = stamp[(fr[0] >> 4) & 0xf];
    394 			rp[1] = stamp[fr[0] & 0xf];
    395 			rp[2] = stamp[(fr[1] >> 4) & 0xf];
    396 			fr += fs;
    397 			rp += rs;
    398 		}
    399 	}
    400 
    401 	/* Do underline */
    402 	if ((attr & 1) != 0) {
    403 		rp -= (rs << 1);
    404 		rp[0] = stamp[15];
    405 		rp[1] = stamp[15];
    406 		rp[2] = stamp[15];
    407 	}
    408 
    409 	stamp_mutex--;
    410 }
    411 
    412 /*
    413  * Put a single character. This is for 16-pixel wide fonts.
    414  */
    415 static void
    416 rasops4_putchar16(cookie, row, col, uc, attr)
    417 	void *cookie;
    418 	int row, col;
    419 	u_int uc;
    420 	long attr;
    421 {
    422 	struct rasops_info *ri;
    423 	int height, fs, rs;
    424 	u_char *fr;
    425 	u_int16_t *rp;
    426 
    427 	/* Can't risk remaking the stamp if it's already in use */
    428 	if (stamp_mutex++) {
    429 		stamp_mutex--;
    430 		rasops4_putchar(cookie, row, col, uc, attr);
    431 		return;
    432 	}
    433 
    434 	ri = (struct rasops_info *)cookie;
    435 
    436 #ifdef RASOPS_CLIPPING
    437 	/* Catches 'row < 0' case too */
    438 	if ((unsigned)row >= (unsigned)ri->ri_rows) {
    439 		stamp_mutex--;
    440 		return;
    441 	}
    442 
    443 	if ((unsigned)col >= (unsigned)ri->ri_cols) {
    444 		stamp_mutex--;
    445 		return;
    446 	}
    447 #endif
    448 
    449 	rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
    450 	height = ri->ri_font->fontheight;
    451 	rs = ri->ri_stride / sizeof(*rp);
    452 
    453 	/* Recompute stamp? */
    454 	if (attr != stamp_attr)
    455 		rasops4_makestamp(ri, attr);
    456 
    457 	if (uc == ' ') {
    458 		u_int16_t c = stamp[0];
    459 		while (height--) {
    460 			rp[0] = c;
    461 			rp[1] = c;
    462 			rp[2] = c;
    463 			rp[3] = c;
    464 			rp += rs;
    465 		}
    466 	} else {
    467 		uc -= ri->ri_font->firstchar;
    468 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    469 		fs = ri->ri_font->stride;
    470 
    471 		while (height--) {
    472 			rp[0] = stamp[(fr[0] >> 4) & 0xf];
    473 			rp[1] = stamp[fr[0] & 0xf];
    474 			rp[2] = stamp[(fr[1] >> 4) & 0xf];
    475 			rp[3] = stamp[fr[1] & 0xf];
    476 			fr += fs;
    477 			rp += rs;
    478 		}
    479 	}
    480 
    481 	/* Do underline */
    482 	if ((attr & 1) != 0) {
    483 		rp -= (rs << 1);
    484 		rp[0] = stamp[15];
    485 		rp[1] = stamp[15];
    486 		rp[2] = stamp[15];
    487 		rp[3] = stamp[15];
    488 	}
    489 
    490 	stamp_mutex--;
    491 }
    492 #endif	/* !RASOPS_SMALL */
    493 
    494 /*
    495  * Grab routines common to depths where (bpp < 8)
    496  */
    497 #define NAME(ident)	rasops4_##ident
    498 #define PIXEL_SHIFT	3
    499 
    500 #include <dev/rasops/rasops_bitops.h>
    501