driver.c

linux 下svgalib编的一个界面程序示例

    }
}

void __svgalib_driver16p_fillbox(int x, int y, int w, int h, int c)
{
    int vp;
    int page;
    int i;
    ASSIGNVPOFFSET16(x, y, vp);
    page = vp >> 16;
    vp &= 0xffff;
    vga_setpage(page);
    for (i = 0; i < h; i++) {
	if (vp + w * 2 > 0x10000) {
	    if (vp >= 0x10000) {
		page++;
		vga_setpage(page);
		vp &= 0xffff;
	    } else {		/* page break within line */
		__memset2(VBUF + vp, c, (0x10000 - vp) / 2);
		page++;
		vga_setpage(page);
		__memset2(VBUF, c, ((vp + w * 2) & 0xffff) / 2);
		vp = (vp + BYTEWIDTH) & 0xffff;
		continue;
	    }
        };
	__memset2(VBUF + vp, c, w);
	vp += BYTEWIDTH;
    }
}

void __svgalib_driver16_putbox(int x, int y, int w, int h, void *b, int bw)
{
    char *vp;			/* screen pointer */
    char *bp;			/* bitmap pointer */
    int i;
    ASSIGNVP16(x, y, vp);
    bp = b;
    for (i = 0; i < h; i++) {
	__memcpy(vp, bp, w * 2);
	bp += bw * 2;
	vp += BYTEWIDTH;
    }
}

void __svgalib_driver16p_putbox(int x, int y, int w, int h, void *b, int bw)
{
    __svgalib_driver8p_putbox(x * 2, y, w * 2, h, b, bw * 2);
}

void __svgalib_driver16_getbox(int x, int y, int w, int h, void *b, int bw)
{
    char *vp;			/* screen pointer */
    char *bp;			/* bitmap pointer */
    int i;
    ASSIGNVP16(x, y, vp);
    bp = b;
    for (i = 0; i < h; i++) {
	__memcpy(bp, vp, w * 2);
	bp += bw * 2;
	vp += BYTEWIDTH;
    }
}

INLINE void __svgalib_driver16p_getbox(int x, int y, int w, int h, void *b, int bw)
{
    __svgalib_driver8p_getbox(x * 2, y, w * 2, h, b, bw * 2);
}

void __svgalib_driver16_putboxmask(int x, int y, int w, int h, void *b)
{
    uchar *bp = b;
    uchar *vp;
    int i;
    ASSIGNVP16(x, y, vp);
    for (i = 0; i < h; i++) {
	uchar *endoflinebp = bp + w * 2;
	while (bp < endoflinebp - 7) {
	    unsigned c2 = *(unsigned *) bp;
	    if (c2 & 0xffff)
		*(ushort *) vp = (ushort) c2;
	    c2 >>= 16;
	    if (c2 & 0xffff)
		*(ushort *) (vp + 2) = (ushort) c2;
	    c2 = *(unsigned *) (bp + 4);
	    if (c2 & 0xffff)
		*(ushort *) (vp + 4) = (ushort) c2;
	    c2 >>= 16;
	    if (c2 & 0xffff)
		*(ushort *) (vp + 6) = (ushort) c2;
	    bp += 8;
	    vp += 8;
	}
	while (bp < endoflinebp) {
	    ushort c = *(ushort *) bp;
	    if (c)
		*(ushort *) vp = c;
	    bp += 2;
	    vp += 2;
	}
	vp += BYTEWIDTH - w * 2;
    }
}

INLINE void __svgalib_driver16_putboxpart(int x, int y, int w, int h, int ow, int oh,
				void *b, int xo, int yo)
{
    __svgalib_driver8_putbox(x * 2, y, w * 2, h, b + yo * ow * 2 + xo * 2, ow * 2);
    /* inlined */
}

INLINE void __svgalib_driver16p_putboxpart(int x, int y, int w, int h, int ow, int oh,
				 void *b, int xo, int yo)
{
    __svgalib_driver8p_putbox(x * 2, y, w * 2, h, b + yo * ow * 2 + xo * 2, ow * 2);
}

INLINE void __svgalib_driver16_getboxpart(int x, int y, int w, int h, int ow, int oh,
				void *b, int xo, int yo)
{
    __svgalib_driver16_getbox(x, y, w, h, b + yo * ow + xo, ow);
}

INLINE void __svgalib_driver16p_getboxpart(int x, int y, int w, int h, int ow, int oh,
				 void *b, int xo, int yo)
{
    __svgalib_driver16p_getbox(x, y, w, h, b + yo * ow + xo, ow);
}

INLINE void __svgalib_driver16_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    __svgalib_driver8_copybox(x1 * 2, y1, w * 2, h, x2 * 2, y2);
}

void __svgalib_driver16a_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    int svp, dvp;
    ASSIGNVPOFFSET16(x1, y1, svp);
    ASSIGNVPOFFSET16(x2, y2, dvp);
    vga_bitblt(svp, dvp, w * 2, h, BYTEWIDTH);
}



/* Three bytes per pixel graphics primitives */

#define ASSIGNVP24(x, y, vp) vp = VBUF + (y) * BYTEWIDTH + (x) * 3;
#define ASSIGNVPOFFSET24(x, y, vp) vp = (y) * BYTEWIDTH + (x) * 3;
#define RGBEQUAL(c) ((c & 0xff) == ((c >> 8) & 0xff) && \
	(c & 0xff) == ((c >> 16) & 0xff))

void __svgalib_driver24_setpixel(int x, int y, int c)
{
    char *vp;
    c = RGB2BGR(c);
    ASSIGNVP24(x, y, vp);
    *(unsigned short *) vp = c;
    *(unsigned char *) (vp + 2) = c >> 16;
}

void __svgalib_driver24p_setpixel(int x, int y, int c)
{
    int vp, vpo;
    char *vbuf;
    int page;
    c = RGB2BGR(c);
    ASSIGNVPOFFSET24(x, y, vp);
    vbuf = VBUF;
    page = vp >> 16;
    vga_setpage(page);
    vpo = vp & 0xffff;
    if (vpo <= 0xfffd) {
	*(unsigned short *) (vbuf + vpo) = c;
	*(unsigned char *) (vbuf + vpo + 2) = c >> 16;
    } else if (vpo == 0xfffe) {
	*(unsigned short *) (vbuf + 0xfffe) = c;
	vga_setpage(page + 1);
	*(unsigned char *) vbuf = c >> 16;
    } else {			/* vpo == 0xffff */
	*(unsigned char *) (vbuf + 0xffff) = c;
	vga_setpage(page + 1);
	*(unsigned short *) vbuf = c >> 8;
    }
}

int __svgalib_driver24_getpixel(int x, int y)
{
    char *vp;
    ASSIGNVP24(x, y, vp);
    return RGB2BGR(*(unsigned short *) vp + (*(unsigned char *) (vp + 2) << 16));
}

int __svgalib_driver24p_getpixel(int x, int y)
{
    int vp, vpo;
    char *vbuf;
    int page;
    ASSIGNVPOFFSET24(x, y, vp);
    vbuf = VBUF;
    page = vp >> 16;
    vga_setpage(page);
    vpo = vp & 0xffff;
    if (vpo <= 0xfffd)
	return RGB2BGR(*(unsigned short *) (vbuf + vpo) +
		       (*(unsigned char *) (vbuf + vpo + 2) << 16));
    else if (vpo == 0xfffe) {
	int c;
	c = *(unsigned short *) (vbuf + 0xfffe);
	vga_setpage(page + 1);
	return RGB2BGR((*(unsigned char *) vbuf << 16) + c);
    } else {			/* vpo == 0xffff */
	int c;
	c = *(unsigned char *) (vbuf + 0xffff);
	vga_setpage(page + 1);
	return RGB2BGR((*(unsigned short *) vbuf << 8) + c);
    }
}

void __svgalib_driver24_hline(int x1, int y, int x2, int c)
{
    char *vp;
    c = RGB2BGR(c);
    ASSIGNVP24(x1, y, vp);
    if (RGBEQUAL(c))
	__memset(vp, c, (x2 - x1 + 1) * 3);
    else
	__memset3(vp, c, x2 - x1 + 1);
}

void __svgalib_driver24p_hline(int x1, int y, int x2, int c)
{
    int vp;
    char *rvp;
    int l;
    int chunksize, page;
    c = RGB2BGR(c);
    ASSIGNVPOFFSET24(x1, y, vp);
    SETWRITEPAGED(vp, rvp, chunksize, page);
    l = (x2 - x1 + 1) * 3;
    if (l <= chunksize)
	__memset3(rvp, c, l / 3);
    else {
	int n, m, o;
	n = chunksize / 3;
	m = chunksize % 3;
	__memset3(rvp, c, n);
	/* Handle page break within pixel. */
	if (m >= 1)
	    *(rvp + n * 3) = c;
	if (m == 2)
	    *(rvp + n * 3 + 1) = c >> 8;
	vga_setpage(page + 1);
	o = 0;
	if (m == 2) {
	    *(VBUF) = c >> 16;
	    o = 1;
	}
	if (m == 1) {
	    *(unsigned short *) (VBUF) = c >> 8;
	    o = 2;
	}
	__memset3(VBUF + o, c, (l - chunksize) / 3);
    }
}

void __svgalib_driver24_fillbox(int x, int y, int w, int h, int c)
{
    char *vp;
    int i, j;
    c = RGB2BGR(c);
    ASSIGNVP24(x, y, vp);
    if (RGBEQUAL(c))
	for (i = 0; i < h; i++) {
	    __memset(vp, c, w * 3);
	    vp += BYTEWIDTH;
    } else
	for (j = 0; j < h; j++) {
	    __memset3(vp, c, w);
	    vp += BYTEWIDTH;
	}
}

void __svgalib_driver24p_fillbox(int x, int y, int w, int h, int c)
{
    int vp;
    int page;
    int i;
    c = RGB2BGR(c);
    ASSIGNVPOFFSET24(x, y, vp);
    page = vp >> 16;
    vp &= 0xffff;
    vga_setpage(page);
    if (RGBEQUAL(c)) {
	for (i = 0; i < h; i++) {
	    if (vp + w * 3 > 0x10000) {
		if (vp >= 0x10000) {
		    page++;
		    vga_setpage(page);
		    vp &= 0xffff;
		} else {	/* Page break within line. */
		    __memset(VBUF + vp, c, 0x10000 - vp);
		    page++;
		    vga_setpage(page);
		    __memset(VBUF, c, (vp + w * 3) & 0xffff);
		    vp = (vp + BYTEWIDTH) & 0xffff;
		    continue;
		}
            };
	    __memset(VBUF + vp, c, w * 3);
	    vp += BYTEWIDTH;
	}
    } else
	for (i = 0; i < h; i++) {
	    if (vp + w * 3 > 0x10000) {
		if (vp >= 0x10000) {
		    page++;
		    vga_setpage(page);
		    vp &= 0xffff;
		} else {	/* Page break within line. */
		    int n, m, o;
		    n = (0x10000 - vp) / 3;
		    m = (0x10000 - vp) % 3;
		    __memset3(VBUF + vp, c, n);
		    /* Handle page break within pixel. */
		    if (m >= 1)
			*(VBUF + vp + n * 3) = c;
		    if (m == 2)
			*(VBUF + vp + n * 3 + 1) = c >> 8;
		    page++;
		    vga_setpage(page);
		    o = 0;
		    if (m == 2) {
			*(VBUF) = c >> 16;
			o = 1;
		    }
		    if (m == 1) {
			*(unsigned short *) (VBUF) = c >> 8;
			o = 2;
		    }
		    __memset3(VBUF + o, c, ((vp + w * 3) & 0xffff) / 3);
		    vp = (vp + BYTEWIDTH) & 0xffff;
		    continue;
		}
            };
	    __memset3(VBUF + vp, c, w);
	    vp += BYTEWIDTH;
	}
}

void __svgalib_driver24_putbox(int x, int y, int w, int h, void *b, int bw)
{
    char *vp;			/* screen pointer */
    char *bp;			/* bitmap pointer */
    int i;
    ASSIGNVP24(x, y, vp);
    bp = b;
    if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
	for (i = 0; i < h; i++) {
	    RGB_swapped_memcpy(vp, bp, w * 3);
	    bp += bw * 3;
	    vp += BYTEWIDTH;
	}
    } else {
	for (i = 0; i < h; i++) {
	    __memcpy(vp, bp, w * 3);
	    bp += bw * 3;
	    vp += BYTEWIDTH;
	}
    }
}

static void driver24_rev_putbox(int x, int y, int w, int h, void *b, int bw)
{
/* extra argument width of source bitmap, so that putboxpart can use this */
    int vp;
    int page;
    char *bp = b, *bp2;
    int i, left;

    ASSIGNVPOFFSET8(x, y, vp);
    page = vp >> 16;
    vp &= 0xffff;
    vga_setpage(page);
    for (i = 0; i < h; i++) {
	if (vp + w > 0x10000) {
	    if (vp >= 0x10000) {
		page++;
		vga_setpage(page);
		vp &= 0xffff;
	    } else {		/* page break within line */
		left = RGB_swapped_memcpy(VBUF + vp, bp, 0x10000 - vp);
		bp2 = bp + (0x10000 - vp - left);
		switch (left) {
		case 2:
		    *(VBUF + 0xFFFE) = bp2[2];
		    *(VBUF + 0xFFFF) = bp2[1];
		    break;
		case 1:
		    *(VBUF + 0xFFFF) = bp2[2];
		    break;
		}

		page++;
		vga_setpage(page);

		switch (left) {
		case 1:
		    *(VBUF) = bp2[1];
		    *(VBUF + 1) = bp2[0];
		    left = 3 - left;
		    bp2 += 3;
		    break;
		case 2:
		    *(VBUF) = bp2[0];
		    left = 3 - left;
		    bp2 += 3;
		    break;
		}

		RGB_swapped_memcpy(VBUF + left, bp2, ((vp + w) & 0xffff) - left);
		vp = (vp + BYTEWIDTH) & 0xffff;
		bp += bw;
		continue;
	    }
        };
	RGB_swapped_memcpy(VBUF + vp, bp, w);
	bp += bw;
	vp += BYTEWIDTH;
    }
}

INLINE void __svgalib_driver24p_putbox(int x, int y, int w, int h, void *b, int bw)
{
    if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
	driver24_rev_putbox(x * 3, y, w * 3, h, b, bw * 3);
    } else {
	__svgalib_driver8p_putbox(x * 3, y, w * 3, h, b, bw * 3);
    }
}

void __svgalib_driver24_putbox32(int x, int y, int w, int h, void *b, int bw)
{
    char *vp;			/* screen pointer */
    char *bp;			/* bitmap pointer */
    int i;
    ASSIGNVP24(x, y, vp);
    bp = b;
    for (i = 0; i < h; i++) {
	__svgalib_memcpy4to3(vp, bp, w);
	bp += bw * 4;
	vp += BYTEWIDTH;
    }
}

void __svgalib_driver24_getbox(int x, int y, int w, int h, void *b, int bw)
{
    char *vp;			/* screen pointer */
    char *bp;			/* bitmap pointer */
    int i;
    ASSIGNVP24(x, y, vp);