driver.c

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

    bp = b;
    if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
	for (i = 0; i < h; i++) {
	    RGB_swapped_memcpy(bp, vp, w * 3);
	    bp += bw * 3;
	    vp += BYTEWIDTH;
	}
    } else {
	for (i = 0; i < h; i++) {
	    __memcpy(bp, vp, w * 3);
	    bp += bw * 3;
	    vp += BYTEWIDTH;
	}
    }
}

static void driver24_rev_getbox(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(bp, VBUF + vp, 0x10000 - vp);
		bp2 = bp + (0x10000 - vp - left);
		switch (left) {
		case 2:
		    bp2[2] = *(VBUF + 0xFFFE);
		    bp2[1] = *(VBUF + 0xFFFF);
		    break;
		case 1:
		    bp2[2] = *(VBUF + 0xFFFF);
		    break;
		}

		page++;
		vga_setpage(page);

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

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

INLINE void __svgalib_driver24p_getbox(int x, int y, int w, int h, void *b, int bw)
{
    if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
	driver24_rev_getbox(x * 3, y, w * 3, h, b, bw * 3);
    } else {
	__svgalib_driver8p_getbox(x * 3, y, w * 3, h, b, bw * 3);
    }
}

void __svgalib_driver24_putboxmask(int x, int y, int w, int h, void *b)
{
    uchar *bp = b;
    uchar *vp;
    int i;
    ASSIGNVP24(x, y, vp);
    for (i = 0; i < h; i++) {
	uchar *endoflinebp = bp + w * 3;
	while (bp < endoflinebp - 11) {
	    unsigned c = RGB2BGR(*(unsigned *) bp);
	    if (c & 0xffffff) {
		*(ushort *) vp = (ushort) c;
		*(vp + 2) = c >> 16;
	    }
	    c = RGB2BGR(*(unsigned *) (bp + 3));
	    if (c & 0xffffff) {
		*(ushort *) (vp + 3) = (ushort) c;
		*(vp + 5) = c >> 16;
	    }
	    c = RGB2BGR(*(unsigned *) (bp + 6));
	    if (c & 0xffffff) {
		*(ushort *) (vp + 6) = (ushort) c;
		*(vp + 8) = c >> 16;
	    }
	    c = RGB2BGR(*(unsigned *) (bp + 9));
	    if (c & 0xffffff) {
		*(ushort *) (vp + 9) = (ushort) c;
		*(vp + 11) = c >> 16;
	    }
	    bp += 12;
	    vp += 12;
	}
	while (bp < endoflinebp) {
	    uint c = RGB2BGR(*(uint *) bp);
	    if (c & 0xffffff) {
		*(ushort *) vp = (ushort) c;
		*(vp + 2) = c >> 16;
	    }
	    bp += 3;
	    vp += 3;
	}
	vp += BYTEWIDTH - w * 3;
    }
}

INLINE void __svgalib_driver24_putboxpart(int x, int y, int w, int h, int ow, int oh,
				void *b, int xo, int yo)
{
    /*
     * Actually I think all this could be done by just calling __svgalib_driver24_putbox
     * with correct args. But I'm too fearful. - Michael.
     */
    if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
	__svgalib_driver24_putbox(x, y, w, h, b + yo * ow + xo, ow);
    } else {
	__svgalib_driver8_putbox(x * 3, y, w * 3, h, b + yo * ow * 3 + xo * 3, ow * 3);
    }
}

INLINE void __svgalib_driver24p_putboxpart(int x, int y, int w, int h, int ow, int oh,
				 void *b, int xo, int yo)
{
    if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
	driver24_rev_putbox(x * 3, y, w * 3, h, b + yo * ow * 3 + xo * 3, ow * 3);
    } else {
	__svgalib_driver8p_putbox(x * 3, y, w * 3, h, b + yo * ow * 3 + xo * 3, ow * 3);
    }
}

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

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

void __svgalib_driver24_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    __svgalib_driver8_copybox(x1 * 3, y1, w * 3, h, x2 * 3, y2);
}

void __svgalib_driver24a_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    int svp, dvp;
    ASSIGNVPOFFSET24(x1, y1, svp);
    ASSIGNVPOFFSET24(x2, y2, dvp);
    vga_bitblt(svp, dvp, w * 3, h, BYTEWIDTH);
}



/* Four bytes per pixel graphics primitives */

#define ASSIGNVP32(x, y, vp) vp = VBUF + (y) * BYTEWIDTH + (x) * 4;
#define ASSIGNVPOFFSET32(x, y, vp) vp = (y) * BYTEWIDTH + (x) * 4;

void __svgalib_driver32_setpixel(int x, int y, int c)
{
    char *vp;
    ASSIGNVP32(x, y, vp);
    *(unsigned *) vp = c;
}

void __svgalib_driver32p_setpixel(int x, int y, int c)
{
    int vp;
    ASSIGNVPOFFSET32(x, y, vp);
    vga_setpage(vp >> 16);
    *(unsigned *) (VBUF + (vp & 0xffff)) = c;
}

int __svgalib_driver32_getpixel(int x, int y)
{
    char *vp;
    ASSIGNVP32(x, y, vp);
    return *(unsigned *) vp;
}

int __svgalib_driver32p_getpixel(int x, int y)
{
    int vp;
    ASSIGNVPOFFSET32(x, y, vp);
    vga_setpage(vp >> 16);
    return *(unsigned *) (VBUF + (vp & 0xffff));
}

void __svgalib_driver32_hline(int x1, int y, int x2, int c)
{
    char *vp;
    ASSIGNVP32(x1, y, vp);
    __memsetlong(vp, c, x2 - x1 + 1);
}

void __svgalib_driver32p_hline(int x1, int y, int x2, int c)
{
    int vp;
    char *rvp;
    int l;
    int chunksize, page;
    ASSIGNVPOFFSET32(x1, y, vp);
    SETWRITEPAGED(vp, rvp, chunksize, page);
    l = (x2 - x1 + 1) * 4;
    if (l <= chunksize)
	__memsetlong(rvp, c, l / 4);
    else {
	__memsetlong(rvp, c, chunksize / 4);
	vga_setpage(page + 1);
	__memsetlong(VBUF, c, (l - chunksize) / 4);
    }
}

void __svgalib_driver32_fillbox(int x, int y, int w, int h, int c)
{
    char *vp;
    int i;
    ASSIGNVP32(x, y, vp);
    for (i = 0; i < h; i++) {
	__memsetlong(vp, c, w);
	vp += BYTEWIDTH;
    }
}

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

INLINE void __svgalib_driver32_putbox(int x, int y, int w, int h, void *b, int bw)
{
    __svgalib_driver8_putbox(x * 4, y, w * 4, h, b, bw * 4);
}

INLINE void __svgalib_driver32p_putbox(int x, int y, int w, int h, void *b, int bw)
{
    __svgalib_driver8p_putbox(x * 4, y, w * 4, h, b, bw * 4);
}

INLINE void __svgalib_driver32_getbox(int x, int y, int w, int h, void *b, int bw)
{
    __svgalib_driver8_getbox(x * 4, y, w * 4, h, b, bw * 4);
}

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

void __svgalib_driver32_putboxmask(int x, int y, int w, int h, void *b)
{
    uchar *bp = b;
    uchar *vp;
    int i;
    ASSIGNVP32(x, y, vp);
    for (i = 0; i < h; i++) {
	uchar *endoflinebp = bp + w * 4;
	while (bp < endoflinebp - 15) {
	    unsigned c = *(unsigned *) bp;
	    if (c)
		*(unsigned *) vp = c;
	    c = *(unsigned *) (bp + 4);
	    if (c)
		*(unsigned *) (vp + 4) = c;
	    c = *(unsigned *) (bp + 8);
	    if (c)
		*(unsigned *) (vp + 8) = c;
	    c = *(unsigned *) (bp + 12);
	    if (c)
		*(unsigned *) (vp + 12) = c;
	    bp += 16;
	    vp += 16;
	}
	while (bp < endoflinebp) {
	    unsigned c = *(unsigned *) bp;
	    if (c)
		*(unsigned *) vp = c;
	    bp += 4;
	    vp += 4;
	}
	vp += BYTEWIDTH - w * 4;
    }
}

INLINE void __svgalib_driver32_putboxpart(int x, int y, int w, int h, int ow, int oh,
				void *b, int xo, int yo)
{
    __svgalib_driver32_putbox(x, y, w, h, b + yo * ow * 4 + xo * 4 , ow );
    /* inlined */
}

INLINE void __svgalib_driver32p_putboxpart(int x, int y, int w, int h, int ow, int oh,
				 void *b, int xo, int yo)
{
    __svgalib_driver32p_putbox(x, y, w, h, b + yo * ow * 4 + xo * 4, ow );
    /* inlined */
}

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

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

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



/* Planar 256 color mode graphics primitives (only putbox) */

void __svgalib_driverplanar256_nothing(void)
{
    NOTIMPL("planar 256 color mode primitive");
}

void __svgalib_driverplanar256_putbox(int x, int y, int w, int h, void *b, int bw)
{
    if ((w & 3) != 0 || (x & 3) != 0)
	NOTIMPL("planar 256 color mode unaligned putbox");
    vga_copytoplanar256(b, bw, y * BYTEWIDTH + x / 4, BYTEWIDTH,
			w, h);
}

void __svgalib_driverplanar16_nothing(void)
{
    NOTIMPL("planar 16 color mode primitive");
}


/* Memory primitives */

int __svgalib_driver_setread(GraphicsContext * gc, int i, void **vp)
{
    if (gc->modetype == CONTEXT_PAGED) {
	vga_setpage(i >> 16);
	*vp = (i & 0xffff) + gc->vbuf;
	return 0x10000 - (i & 0xffff);
    } else {
	*vp = gc->vbuf + i;
	return 0x10000;
    }
}

int __svgalib_driver_setwrite(GraphicsContext * gc, int i, void **vp)
{
    if (gc->modetype == CONTEXT_PAGED) {
	vga_setpage(i >> 16);
	*vp = (i & 0xffff) + gc->vbuf;
	return 0x10000 - (i & 0xffff);
    } else {
	*vp = gc->vbuf + i;
	return 0x10000;
    }
}



/* Functions that are not yet implemented */

void __svgalib_driver8p_putboxmask(int x, int y, int w, int h, void *b)
{
    NOTIMPL("8-bit paged putboxmask");
}

void __svgalib_driver8p_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    NOTIMPL("8-bit paged copybox (bitblt)");
}

void __svgalib_driver16p_putboxmask(int x, int y, int w, int h, void *b)
{
    NOTIMPL("16-bit paged putboxmask");
}

void __svgalib_driver16p_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    NOTIMPL("16-bit paged copybox");
}

void __svgalib_driver24p_putboxmask(int x, int y, int w, int h, void *b)
{
    NOTIMPL("24-bit paged putboxmask");
}

void __svgalib_driver24p_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    NOTIMPL("24-bit paged copybox");
}

void __svgalib_driver32p_putboxmask(int x, int y, int w, int h, void *b)
{
    NOTIMPL("32-bit paged putboxmask");
}

void __svgalib_driver32p_copybox(int x1, int y1, int w, int h, int x2, int y2)
{
    NOTIMPL("32-bit paged copybox");
}