Subversion Repositories or1k

/*

 * Copyright (c) 1999 Martin Jolicoeur <martinj@visuaide.com>

 *

 * 4bpp Packed Linear Video Driver for Microwindows

 * Designed for the arm SA1100 lcd controller with 16 bits access

 * (little endian)

 *

 *      In this driver, psd->linelen is line byte length, not line pixel length

 */

/*#define NDEBUG*/

#include <assert.h>

#include <string.h>

#include "device.h"

#include "fb.h"

static unsigned short notmask[4] = { 0x0fff, 0xf0ff, 0xff0f, 0xfff0};

/* Calc linelen and mmap size, return 0 on fail*/

static int

linear4_init(PSD psd)

{

        if (!psd->size)

                psd->size = psd->yres * psd->linelen;

        /* linelen in bytes for bpp 1, 2, 4, 8 so no change*/

        return 1;

}

/* Set pixel at x, y, to pixelval c*/

static void

linear4_drawpixel(PSD psd, MWCOORD x, MWCOORD y, MWPIXELVAL c)

{

        ADDR8   addr = psd->addr;

        assert (addr != 0);

        assert (x >= 0 && x < psd->xres);

        assert (y >= 0 && y < psd->yres);

        assert (c < psd->ncolors);

        DRAWON;

        addr += (x>>1) + y * psd->linelen;

        if(gr_mode == MWMODE_XOR)

                *(ADDR16)addr ^= c << ((3-(x&3))<<2);

        else

                *(ADDR16)addr = (*(ADDR16)addr & notmask[x&3]) | (c << ((3-(x&3))<<2));

        DRAWOFF;

}

/* Read pixel at x, y*/

static MWPIXELVAL

linear4_readpixel(PSD psd, MWCOORD x, MWCOORD y)

{

        ADDR8   addr = psd->addr;

        assert (addr != 0);

        assert (x >= 0 && x < psd->xres);

        assert (y >= 0 && y < psd->yres);

        return (addr[(x>>1) + y * psd->linelen] >> ((1-(x&1))<<2) ) & 0x0f;

}

/* Draw horizontal line from x1,y to x2,y including final point*/

static void

linear4_drawhorzline(PSD psd, MWCOORD x1, MWCOORD x2, MWCOORD y, MWPIXELVAL c)

{

        ADDR8   addr = psd->addr;

        assert (addr != 0);

        assert (x1 >= 0 && x1 < psd->xres);

        assert (x2 >= 0 && x2 < psd->xres);

        assert (x2 >= x1);

        assert (y >= 0 && y < psd->yres);

        assert (c < psd->ncolors);

        DRAWON;

        addr += (x1>>1) + y * psd->linelen;

        if(gr_mode == MWMODE_XOR) {

                while(x1 <= x2) {

                        *(ADDR16)addr ^= c << ((3-(x1&3))<<2);

                        if((++x1 & 1) == 0)

                                ++addr;

                }

        } else {

                while(x1 <= x2) {

                        *(ADDR16)addr = (*(ADDR16)addr & notmask[x1&3]) | (c << ((3-(x1&3))<<2));

                        if((++x1 & 1) == 0)

                                ++addr;

                }

        }

        DRAWOFF;

}

/* Draw a vertical line from x,y1 to x,y2 including final point*/

static void

linear4_drawvertline(PSD psd, MWCOORD x, MWCOORD y1, MWCOORD y2, MWPIXELVAL c)

{

        ADDR8   addr = psd->addr;

        int     linelen = psd->linelen;

        assert (addr != 0);

        assert (x >= 0 && x < psd->xres);

        assert (y1 >= 0 && y1 < psd->yres);

        assert (y2 >= 0 && y2 < psd->yres);

        assert (y2 >= y1);

        assert (c < psd->ncolors);

        DRAWON;

        addr += (x>>1) + y1 * linelen;

        if(gr_mode == MWMODE_XOR)

                while(y1++ <= y2) {

                        *(ADDR16)addr ^= c << ((3-(x&3))<<2);

                        addr += linelen;

                }

        else

                while(y1++ <= y2) {

                        *(ADDR16)addr = (*(ADDR16)addr & notmask[x&3]) | (c << ((3-(x&3))<<2));

                        addr += linelen;

                }

        DRAWOFF;

}

/* srccopy bitblt, opcode is currently ignored*/

static void

linear4_blit(PSD dstpsd, MWCOORD dstx, MWCOORD dsty, MWCOORD w, MWCOORD h,

        PSD srcpsd, MWCOORD srcx, MWCOORD srcy, long op)

{

        ADDR8   dst;

        ADDR8   src;

        int     i;

        int     dlinelen = dstpsd->linelen;

        int     slinelen = srcpsd->linelen;

        assert (dstpsd->addr != 0);

        assert (dstx >= 0 && dstx < dstpsd->xres);

        assert (dsty >= 0 && dsty < dstpsd->yres);

        assert (w > 0);

        assert (h > 0);

        assert (srcpsd->addr != 0);

        assert (srcx >= 0 && srcx < srcpsd->xres);

        assert (srcy >= 0 && srcy < srcpsd->yres);

        assert (dstx+w <= dstpsd->xres);

        assert (dsty+h <= dstpsd->yres);

        assert (srcx+w <= srcpsd->xres);

        assert (srcy+h <= srcpsd->yres);

        DRAWON;

        dst = dstpsd->addr + (dstx>>1) + dsty * dlinelen;

        src = srcpsd->addr + (srcx>>1) + srcy * slinelen;

        while(--h >= 0) {

                ADDR8   d = dst;

                ADDR8   s = src;

                MWCOORD dx = dstx;

                MWCOORD sx = srcx;

                for(i=0; i<w; ++i) {

                        *(ADDR16)d = (*(ADDR16)d & notmask[dx&3]) |

                           ((*(ADDR16)s >> ((3-(sx&3))<<2) & 0x000f) << ((3-(dx&3))<<2));

                        if((++dx & 1) == 0)

                                ++d;

                        if((++sx & 1) == 0)

                                ++s;

                }

                dst += dlinelen;

                src += slinelen;

        }

        DRAWOFF;

}

SUBDRIVER fblinear4 = {

        linear4_init,

        linear4_drawpixel,

        linear4_readpixel,

        linear4_drawhorzline,

        linear4_drawvertline,

        gen_fillrect,

        linear4_blit

};