root/dev/rasops/rasops2.c

DEFINITIONS

1. rasops2_init
2. rasops2_mergebits
3. rasops2_putchar
4. rasops2_makestamp
5. rasops2_putchar8
6. rasops2_putchar12
7. rasops2_putchar16

    1 /*      $OpenBSD: rasops2.c,v 1.7 2006/08/03 18:42:06 miod Exp $        */
    2 /*      $NetBSD: rasops2.c,v 1.5 2000/04/12 14:22:29 pk Exp $   */
    4 /*-
    5  * Copyright (c) 1999 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Andrew Doran.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *      This product includes software developed by the NetBSD
   22  *      Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/time.h>
   43 #include <machine/endian.h>
   45 #include <dev/wscons/wsdisplayvar.h>
   46 #include <dev/wscons/wsconsio.h>
   47 #include <dev/rasops/rasops.h>
   48 #include <dev/rasops/rasops_masks.h>
   50 void    rasops2_copycols(void *, int, int, int, int);
   51 void    rasops2_erasecols(void *, int, int, int, long);
   52 void    rasops2_do_cursor(struct rasops_info *);
   53 void    rasops2_putchar(void *, int, int col, u_int, long);
u_int   rasops2_mergebits(u_char *, int, int);
   55 #ifndef RASOPS_SMALL
   56 void    rasops2_putchar8(void *, int, int col, u_int, long);
   57 void    rasops2_putchar12(void *, int, int col, u_int, long);
   58 void    rasops2_putchar16(void *, int, int col, u_int, long);
   59 void    rasops2_makestamp(struct rasops_info *, long);
   61 /*
   62  * 4x1 stamp for optimized character blitting
   63  */
   64 static int8_t   stamp[16];
   65 static long     stamp_attr;
   66 static int      stamp_mutex;    /* XXX see note in README */
   67 #endif
   69 /*
   70  * Initialize rasops_info struct for this colordepth.
   71  */
   72 void
rasops2_init(ri)
   74         struct rasops_info *ri;
   75 {
rasops_masks_init();
   78         switch (ri->ri_font->fontwidth) {
   79 #ifndef RASOPS_SMALL
   80         case 8:
ri->ri_ops.putchar = rasops2_putchar8;
   82                 break;
   83         case 12:
ri->ri_ops.putchar = rasops2_putchar12;
   85                 break;
   86         case 16:
ri->ri_ops.putchar = rasops2_putchar16;
   88                 break;
   89 #endif  /* !RASOPS_SMALL */
   90         default:
ri->ri_ops.putchar = rasops2_putchar;
   92                 break;
   93         }
   95         if ((ri->ri_font->fontwidth & 3) != 0) {
ri->ri_ops.erasecols = rasops2_erasecols;
ri->ri_ops.copycols = rasops2_copycols;
ri->ri_do_cursor = rasops2_do_cursor;
   99         }
  100 }
  102 /*
  103  * Compute a 2bpp expansion of a font element against the given colors.
  104  * Used by rasops2_putchar() below.
  105  */
u_int
rasops2_mergebits(u_char *fr, int fg, int bg)
  108 {
u_int fb, bits;
  110         int mask, shift;
fg &= 3;
bg &= 3;
bits = fr[1] | (fr[0] << 8);
fb = 0;
  117         for (mask = 0x8000, shift = 32 - 2; mask != 0; mask >>= 1, shift -= 2)
fb |= (bits & mask ? fg : bg) << shift;
  120         return (fb);
  121 }
  123 /*
  124  * Paint a single character. This is the generic version, this is ugly.
  125  */
  126 void
rasops2_putchar(cookie, row, col, uc, attr)
  128         void *cookie;
  129         int row, col;
u_int uc;
  131         long attr;
  132 {
  133         int height, width, fs, rs, bg, fg, lmask, rmask;
u_int fb;
  135         struct rasops_info *ri;
int32_t *rp;
u_char *fr;
ri = (struct rasops_info *)cookie;
  141 #ifdef RASOPS_CLIPPING
  142         /* Catches 'row < 0' case too */
  143         if ((unsigned)row >= (unsigned)ri->ri_rows)
  144                 return;
  146         if ((unsigned)col >= (unsigned)ri->ri_cols)
  147                 return;
  148 #endif
width = ri->ri_font->fontwidth << 1;
height = ri->ri_font->fontheight;
col *= width;
rp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale + ((col >> 3) & ~3));
col = col & 31;
rs = ri->ri_stride;
bg = ri->ri_devcmap[(attr >> 16) & 0xf];
fg = ri->ri_devcmap[(attr >> 24) & 0xf];
  160         /* If fg and bg match this becomes a space character */
  161         if (fg == bg || uc == ' ') {
uc = (u_int)-1;
fr = 0;         /* shutup gcc */
fs = 0;         /* shutup gcc */
  165         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  169         }
  171         /* Single word, one mask */
  172         if ((col + width) <= 32) {
rmask = rasops_pmask[col][width];
lmask = ~rmask;
  176                 if (uc == (u_int)-1) {
bg &= rmask;
  179                         while (height--) {
  180                                 *rp = (*rp & lmask) | bg;
DELTA(rp, rs, int32_t *);
  182                         }
  183                 } else {
  184                         while (height--) {
fb = rasops2_mergebits(fr, fg, bg);
  186                                 *rp = (*rp & lmask) |
  187                                     (MBE(fb >> col) & rmask);
fr += fs;
DELTA(rp, rs, int32_t *);
  191                         }
  192                 }
  194                 /* Do underline */
  195                 if (attr & 1) {
DELTA(rp, -(ri->ri_stride << 1), int32_t *);
  197                         *rp = (*rp & lmask) | (fg & rmask);
  198                 }
  199         } else {
lmask = ~rasops_lmask[col];
rmask = ~rasops_rmask[(col + width) & 31];
  203                 if (uc == (u_int)-1) {
width = bg & ~rmask;
bg = bg & ~lmask;
  207                         while (height--) {
rp[0] = (rp[0] & lmask) | bg;
rp[1] = (rp[1] & rmask) | width;
DELTA(rp, rs, int32_t *);
  211                         }
  212                 } else {
width = 32 - col;
  215                         while (height--) {
fb = rasops2_mergebits(fr, fg, bg);
rp[0] = (rp[0] & lmask) |
MBE(fb >> col);
rp[1] = (rp[1] & rmask) |
  221                                     (MBE(fb << width) & ~rmask);
fr += fs;
DELTA(rp, rs, int32_t *);
  225                         }
  226                 }
  228                 /* Do underline */
  229                 if (attr & 1) {
DELTA(rp, -(ri->ri_stride << 1), int32_t *);
rp[0] = (rp[0] & lmask) | (fg & ~lmask);
rp[1] = (rp[1] & rmask) | (fg & ~rmask);
  233                 }
  234         }
  235 }
  237 #ifndef RASOPS_SMALL
  238 /*
  239  * Recompute the blitting stamp.
  240  */
  241 void
rasops2_makestamp(ri, attr)
  243         struct rasops_info *ri;
  244         long attr;
  245 {
  246         int i, fg, bg;
fg = ri->ri_devcmap[(attr >> 24) & 0xf] & 3;
bg = ri->ri_devcmap[(attr >> 16) & 0xf] & 3;
stamp_attr = attr;
  252         for (i = 0; i < 16; i++) {
stamp[i] = (i & 1 ? fg : bg);
stamp[i] |= (i & 2 ? fg : bg) << 2;
stamp[i] |= (i & 4 ? fg : bg) << 4;
stamp[i] |= (i & 8 ? fg : bg) << 6;
  257         }
  258 }
  260 /*
  261  * Put a single character. This is for 8-pixel wide fonts.
  262  */
  263 void
rasops2_putchar8(cookie, row, col, uc, attr)
  265         void *cookie;
  266         int row, col;
u_int uc;
  268         long attr;
  269 {
  270         struct rasops_info *ri;
  271         int height, fs, rs;
u_char *fr, *rp;
  274         /* Can't risk remaking the stamp if it's already in use */
  275         if (stamp_mutex++) {
stamp_mutex--;
rasops2_putchar(cookie, row, col, uc, attr);
  278                 return;
  279         }
ri = (struct rasops_info *)cookie;
  283 #ifdef RASOPS_CLIPPING
  284         /* Catches 'row < 0' case too */
  285         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  287                 return;
  288         }
  290         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  292                 return;
  293         }
  294 #endif
rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
height = ri->ri_font->fontheight;
rs = ri->ri_stride;
  300         /* Recompute stamp? */
  301         if (attr != stamp_attr)
rasops2_makestamp(ri, attr);
  304         if (uc == ' ') {
int8_t c = stamp[0];
  306                 while (height--) {
  307                         *(int16_t *)rp = c;
rp += rs;
  309                 }
  310         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  315                 while (height--) {
rp[0] = stamp[(*fr >> 4) & 0xf];
rp[1] = stamp[*fr & 0xf];
fr += fs;
rp += rs;
  320                 }
  321         }
  323         /* Do underline */
  324         if ((attr & 1) != 0)
  325                 *(int16_t *)(rp - (ri->ri_stride << 1)) = stamp[15];
stamp_mutex--;
  328 }
  330 /*
  331  * Put a single character. This is for 12-pixel wide fonts.
  332  */
  333 void
rasops2_putchar12(cookie, row, col, uc, attr)
  335         void *cookie;
  336         int row, col;
u_int uc;
  338         long attr;
  339 {
  340         struct rasops_info *ri;
  341         int height, fs, rs;
u_char *fr, *rp;
  344         /* Can't risk remaking the stamp if it's already in use */
  345         if (stamp_mutex++) {
stamp_mutex--;
rasops2_putchar(cookie, row, col, uc, attr);
  348                 return;
  349         }
ri = (struct rasops_info *)cookie;
  353 #ifdef RASOPS_CLIPPING
  354         /* Catches 'row < 0' case too */
  355         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  357                 return;
  358         }
  360         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  362                 return;
  363         }
  364 #endif
rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
height = ri->ri_font->fontheight;
rs = ri->ri_stride;
  370         /* Recompute stamp? */
  371         if (attr != stamp_attr)
rasops2_makestamp(ri, attr);
  374         if (uc == ' ') {
int8_t c = stamp[0];
  376                 while (height--) {
rp[0] = rp[1] = rp[2] = c;
rp += rs;
  379                 }
  380         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  385                 while (height--) {
rp[0] = stamp[(fr[0] >> 4) & 0xf];
rp[1] = stamp[fr[0] & 0xf];
rp[2] = stamp[(fr[1] >> 4) & 0xf];
fr += fs;
rp += rs;
  391                 }
  392         }
  394         /* Do underline */
  395         if ((attr & 1) != 0) {
rp -= ri->ri_stride << 1;
rp[0] = rp[1] = rp[2] = stamp[15];
  398         }
stamp_mutex--;
  401 }
  403 /*
  404  * Put a single character. This is for 16-pixel wide fonts.
  405  */
  406 void
rasops2_putchar16(cookie, row, col, uc, attr)
  408         void *cookie;
  409         int row, col;
u_int uc;
  411         long attr;
  412 {
  413         struct rasops_info *ri;
  414         int height, fs, rs;
u_char *fr, *rp;
  417         /* Can't risk remaking the stamp if it's already in use */
  418         if (stamp_mutex++) {
stamp_mutex--;
rasops2_putchar(cookie, row, col, uc, attr);
  421                 return;
  422         }
ri = (struct rasops_info *)cookie;
  426 #ifdef RASOPS_CLIPPING
  427         /* Catches 'row < 0' case too */
  428         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  430                 return;
  431         }
  433         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  435                 return;
  436         }
  437 #endif
rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
height = ri->ri_font->fontheight;
rs = ri->ri_stride;
  443         /* Recompute stamp? */
  444         if (attr != stamp_attr)
rasops2_makestamp(ri, attr);
  447         if (uc == ' ') {
int8_t c = stamp[0];
  449                 while (height--) {
  450                         *(int32_t *)rp = c;
rp += rs;
  452                 }
  453         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  458                 while (height--) {
rp[0] = stamp[(fr[0] >> 4) & 0xf];
rp[1] = stamp[fr[0] & 0xf];
rp[2] = stamp[(fr[1] >> 4) & 0xf];
rp[3] = stamp[fr[1] & 0xf];
fr += fs;
rp += rs;
  465                 }
  466         }
  468         /* Do underline */
  469         if ((attr & 1) != 0)
  470                 *(int32_t *)(rp - (ri->ri_stride << 1)) = stamp[15];
stamp_mutex--;
  473 }
  474 #endif  /* !RASOPS_SMALL */
  476 /*
  477  * Grab routines common to depths where (bpp < 8)
  478  */
  479 #define NAME(ident)     rasops2_##ident
  480 #define PIXEL_SHIFT     1
  482 #include <dev/rasops/rasops_bitops.h>