b09e761aad
- Introduce and use proper macros. - Use not ambiguous variable names. - Unify similar functions as possible as I can. - G/C unused headers. - Use #include <dev/rasops/foo.h> instead of "foo.h" No particular functional changes intended.
409 lines
8.6 KiB
C
409 lines
8.6 KiB
C
/* $NetBSD: rasops_bitops.h,v 1.25 2019/08/10 01:24:17 rin Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 1999 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Andrew Doran.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef _RASOPS_BITOPS_H_
|
|
#define _RASOPS_BITOPS_H_ 1
|
|
|
|
#if RASOPS_DEPTH == 1
|
|
#define PIXEL_SHIFT 0
|
|
#elif RASOPS_DEPTH == 2
|
|
#define PIXEL_SHIFT 1
|
|
#elif RASOPS_DEPTH == 4
|
|
#define PIXEL_SHIFT 2
|
|
#else
|
|
#error "Depth not supported"
|
|
#endif
|
|
|
|
#define NAME(name) NAME1(RASOPS_DEPTH, name)
|
|
#define NAME1(depth, name) NAME2(depth, name)
|
|
#define NAME2(depth, name) rasops ## depth ## _ ## name
|
|
|
|
/*
|
|
* Erase columns.
|
|
*/
|
|
static void
|
|
NAME(erasecols)(void *cookie, int row, int col, int num, long attr)
|
|
{
|
|
struct rasops_info *ri = (struct rasops_info *)cookie;
|
|
int height, cnt;
|
|
uint32_t bg, lbg, rbg, lmask, rmask, tmp;
|
|
uint32_t *dp, *rp, *hp;
|
|
|
|
hp = NULL; /* XXX GCC */
|
|
|
|
#ifdef RASOPS_CLIPPING
|
|
if ((unsigned)row >= (unsigned)ri->ri_rows)
|
|
return;
|
|
|
|
if (col < 0) {
|
|
num += col;
|
|
col = 0;
|
|
}
|
|
|
|
if (col + num > ri->ri_cols)
|
|
num = ri->ri_cols - col;
|
|
|
|
if (num <= 0)
|
|
return;
|
|
#endif
|
|
|
|
height = ri->ri_font->fontheight;
|
|
col *= ri->ri_font->fontwidth << PIXEL_SHIFT;
|
|
num *= ri->ri_font->fontwidth << PIXEL_SHIFT;
|
|
|
|
rp = (uint32_t *)(ri->ri_bits + row*ri->ri_yscale + ((col >> 3) & ~3));
|
|
if (ri->ri_hwbits)
|
|
hp = (uint32_t *)(ri->ri_hwbits + row*ri->ri_yscale +
|
|
((col >> 3) & ~3));
|
|
|
|
col &= 31;
|
|
|
|
bg = ATTR_BG(ri, attr);
|
|
|
|
if (col + num <= 32) {
|
|
lmask = ~rasops_pmask[col][num & 31];
|
|
bg &= ~lmask;
|
|
|
|
while (height--) {
|
|
tmp = (*rp & lmask) | bg;
|
|
*rp = tmp;
|
|
|
|
if (ri->ri_hwbits) {
|
|
*hp = tmp;
|
|
DELTA(hp, ri->ri_stride, uint32_t *);
|
|
}
|
|
|
|
DELTA(rp, ri->ri_stride, uint32_t *);
|
|
}
|
|
} else {
|
|
lmask = rasops_rmask[col];
|
|
rmask = rasops_lmask[(col + num) & 31];
|
|
|
|
if (lmask)
|
|
num = (num - (32 - col)) >> 5;
|
|
else
|
|
num = num >> 5;
|
|
|
|
lbg = bg & ~lmask;
|
|
rbg = bg & ~rmask;
|
|
|
|
while (height--) {
|
|
dp = rp;
|
|
|
|
if (lmask) {
|
|
*dp = (*dp & lmask) | lbg;
|
|
dp++;
|
|
}
|
|
|
|
for (cnt = num; cnt > 0; cnt--)
|
|
*dp++ = bg;
|
|
|
|
if (rmask)
|
|
*dp = (*dp & rmask) | rbg;
|
|
|
|
if (ri->ri_hwbits) {
|
|
memcpy(hp, rp, ((lmask != 0) + num +
|
|
(rmask != 0)) << 2);
|
|
DELTA(hp, ri->ri_stride, uint32_t *);
|
|
}
|
|
|
|
DELTA(rp, ri->ri_stride, uint32_t *);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Actually paint the cursor.
|
|
*/
|
|
static void
|
|
NAME(do_cursor)(struct rasops_info *ri)
|
|
{
|
|
int row, col, height, width, cnt;
|
|
uint32_t lmask, rmask, tmp;
|
|
uint32_t *dp, *rp, *hp;
|
|
|
|
hp = NULL; /* XXX GCC */
|
|
|
|
row = ri->ri_crow;
|
|
col = ri->ri_ccol * ri->ri_font->fontwidth << PIXEL_SHIFT;
|
|
|
|
height = ri->ri_font->fontheight;
|
|
width = ri->ri_font->fontwidth << PIXEL_SHIFT;
|
|
|
|
rp = (uint32_t *)(ri->ri_bits + row * ri->ri_yscale +
|
|
((col >> 3) & ~3));
|
|
if (ri->ri_hwbits)
|
|
hp = (uint32_t *)(ri->ri_hwbits + row * ri->ri_yscale +
|
|
((col >> 3) & ~3));
|
|
|
|
col &= 31;
|
|
|
|
if (col + width <= 32) {
|
|
lmask = rasops_pmask[col][width & 31];
|
|
|
|
while (height--) {
|
|
tmp = *rp ^ lmask;
|
|
*rp = tmp;
|
|
if (ri->ri_hwbits) {
|
|
*hp = tmp;
|
|
DELTA(hp, ri->ri_stride, uint32_t *);
|
|
}
|
|
DELTA(rp, ri->ri_stride, uint32_t *);
|
|
}
|
|
} else {
|
|
lmask = ~rasops_rmask[col];
|
|
rmask = ~rasops_lmask[(col + width) & 31];
|
|
|
|
if (lmask != -1)
|
|
width = (width - (32 - col)) >> 5;
|
|
else
|
|
width = width >> 5;
|
|
|
|
while (height--) {
|
|
dp = rp;
|
|
|
|
if (lmask != -1)
|
|
*dp++ ^= lmask;
|
|
|
|
for (cnt = width; cnt; cnt--) {
|
|
*dp = ~*dp;
|
|
dp++;
|
|
}
|
|
|
|
if (rmask != -1)
|
|
*dp ^= rmask;
|
|
|
|
if (ri->ri_hwbits) {
|
|
memcpy(hp, rp, ((lmask != -1) + width +
|
|
(rmask != -1)) << 2);
|
|
DELTA(hp, ri->ri_stride, uint32_t *);
|
|
}
|
|
|
|
DELTA(rp, ri->ri_stride, uint32_t *);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Copy columns. Ick!
|
|
*/
|
|
static void
|
|
NAME(copycols)(void *cookie, int row, int src, int dst, int num)
|
|
{
|
|
struct rasops_info *ri = (struct rasops_info *)cookie;
|
|
int height, width, lnum, rnum, sb, db, full, cnt, sboff;
|
|
uint32_t lmask, rmask, tmp;
|
|
uint32_t *sp, *dp, *srp, *drp, *hp;
|
|
bool sbover;
|
|
|
|
hp = NULL; /* XXX GCC */
|
|
|
|
if (__predict_false(dst == src))
|
|
return;
|
|
|
|
#ifdef RASOPS_CLIPPING
|
|
/* Catches < 0 case too */
|
|
if ((unsigned)row >= (unsigned)ri->ri_rows)
|
|
return;
|
|
|
|
if (src < 0) {
|
|
num += src;
|
|
src = 0;
|
|
}
|
|
|
|
if (src + num > ri->ri_cols)
|
|
num = ri->ri_cols - src;
|
|
|
|
if (dst < 0) {
|
|
num += dst;
|
|
dst = 0;
|
|
}
|
|
|
|
if (dst + num > ri->ri_cols)
|
|
num = ri->ri_cols - dst;
|
|
|
|
if (num <= 0)
|
|
return;
|
|
#endif
|
|
|
|
height = ri->ri_font->fontheight;
|
|
width = ri->ri_font->fontwidth << PIXEL_SHIFT;
|
|
|
|
row *= ri->ri_yscale;
|
|
|
|
src *= width;
|
|
dst *= width;
|
|
num *= width;
|
|
|
|
sb = src & 31;
|
|
db = dst & 31;
|
|
|
|
if (db + num <= 32) {
|
|
/* Destination is contained within a single word */
|
|
srp = (uint32_t *)(ri->ri_bits + row + ((src >> 3) & ~3));
|
|
drp = (uint32_t *)(ri->ri_bits + row + ((dst >> 3) & ~3));
|
|
if (ri->ri_hwbits)
|
|
hp = (uint32_t *)(ri->ri_hwbits + row +
|
|
((dst >> 3) & ~3));
|
|
|
|
while (height--) {
|
|
GETBITS(srp, sb, num, tmp);
|
|
PUTBITS(tmp, db, num, drp);
|
|
if (ri->ri_hwbits) {
|
|
*hp = *drp;
|
|
DELTA(hp, ri->ri_stride, uint32_t *);
|
|
}
|
|
DELTA(srp, ri->ri_stride, uint32_t *);
|
|
DELTA(drp, ri->ri_stride, uint32_t *);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
lmask = rasops_rmask[db];
|
|
rmask = rasops_lmask[(dst + num) & 31];
|
|
lnum = (32 - db) & 31;
|
|
rnum = (dst + num) & 31;
|
|
|
|
if (lmask != 0)
|
|
full = (num - lnum) >> 5;
|
|
else
|
|
full = num >> 5;
|
|
|
|
if (src < dst && src + num > dst) {
|
|
/* Copy right-to-left */
|
|
srp = (uint32_t *)(ri->ri_bits + row +
|
|
(((src + num) >> 3) & ~3));
|
|
drp = (uint32_t *)(ri->ri_bits + row +
|
|
(((dst + num) >> 3) & ~3));
|
|
if (ri->ri_hwbits) {
|
|
hp = (uint32_t *)(ri->ri_hwbits + row +
|
|
(((dst + num) >> 3) & ~3));
|
|
hp -= (lmask != 0) + full;
|
|
}
|
|
|
|
sboff = (src + num) & 31;
|
|
sbover = sb + lnum >= 32;
|
|
if ((sboff -= rnum) < 0) {
|
|
srp--;
|
|
sboff += 32;
|
|
}
|
|
|
|
while (height--) {
|
|
sp = srp;
|
|
dp = drp;
|
|
|
|
if (rmask != 0) {
|
|
GETBITS(sp, sboff, rnum, tmp);
|
|
PUTBITS(tmp, 0, rnum, dp);
|
|
}
|
|
|
|
/* Now aligned to 32-bits wrt dp */
|
|
for (cnt = full; cnt; cnt--) {
|
|
--dp;
|
|
--sp;
|
|
GETBITS(sp, sboff, 32, tmp);
|
|
*dp = tmp;
|
|
}
|
|
|
|
if (lmask != 0) {
|
|
if (sbover)
|
|
--sp;
|
|
--dp;
|
|
GETBITS(sp, sb, lnum, tmp);
|
|
PUTBITS(tmp, db, lnum, dp);
|
|
}
|
|
|
|
if (ri->ri_hwbits) {
|
|
memcpy(hp, dp, ((lmask != 0) + full +
|
|
(rmask != 0)) << 2);
|
|
DELTA(hp, ri->ri_stride, uint32_t *);
|
|
}
|
|
|
|
DELTA(srp, ri->ri_stride, uint32_t *);
|
|
DELTA(drp, ri->ri_stride, uint32_t *);
|
|
}
|
|
} else {
|
|
/* Copy left-to-right */
|
|
srp = (uint32_t *)(ri->ri_bits + row + ((src >> 3) & ~3));
|
|
drp = (uint32_t *)(ri->ri_bits + row + ((dst >> 3) & ~3));
|
|
if (ri->ri_hwbits)
|
|
hp = (uint32_t *)(ri->ri_hwbits + row +
|
|
((dst >> 3) & ~3));
|
|
|
|
while (height--) {
|
|
sp = srp;
|
|
dp = drp;
|
|
|
|
sboff = sb;
|
|
|
|
if (lmask != 0) {
|
|
GETBITS(sp, sboff, lnum, tmp);
|
|
PUTBITS(tmp, db, lnum, dp);
|
|
dp++;
|
|
|
|
if ((sboff += lnum) > 31) {
|
|
sp++;
|
|
sboff -= 32;
|
|
}
|
|
}
|
|
|
|
/* Now aligned to 32-bits wrt dp */
|
|
for (cnt = full; cnt; cnt--, sp++) {
|
|
GETBITS(sp, sboff, 32, tmp);
|
|
*dp++ = tmp;
|
|
}
|
|
|
|
if (rmask != 0) {
|
|
GETBITS(sp, sboff, rnum, tmp);
|
|
PUTBITS(tmp, 0, rnum, dp);
|
|
}
|
|
|
|
if (ri->ri_hwbits) {
|
|
memcpy(hp, drp, ((lmask != 0) + full +
|
|
(rmask != 0)) << 2);
|
|
DELTA(hp, ri->ri_stride, uint32_t *);
|
|
}
|
|
|
|
DELTA(srp, ri->ri_stride, uint32_t *);
|
|
DELTA(drp, ri->ri_stride, uint32_t *);
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef PIXEL_SHIFT
|
|
|
|
#undef NAME
|
|
#undef NAME1
|
|
#undef NAME2
|
|
|
|
#endif /* _RASOPS_BITOPS_H_ */
|