fblin24.c

一个linux下的根文件系统的源码

#undef MWI_ADVANCE_BIT
#undef MWI_BIT_NO
#undef MWI_FIRST_BIT
#undef MWI_LAST_BIT
}
#endif /* MW_FEATURE_PSDOP_BITMAP_BYTES_LSB_FIRST */

#if MW_FEATURE_PSDOP_BITMAP_BYTES_MSB_FIRST
/* psd->DrawArea operation PSDOP_BITMAP_BYTES_MSB_FIRST which
 * takes a pixmap, each line is byte aligned, and copies it
 * to the screen using fg_color and bg_color to replace a 1
 * and 0 in the pixmap.  
 *
 * The bitmap is ordered how you'd expect, with the MSB used
 * for the leftmost of the 8 pixels controlled by each byte.
 *
 * Variables used in the gc:
 *       dstx, dsty, dsth, dstw   Destination rectangle
 *       srcx, srcy               Source rectangle
 *       src_linelen              Linesize in bytes of source
 *       pixels                   Pixmap data
 *       fg_color                 Color of a '1' bit
 *       bg_color                 Color of a '0' bit
 *       gr_usebg                 If set, bg_color is used.  If zero,
 *                                then '0' bits are transparent.
 */
static void
linear24_drawarea_bitmap_bytes_msb_first(PSD psd, driver_gc_t * gc)
{
/*
 * The difference between the MSB_FIRST and LSB_FIRST variants of
 * this function is simply the definition of these three #defines.
 *
 * MWI_IS_BIT_BEFORE_OR_EQUAL(A,B) returns true if bit A is before
 *     (i.e. to the left of) bit B.
 * MWI_ADVANCE_BIT(X) advances X on to the next bit to the right,
 *     and stores the result back in X.
 * MWI_BIT_NO(N), where 0<=n<=7, gives the Nth bit, where 0 is the
 *     leftmost bit and 7 is the rightmost bit.  This is a constant
 *     iff N is a constant.
 */
#define MWI_IS_BIT_BEFORE_OR_EQUAL(a,b) ((a) >= (b))
#define MWI_ADVANCE_BIT(target) ((target) >>= 1)
#define MWI_BIT_NO(n) (0x80 >> (n))

/*
 * Two convenience defines - these are the same for MSB_FIRST and
 * LSB_FIRST.
 */
#define MWI_FIRST_BIT MWI_BIT_NO(0)
#define MWI_LAST_BIT  MWI_BIT_NO(7)

	unsigned char prefix_first_bit;
	unsigned char postfix_first_bit = MWI_FIRST_BIT;
	unsigned char postfix_last_bit;
	unsigned char bitmap_byte;
	unsigned char mask;
	unsigned long fg, bg;
	unsigned char fg_r, fg_g, fg_b, bg_r, bg_g, bg_b;
	int first_byte, last_byte;
	int size_main;
	int t, y;
	unsigned int advance_src, advance_dst;
	ADDR8 src;
	ADDR8 dst;

	/* The bit in the first byte, which corresponds to the leftmost pixel. */
	prefix_first_bit = MWI_BIT_NO(gc->srcx & 7);

	/* The bit in the last byte, which corresponds to the rightmost pixel. */
	postfix_last_bit = MWI_BIT_NO((gc->srcx + gc->dstw - 1) & 7);

	/* The index into each scanline of the first byte to use. */
	first_byte = gc->srcx >> 3;

	/* The index into each scanline of the last byte to use. */
	last_byte = (gc->srcx + gc->dstw - 1) >> 3;

	src = ((ADDR8) gc->pixels) + gc->src_linelen * gc->srcy + first_byte;
	dst = ((ADDR8) psd->addr) + (psd->linelen * gc->dsty + gc->dstx) * 3;
	fg = gc->fg_color;
	fg_r = PIXEL888RED(fg);
	fg_g = PIXEL888GREEN(fg);
	fg_b = PIXEL888BLUE(fg);
	bg = gc->bg_color;
	bg_r = PIXEL888RED(bg);
	bg_g = PIXEL888GREEN(bg);
	bg_b = PIXEL888BLUE(bg);

	advance_src = gc->src_linelen - last_byte + first_byte - 1;
	advance_dst = (psd->linelen - gc->dstw) * 3;

	if (first_byte != last_byte) {
		/* The total number of bytes to use, less the two special-cased
		 * bytes (first and last).
		 */
		size_main = last_byte - first_byte + 1 - 2;

		if (prefix_first_bit == MWI_FIRST_BIT) {
			/* No need to special case. */
			prefix_first_bit = 0;
			size_main++;
		}
		if (postfix_last_bit == MWI_LAST_BIT) {
			/* No need to special case. */
			postfix_last_bit = 0;
			size_main++;
		}
	} else if ((prefix_first_bit == MWI_FIRST_BIT)
		   && (postfix_last_bit == MWI_LAST_BIT)) {
		/* Exactly one byte wide. */
		prefix_first_bit = 0;
		postfix_last_bit = 0;
		size_main = 1;
	} else {
		/* Very narrow pixmap, fits in single first byte. */
		/* Do everything in 'postfix' loop. */
		postfix_first_bit = prefix_first_bit;
		prefix_first_bit = 0;
		size_main = 0;
	}

	DRAWON;

	if (gc->gr_usebg) {
		for (y = 0; y < gc->dsth; y++) {

			/* Do pixels of partial first byte */
			if (prefix_first_bit) {
				bitmap_byte = *src++;
				for (mask = prefix_first_bit; mask;
				     MWI_ADVANCE_BIT(mask)) {
					if (mask & bitmap_byte) {
						*dst++ = fg_b;
						*dst++ = fg_g;
						*dst++ = fg_r;
					} else {
						*dst++ = bg_b;
						*dst++ = bg_g;
						*dst++ = bg_r;
					}
				}
			}

			/* Do all pixels of main part one byte at a time */
			for (t = size_main; t != 0; t--) {
				bitmap_byte = *src++;

				if (MWI_BIT_NO(0) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
				if (MWI_BIT_NO(1) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
				if (MWI_BIT_NO(2) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
				if (MWI_BIT_NO(3) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
				if (MWI_BIT_NO(4) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
				if (MWI_BIT_NO(5) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
				if (MWI_BIT_NO(6) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
				if (MWI_BIT_NO(7) & bitmap_byte) {
					*dst++ = fg_b;
					*dst++ = fg_g;
					*dst++ = fg_r;
				} else {
					*dst++ = bg_b;
					*dst++ = bg_g;
					*dst++ = bg_r;
				}
			}

			/* Do last few bits of line */
			if (postfix_last_bit) {
				bitmap_byte = *src++;
				for (mask = postfix_first_bit;
				     MWI_IS_BIT_BEFORE_OR_EQUAL(mask,
								postfix_last_bit);
				     MWI_ADVANCE_BIT(mask)) {
					if (mask & bitmap_byte) {
						*dst++ = fg_b;
						*dst++ = fg_g;
						*dst++ = fg_r;
					} else {
						*dst++ = bg_b;
						*dst++ = bg_g;
						*dst++ = bg_r;
					}
				}
			}

			src += advance_src;
			dst += advance_dst;
		}
	} else {
		for (y = 0; y < gc->dsth; y++) {

			/* Do pixels of partial first byte */
			if (prefix_first_bit) {
				bitmap_byte = *src++;
				for (mask = prefix_first_bit; mask;
				     MWI_ADVANCE_BIT(mask)) {
					if (mask & bitmap_byte) {
						dst[0] = fg_b;
						dst[1] = fg_g;
						dst[2] = fg_r;
					}
					dst += 3;
				}
			}

			/* Do all pixels of main part one byte at a time */
			for (t = size_main; t != 0; t--) {
				bitmap_byte = *src++;

				if (MWI_BIT_NO(0) & bitmap_byte) {
					dst[0 * 3 + 0] = fg_b;
					dst[0 * 3 + 1] = fg_g;
					dst[0 * 3 + 2] = fg_r;
				}
				if (MWI_BIT_NO(1) & bitmap_byte) {
					dst[1 * 3 + 0] = fg_b;
					dst[1 * 3 + 1] = fg_g;
					dst[1 * 3 + 2] = fg_r;
				}
				if (MWI_BIT_NO(2) & bitmap_byte) {
					dst[2 * 3 + 0] = fg_b;
					dst[2 * 3 + 1] = fg_g;
					dst[2 * 3 + 2] = fg_r;
				}
				if (MWI_BIT_NO(3) & bitmap_byte) {
					dst[3 * 3 + 0] = fg_b;
					dst[3 * 3 + 1] = fg_g;
					dst[3 * 3 + 2] = fg_r;
				}
				if (MWI_BIT_NO(4) & bitmap_byte) {
					dst[4 * 3 + 0] = fg_b;
					dst[4 * 3 + 1] = fg_g;
					dst[4 * 3 + 2] = fg_r;
				}
				if (MWI_BIT_NO(5) & bitmap_byte) {
					dst[5 * 3 + 0] = fg_b;
					dst[5 * 3 + 1] = fg_g;
					dst[5 * 3 + 2] = fg_r;
				}
				if (MWI_BIT_NO(6) & bitmap_byte) {
					dst[6 * 3 + 0] = fg_b;
					dst[6 * 3 + 1] = fg_g;
					dst[6 * 3 + 2] = fg_r;
				}
				if (MWI_BIT_NO(7) & bitmap_byte) {
					dst[7 * 3 + 0] = fg_b;
					dst[7 * 3 + 1] = fg_g;
					dst[7 * 3 + 2] = fg_r;
				}
				dst += 8 * 3;
			}

			/* Do last few bits of line */
			if (postfix_last_bit) {
				bitmap_byte = *src++;
				for (mask = postfix_first_bit;
				     MWI_IS_BIT_BEFORE_OR_EQUAL(mask,
								postfix_last_bit);
				     MWI_ADVANCE_BIT(mask)) {
					if (mask & bitmap_byte) {
						dst[0] = fg_b;
						dst[1] = fg_g;
						dst[2] = fg_r;
					}
					dst += 3;
				}
			}

			src += advance_src;
			dst += advance_dst;
		}
	}

	DRAWOFF;

#undef MWI_IS_BIT_BEFORE_OR_EQUAL
#undef MWI_ADVANCE_BIT
#undef MWI_BIT_NO
#undef MWI_FIRST_BIT
#undef MWI_LAST_BIT
}
#endif /* MW_FEATURE_PSDOP_BITMAP_BYTES_MSB_FIRST */

#if MW_FEATURE_PSDOP_ALPHACOL
static void
linear24_drawarea_alphacol(PSD psd, driver_gc_t * gc)
{
	ADDR8 dst;
	ADDR8 alpha;
	unsigned long ps, pd;
	int as;
	int psr, psg, psb;
	int x, y;
	int src_row_step, dst_row_step;

	alpha = ((ADDR8) gc->misc) + gc->src_linelen * gc->srcy + gc->srcx;
	dst = ((ADDR8) psd->addr) + (psd->linelen * gc->dsty + gc->dstx) * 3;
	ps = gc->fg_color;
	psr = PIXEL888RED(ps);
	psg = PIXEL888GREEN(ps);
	psb = PIXEL888BLUE(ps);

	src_row_step = gc->src_linelen - gc->dstw;
	dst_row_step = (psd->linelen - gc->dstw) * 3;

	DRAWON;
	for (y = 0; y < gc->dsth; y++) {
		for (x = 0; x < gc->dstw; x++) {
			as = *alpha++;
			if (as == 255) {
				*dst++ = psb;
				*dst++ = psg;
				*dst++ = psr;
			} else if (as != 0) {
				/*
				 * Scale alpha value from 255ths to 256ths
				 * (In other words, if as >= 128, add 1 to it)
				 */
				as += (as >> 7);

				pd = *dst;
				*dst++ = (unsigned
					  char) ((((psb - pd) * as) >> 8) +
						 pd);
				pd = *dst;
				*dst++ = (unsigned
					  char) ((((psg - pd) * as) >> 8) +
						 pd);
				pd = *dst;
				*dst++ = (unsigned
					  char) ((((psr - pd) * as) >> 8) +
						 pd);
			} else {
				dst += 3;
			}
		}
		alpha += src_row_step;
		dst += dst_row_step;
	}
	DRAWOFF;
}
#endif /* MW_FEATURE_PSDOP_ALPHACOL */

static void
linear24_drawarea(PSD psd, driver_gc_t * gc, int op)
{
	assert(psd->addr != 0);
	/*assert(gc->dstw <= gc->srcw); */
	assert(gc->dstx >= 0 && gc->dstx + gc->dstw <= psd->xres);
	/*assert(gc->dsty >= 0 && gc->dsty+gc->dsth <= psd->yres); */
	/*assert(gc->srcx >= 0 && gc->srcx+gc->dstw <= gc->srcw); */
	assert(gc->srcy >= 0);
	/*DPRINTF("linear32_drawarea op=%d dstx=%d dsty=%d\n", op, gc->dstx, gc->dsty);*/

	switch (op) {

#if MW_FEATURE_PSDOP_ALPHACOL
	case PSDOP_ALPHACOL:
		linear24_drawarea_alphacol(psd, gc);
		break;
#endif /* MW_FEATURE_PSDOP_ALPHACOL */

#if MW_FEATURE_PSDOP_BITMAP_BYTES_LSB_FIRST
	case PSDOP_BITMAP_BYTES_LSB_FIRST:
		linear24_drawarea_bitmap_bytes_lsb_first(psd, gc);
		break;
#endif /* MW_FEATURE_PSDOP_BITMAP_BYTES_LSB_FIRST */

#if MW_FEATURE_PSDOP_BITMAP_BYTES_MSB_FIRST
	case PSDOP_BITMAP_BYTES_MSB_FIRST:
		linear24_drawarea_bitmap_bytes_msb_first(psd, gc);
		break;
#endif /* MW_FEATURE_PSDOP_BITMAP_BYTES_MSB_FIRST */

	}
}

SUBDRIVER fblinear24 = {
	linear24_init,
	linear24_drawpixel,
	linear24_readpixel,
	linear24_drawhorzline,
	linear24_drawvertline,
	gen_fillrect,
	linear24_blit,
	linear24_drawarea,
	linear24_stretchblit,
	linear24_stretchblitex,
};