root/dev/rasops/rasops4.c

DEFINITIONS

1. rasops4_init
2. rasops4_putchar
3. rasops4_putchar
4. rasops4_makestamp
5. rasops4_putchar8
6. rasops4_putchar12
7. rasops4_putchar16

    1 /*      $OpenBSD: rasops4.c,v 1.7 2006/08/03 18:42:06 miod Exp $        */
    2 /*      $NetBSD: rasops4.c,v 1.4 2001/11/15 09:48:15 lukem 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    rasops4_copycols(void *, int, int, int, int);
   51 void    rasops4_erasecols(void *, int, int, int, long);
   52 void    rasops4_do_cursor(struct rasops_info *);
   53 void    rasops4_putchar(void *, int, int col, u_int, long);
   54 #ifndef RASOPS_SMALL
   55 void    rasops4_putchar8(void *, int, int col, u_int, long);
   56 void    rasops4_putchar12(void *, int, int col, u_int, long);
   57 void    rasops4_putchar16(void *, int, int col, u_int, long);
   58 void    rasops4_makestamp(struct rasops_info *, long);
   60 /*
   61  * 4x1 stamp for optimized character blitting
   62  */
   63 static u_int16_t        stamp[16];
   64 static long     stamp_attr;
   65 static int      stamp_mutex;    /* XXX see note in README */
   66 #endif
   68 /*
   69  * Initialize rasops_info struct for this colordepth.
   70  */
   71 void
rasops4_init(ri)
   73         struct rasops_info *ri;
   74 {
rasops_masks_init();
   77         switch (ri->ri_font->fontwidth) {
   78 #ifndef RASOPS_SMALL
   79         case 8:
ri->ri_ops.putchar = rasops4_putchar8;
   81                 break;
   82         case 12:
ri->ri_ops.putchar = rasops4_putchar12;
   84                 break;
   85         case 16:
ri->ri_ops.putchar = rasops4_putchar16;
   87                 break;
   88 #endif  /* !RASOPS_SMALL */
   89         default:
panic("fontwidth not 8/12/16 or RASOPS_SMALL - fixme!");
ri->ri_ops.putchar = rasops4_putchar;
   92                 break;
   93         }
   95         if ((ri->ri_font->fontwidth & 1) != 0) {
ri->ri_ops.erasecols = rasops4_erasecols;
ri->ri_ops.copycols = rasops4_copycols;
ri->ri_do_cursor = rasops4_do_cursor;
   99         }
  100 }
  102 #ifdef notyet
  103 /*
  104  * Paint a single character. This is the generic version, this is ugly.
  105  */
  106 void
rasops4_putchar(cookie, row, col, uc, attr)
  108         void *cookie;
  109         int row, col;
u_int uc;
  111         long attr;
  112 {
  113         int height, width, fs, rs, fb, bg, fg, lmask, rmask;
  114         struct rasops_info *ri;
int32_t *rp;
u_char *fr;
ri = (struct rasops_info *)cookie;
  120 #ifdef RASOPS_CLIPPING
  121         /* Catches 'row < 0' case too */
  122         if ((unsigned)row >= (unsigned)ri->ri_rows)
  123                 return;
  125         if ((unsigned)col >= (unsigned)ri->ri_cols)
  126                 return;
  127 #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];
  139         /* If fg and bg match this becomes a space character */
  140         if (fg == bg || uc == ' ') {
uc = (u_int)-1;
fr = 0;         /* shutup gcc */
fs = 0;         /* shutup gcc */
  144         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  148         }
  150         /* Single word, one mask */
  151         if ((col + width) <= 32) {
rmask = rasops_pmask[col][width];
lmask = ~rmask;
  155                 if (uc == (u_int)-1) {
bg &= rmask;
  158                         while (height--) {
  159                                 *rp = (*rp & lmask) | bg;
DELTA(rp, rs, int32_t *);
  161                         }
  162                 } else {
  163                         while (height--) {
  164                                 /* get bits, mask */
  165                                 /* compose sl */
  166                                 /* mask sl */
  167                                 /* put word */
  168                         }
  169                 }
  171                 /* Do underline */
  172                 if (attr & 1) {
DELTA(rp, -(ri->ri_stride << 1), int32_t *);
  174                         *rp = (*rp & lmask) | (fg & rmask);
  175                 }
  176         } else {
lmask = ~rasops_lmask[col];
rmask = ~rasops_rmask[(col + width) & 31];
  180                 if (uc == (u_int)-1) {
bg = bg & ~lmask;
width = bg & ~rmask;
  184                         while (height--) {
rp[0] = (rp[0] & lmask) | bg;
rp[1] = (rp[1] & rmask) | width;
DELTA(rp, rs, int32_t *);
  188                         }
  189                 } else {
width = 32 - col;
  192                         /* NOT fontbits if bg is white */
  193                         while (height--) {
fb = ~(fr[3] | (fr[2] << 8) |
  195                                     (fr[1] << 16) | (fr[0] << 24));
rp[0] = (rp[0] & lmask)
  198                                     | MBE((u_int)fb >> col);
rp[1] = (rp[1] & rmask)
  201                                    | (MBE((u_int)fb << width) & ~rmask);
fr += fs;
DELTA(rp, rs, int32_t *);
  205                         }
  206                 }
  208                 /* Do underline */
  209                 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);
  213                 }
  214         }
  215 }
  216 #endif
  218 /*
  219  * Put a single character. This is the generic version.
  220  */
  221 void
rasops4_putchar(cookie, row, col, uc, attr)
  223         void *cookie;
  224         int row, col;
u_int uc;
  226         long attr;
  227 {
  229         /* XXX punt */
  230 }
  232 #ifndef RASOPS_SMALL
  233 /*
  234  * Recompute the blitting stamp.
  235  */
  236 void
rasops4_makestamp(ri, attr)
  238         struct rasops_info *ri;
  239         long attr;
  240 {
  241         int i, fg, bg;
fg = ri->ri_devcmap[(attr >> 24) & 0xf] & 0xf;
bg = ri->ri_devcmap[(attr >> 16) & 0xf] & 0xf;
stamp_attr = attr;
  247         for (i = 0; i < 16; i++) {
  248 #if BYTE_ORDER == LITTLE_ENDIAN
stamp[i] =  (i & 1 ? fg : bg) << 8;
stamp[i] |= (i & 2 ? fg : bg) << 12;
stamp[i] |= (i & 4 ? fg : bg) << 0;
stamp[i] |= (i & 8 ? fg : bg) << 4;
  253 #else
stamp[i] =  (i & 1 ? fg : bg) << 0;
stamp[i] |= (i & 2 ? fg : bg) << 4;
stamp[i] |= (i & 4 ? fg : bg) << 8;
stamp[i] |= (i & 8 ? fg : bg) << 12;
  258 #endif
  259         }
  260 }
  262 /*
  263  * Put a single character. This is for 8-pixel wide fonts.
  264  */
  265 void
rasops4_putchar8(cookie, row, col, uc, attr)
  267         void *cookie;
  268         int row, col;
u_int uc;
  270         long attr;
  271 {
  272         struct rasops_info *ri;
  273         int height, fs, rs;
u_char *fr;
u_int16_t *rp;
  277         /* Can't risk remaking the stamp if it's already in use */
  278         if (stamp_mutex++) {
stamp_mutex--;
rasops4_putchar(cookie, row, col, uc, attr);
  281                 return;
  282         }
ri = (struct rasops_info *)cookie;
  286 #ifdef RASOPS_CLIPPING
  287         /* Catches 'row < 0' case too */
  288         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  290                 return;
  291         }
  293         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  295                 return;
  296         }
  297 #endif
rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
height = ri->ri_font->fontheight;
rs = ri->ri_stride / sizeof(*rp);
  303         /* Recompute stamp? */
  304         if (attr != stamp_attr)
rasops4_makestamp(ri, attr);
  307         if (uc == ' ') {
u_int16_t c = stamp[0];
  309                 while (height--) {
rp[0] = c;
rp[1] = c;
rp += rs;
  313                 }
  314         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  319                 while (height--) {
rp[0] = stamp[(*fr >> 4) & 0xf];
rp[1] = stamp[*fr & 0xf];
fr += fs;
rp += rs;
  324                 }
  325         }
  327         /* Do underline */
  328         if ((attr & 1) != 0) {
rp -= (rs << 1);
rp[0] = stamp[15];
rp[1] = stamp[15];
  332         }
stamp_mutex--;
  335 }
  337 /*
  338  * Put a single character. This is for 12-pixel wide fonts.
  339  */
  340 void
rasops4_putchar12(cookie, row, col, uc, attr)
  342         void *cookie;
  343         int row, col;
u_int uc;
  345         long attr;
  346 {
  347         struct rasops_info *ri;
  348         int height, fs, rs;
u_char *fr;
u_int16_t *rp;
  352         /* Can't risk remaking the stamp if it's already in use */
  353         if (stamp_mutex++) {
stamp_mutex--;
rasops4_putchar(cookie, row, col, uc, attr);
  356                 return;
  357         }
ri = (struct rasops_info *)cookie;
  361 #ifdef RASOPS_CLIPPING
  362         /* Catches 'row < 0' case too */
  363         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  365                 return;
  366         }
  368         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  370                 return;
  371         }
  372 #endif
rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
height = ri->ri_font->fontheight;
rs = ri->ri_stride / sizeof(*rp);
  378         /* Recompute stamp? */
  379         if (attr != stamp_attr)
rasops4_makestamp(ri, attr);
  382         if (uc == ' ') {
u_int16_t c = stamp[0];
  384                 while (height--) {
rp[0] = c;
rp[1] = c;
rp[2] = c;
rp += rs;
  389                 }
  390         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  395                 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;
  401                 }
  402         }
  404         /* Do underline */
  405         if ((attr & 1) != 0) {
rp -= (rs << 1);
rp[0] = stamp[15];
rp[1] = stamp[15];
rp[2] = stamp[15];
  410         }
stamp_mutex--;
  413 }
  415 /*
  416  * Put a single character. This is for 16-pixel wide fonts.
  417  */
  418 void
rasops4_putchar16(cookie, row, col, uc, attr)
  420         void *cookie;
  421         int row, col;
u_int uc;
  423         long attr;
  424 {
  425         struct rasops_info *ri;
  426         int height, fs, rs;
u_char *fr;
u_int16_t *rp;
  430         /* Can't risk remaking the stamp if it's already in use */
  431         if (stamp_mutex++) {
stamp_mutex--;
rasops4_putchar(cookie, row, col, uc, attr);
  434                 return;
  435         }
ri = (struct rasops_info *)cookie;
  439 #ifdef RASOPS_CLIPPING
  440         /* Catches 'row < 0' case too */
  441         if ((unsigned)row >= (unsigned)ri->ri_rows) {
stamp_mutex--;
  443                 return;
  444         }
  446         if ((unsigned)col >= (unsigned)ri->ri_cols) {
stamp_mutex--;
  448                 return;
  449         }
  450 #endif
rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
height = ri->ri_font->fontheight;
rs = ri->ri_stride / sizeof(*rp);
  456         /* Recompute stamp? */
  457         if (attr != stamp_attr)
rasops4_makestamp(ri, attr);
  460         if (uc == ' ') {
u_int16_t c = stamp[0];
  462                 while (height--) {
rp[0] = c;
rp[1] = c;
rp[2] = c;
rp[3] = c;
rp += rs;
  468                 }
  469         } else {
uc -= ri->ri_font->firstchar;
fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
fs = ri->ri_font->stride;
  474                 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;
  481                 }
  482         }
  484         /* Do underline */
  485         if ((attr & 1) != 0) {
rp -= (rs << 1);
rp[0] = stamp[15];
rp[1] = stamp[15];
rp[2] = stamp[15];
rp[3] = stamp[15];
  491         }
stamp_mutex--;
  494 }
  495 #endif  /* !RASOPS_SMALL */
  497 /*
  498  * Grab routines common to depths where (bpp < 8)
  499  */
  500 #define NAME(ident)     rasops4_##ident
  501 #define PIXEL_SHIFT     2
  503 #include <dev/rasops/rasops_bitops.h>