root/dev/rasops/rasops8.c

DEFINITIONS

1. rasops8_init
2. rasops8_putchar
3. rasops8_makestamp
4. rasops8_putchar8
5. rasops8_putchar12
6. rasops8_putchar16

    1 /*      $OpenBSD: rasops8.c,v 1.7 2006/12/02 15:55:18 miod Exp $        */
    2 /*      $NetBSD: rasops8.c,v 1.8 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>
   44 #include <dev/wscons/wsdisplayvar.h>
   45 #include <dev/wscons/wsconsio.h>
   46 #include <dev/rasops/rasops.h>
   48 void    rasops8_putchar(void *, int, int, u_int, long attr);
   49 #ifndef RASOPS_SMALL
   50 void    rasops8_putchar8(void *, int, int, u_int, long attr);
   51 void    rasops8_putchar12(void *, int, int, u_int, long attr);
   52 void    rasops8_putchar16(void *, int, int, u_int, long attr);
   53 void    rasops8_makestamp(struct rasops_info *ri, long);
   55 /*
   56  * 4x1 stamp for optimized character blitting
   57  */
   58 static int32_t  stamp[16];
   59 static long     stamp_attr;
   60 static int      stamp_mutex;    /* XXX see note in README */
   61 #endif
   63 /*
   64  * XXX this confuses the hell out of gcc2 (not egcs) which always insists
   65  * that the shift count is negative.
   66  *
   67  * offset = STAMP_SHIFT(fontbits, nibble #) & STAMP_MASK
   68  * destination = STAMP_READ(offset)
   69  */
   70 #define STAMP_SHIFT(fb,n)       ((n*4-2) >= 0 ? (fb)>>(n*4-2):(fb)<<-(n*4-2))
   71 #define STAMP_MASK              (0xf << 2)
   72 #define STAMP_READ(o)           (*(int32_t *)((caddr_t)stamp + (o)))
   74 /*
   75  * Initialize a 'rasops_info' descriptor for this depth.
   76  */
   77 void
rasops8_init(ri)
   79         struct rasops_info *ri;
   80 {
   82         switch (ri->ri_font->fontwidth) {
   83 #ifndef RASOPS_SMALL
   84         case 8:
ri->ri_ops.putchar = rasops8_putchar8;
   86                 break;
   87         case 12:
ri->ri_ops.putchar = rasops8_putchar12;
   89                 break;
   90         case 16:
ri->ri_ops.putchar = rasops8_putchar16;
   92                 break;
   93 #endif /* !RASOPS_SMALL */
   94         default:
ri->ri_ops.putchar = rasops8_putchar;
   96                 break;
   97         }
   98 }
  100 /*
  101  * Put a single character.
  102  */
  103 void
rasops8_putchar(cookie, row, col, uc, attr)
  105         void *cookie;
  106         int row, col;
u_int uc;
  108         long attr;
  109 {
  110         int width, height, cnt, fs, fb;
u_char *dp, *rp, *fr, clr[2];
  112         struct rasops_info *ri;
ri = (struct rasops_info *)cookie;
  116 #ifdef RASOPS_CLIPPING
  117         /* Catches 'row < 0' case too */
  118         if ((unsigned)row >= (unsigned)ri->ri_rows)
  119                 return;
  121         if ((unsigned)col >= (unsigned)ri->ri_cols)
  122                 return;
  123 #endif
rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
height = ri->ri_font->fontheight;
width = ri->ri_font->fontwidth;
clr[0] = (u_char)ri->ri_devcmap[(attr >> 16) & 0xf];
clr[1] = (u_char)ri->ri_devcmap[(attr >> 24) & 0xf];
  131         if (uc == ' ') {
u_char c = clr[0];
  134                 while (height--) {
dp = rp;
rp += ri->ri_stride;
  138                         for (cnt = width; cnt; cnt--)
  139                                 *dp++ = c;
  140                 }
  141         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  146                 while (height--) {
dp = rp;
fb = fr[3] | (fr[2] << 8) | (fr[1] << 16) | (fr[0] << 24);
fr += fs;
rp += ri->ri_stride;
  152                         for (cnt = width; cnt; cnt--) {
  153                                 *dp++ = clr[(fb >> 31) & 1];
fb <<= 1;
  155                         }
  156                 }
  157         }
  159         /* Do underline */
  160         if ((attr & 1) != 0) {
u_char c = clr[1];
rp -= (ri->ri_stride << 1);
  165                 while (width--)
  166                         *rp++ = c;
  167         }
  168 }
  170 #ifndef RASOPS_SMALL
  171 /*
  172  * Recompute the 4x1 blitting stamp.
  173  */
  174 void
rasops8_makestamp(ri, attr)
  176         struct rasops_info *ri;
  177         long attr;
  178 {
int32_t fg, bg;
  180         int i;
fg = ri->ri_devcmap[(attr >> 24) & 0xf] & 0xff;
bg = ri->ri_devcmap[(attr >> 16) & 0xf] & 0xff;
stamp_attr = attr;
  186         for (i = 0; i < 16; i++) {
  187 #if BYTE_ORDER == LITTLE_ENDIAN
stamp[i] = (i & 8 ? fg : bg);
stamp[i] |= ((i & 4 ? fg : bg) << 8);
stamp[i] |= ((i & 2 ? fg : bg) << 16);
stamp[i] |= ((i & 1 ? fg : bg) << 24);
  192 #else
stamp[i] = (i & 1 ? fg : bg);
stamp[i] |= ((i & 2 ? fg : bg) << 8);
stamp[i] |= ((i & 4 ? fg : bg) << 16);
stamp[i] |= ((i & 8 ? fg : bg) << 24);
  197 #endif
  198 #if NRASOPS_BSWAP > 0
  199                 if (ri->ri_flg & RI_BSWAP)
stamp[i] = swap32(stamp[i]);
  201 #endif
  202         }
  203 }
  205 /*
  206  * Put a single character. This is for 8-pixel wide fonts.
  207  */
  208 void
rasops8_putchar8(cookie, row, col, uc, attr)
  210         void *cookie;
  211         int row, col;
u_int uc;
  213         long attr;
  214 {
  215         struct rasops_info *ri;
  216         int height, fs;
int32_t *rp;
u_char *fr;
  220         /* Can't risk remaking the stamp if it's already in use */
  221         if (stamp_mutex++) {
stamp_mutex--;
rasops8_putchar(cookie, row, col, uc, attr);
  224                 return;
  225         }
ri = (struct rasops_info *)cookie;
  229 #ifdef RASOPS_CLIPPING
  230         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  232                 return;
  233         }
  235         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  237                 return;
  238         }
  239 #endif
  241         /* Recompute stamp? */
  242         if (attr != stamp_attr)
rasops8_makestamp(ri, attr);
rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
height = ri->ri_font->fontheight;
  248         if (uc == ' ') {
  249                 while (height--) {
rp[0] = rp[1] = stamp[0];
DELTA(rp, ri->ri_stride, int32_t *);
  252                 }
  253         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  258                 while (height--) {
rp[0] = STAMP_READ(STAMP_SHIFT(fr[0], 1) & STAMP_MASK);
rp[1] = STAMP_READ(STAMP_SHIFT(fr[0], 0) & STAMP_MASK);
fr += fs;
DELTA(rp, ri->ri_stride, int32_t *);
  264                 }
  265         }
  267         /* Do underline */
  268         if ((attr & 1) != 0) {
DELTA(rp, -(ri->ri_stride << 1), int32_t *);
rp[0] = rp[1] = stamp[15];
  271         }
stamp_mutex--;
  274 }
  276 /*
  277  * Put a single character. This is for 12-pixel wide fonts.
  278  */
  279 void
rasops8_putchar12(cookie, row, col, uc, attr)
  281         void *cookie;
  282         int row, col;
u_int uc;
  284         long attr;
  285 {
  286         struct rasops_info *ri;
  287         int height, fs;
int32_t *rp;
u_char *fr;
  291         /* Can't risk remaking the stamp if it's already in use */
  292         if (stamp_mutex++) {
stamp_mutex--;
rasops8_putchar(cookie, row, col, uc, attr);
  295                 return;
  296         }
ri = (struct rasops_info *)cookie;
  300 #ifdef RASOPS_CLIPPING
  301         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  303                 return;
  304         }
  306         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  308                 return;
  309         }
  310 #endif
  312         /* Recompute stamp? */
  313         if (attr != stamp_attr)
rasops8_makestamp(ri, attr);
rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
height = ri->ri_font->fontheight;
  319         if (uc == ' ') {
  320                 while (height--) {
int32_t c = stamp[0];
rp[0] = rp[1] = rp[2] = c;
DELTA(rp, ri->ri_stride, int32_t *);
  325                 }
  326         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  331                 while (height--) {
rp[0] = STAMP_READ(STAMP_SHIFT(fr[0], 1) & STAMP_MASK);
rp[1] = STAMP_READ(STAMP_SHIFT(fr[0], 0) & STAMP_MASK);
rp[2] = STAMP_READ(STAMP_SHIFT(fr[1], 1) & STAMP_MASK);
fr += fs;
DELTA(rp, ri->ri_stride, int32_t *);
  338                 }
  339         }
  341         /* Do underline */
  342         if ((attr & 1) != 0) {
DELTA(rp, -(ri->ri_stride << 1), int32_t *);
rp[0] = rp[1] = rp[2] = stamp[15];
  345         }
stamp_mutex--;
  348 }
  350 /*
  351  * Put a single character. This is for 16-pixel wide fonts.
  352  */
  353 void
rasops8_putchar16(cookie, row, col, uc, attr)
  355         void *cookie;
  356         int row, col;
u_int uc;
  358         long attr;
  359 {
  360         struct rasops_info *ri;
  361         int height, fs;
int32_t *rp;
u_char *fr;
  365         /* Can't risk remaking the stamp if it's already in use */
  366         if (stamp_mutex++) {
stamp_mutex--;
rasops8_putchar(cookie, row, col, uc, attr);
  369                 return;
  370         }
ri = (struct rasops_info *)cookie;
  374 #ifdef RASOPS_CLIPPING
  375         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  377                 return;
  378         }
  380         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  382                 return;
  383         }
  384 #endif
  386         /* Recompute stamp? */
  387         if (attr != stamp_attr)
rasops8_makestamp(ri, attr);
rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
height = ri->ri_font->fontheight;
  393         if (uc == ' ') {
  394                 while (height--)
rp[0] = rp[1] = rp[2] = rp[3] = stamp[0];
  396         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  401                 while (height--) {
rp[0] = STAMP_READ(STAMP_SHIFT(fr[0], 1) & STAMP_MASK);
rp[1] = STAMP_READ(STAMP_SHIFT(fr[0], 0) & STAMP_MASK);
rp[2] = STAMP_READ(STAMP_SHIFT(fr[1], 1) & STAMP_MASK);
rp[3] = STAMP_READ(STAMP_SHIFT(fr[1], 0) & STAMP_MASK);
fr += fs;
DELTA(rp, ri->ri_stride, int32_t *);
  409                 }
  410         }
  412         /* Do underline */
  413         if ((attr & 1) != 0) {
DELTA(rp, -(ri->ri_stride << 1), int32_t *);
rp[0] = rp[1] = rp[2] = rp[3] = stamp[15];
  416         }
stamp_mutex--;
  419 }
  420 #endif /* !RASOPS_SMALL */