URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [drivers/] [fblin12.c] - Blame information for rev 174

Details | Compare with Previous | View Log


/* by julian schroeder <detemp1@germany.cirrus.com>
 * for Cirrus Logic  based on fblin24.c
 *
 * Copyright (c) 2000 Greg Haerr <greg@censoft.com>
 *
 * 12bpp Linear Video Driver for Microwindows
 *
 * UNDER CONSTRUCTION
 */
/*#define NDEBUG*/
#include <assert.h>
#include <string.h>
#include "device.h"
#include "fb.h"
 
int gr_mode=MWMODE_XOR;
 
/* Calc linelen and mmap size, return 0 on fail*/
static int
linear12_init(PSD psd)
{
        if (!psd->size) {
                psd->size = 960*240/2;
                /* convert linelen from byte to pixel len for bpp 16, 24, 32*/
                psd->linelen *= 2;
                psd->linelen /= 3; /* /1.5*/
        }
        return 1;
}
 
static inline void setpix(char *cptr,int x, int y, char c)
{
long adr;
 
adr=(x>>1) + (y*480);  /* change, julian*/
 
if(gr_mode == MWMODE_XOR)
  {
  if(x & 0x01) cptr[adr]^=((c << 4) & 0xf0);
  else cptr[adr]^=(c & 0x0f);
  }
else
  {
  if(x & 0x01)
    {
    cptr[adr]&=0x0f;
    cptr[adr]|=((c << 4) & 0xf0);
    }
  else
    {
    cptr[adr]&=0xf0;
    cptr[adr]|=(c & 0x0f);
    }
  }
}
 
static inline char getpix(char *cptr,int x, int y)
{
long adr;
adr=(x>>1) + (y*480);  /* change, julian*/
 
if(x & 0x01) return (cptr[adr] >> 4) & 0x0f;
return cptr[adr] & 0x0f;
}
 
 
/* Set pixel at x, y, to pixelval c*/
static void
linear12_drawpixel(PSD psd, MWCOORD x, MWCOORD y, MWPIXELVAL c)
{
        ADDR8   addr = psd->addr;
        MWUCHAR r, g, b;
 
        assert (addr != 0);
        assert (x >= 0 && x < psd->xres);
        assert (y >= 0 && y < psd->yres);
        assert (c < psd->ncolors);
 
        r = PIXEL444RED(c);
        g = PIXEL444GREEN(c);
        b = PIXEL444BLUE(c);
        x=x+(x<<1);
        DRAWON;
        setpix(addr,x,y,r);
        setpix(addr,x+1,y,g);
        setpix(addr,x+2,y,b);
        DRAWOFF;
}
 
/* Read pixel at x, y*/
static MWPIXELVAL
linear12_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);
        x=x+(x<<1);
        return RGB2PIXEL444(getpix(addr,x,y),getpix(addr,x+1,y),getpix(addr,x+2,y));
}
 
/* Draw horizontal line from x1,y to x2,y including final point*/
static void
linear12_drawhorzline(PSD psd, MWCOORD x1, MWCOORD x2, MWCOORD y, MWPIXELVAL c)
{
        ADDR8   addr = psd->addr;
        MWUCHAR r, g, b;
 
        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);
 
        r = PIXEL444RED(c);
        g = PIXEL444GREEN(c);
        b = PIXEL444BLUE(c);
        DRAWON;
                x1*=3;
                x2*=3;
                while((x1+=3) <= x2) {
                setpix(addr,x1,y,r);
                setpix(addr,x1+1,y,g);
                setpix(addr,x1+2,y,b);
                }
        DRAWOFF;
}
 
/* Draw a vertical line from x,y1 to x,y2 including final point*/
static void
linear12_drawvertline(PSD psd, MWCOORD x, MWCOORD y1, MWCOORD y2, MWPIXELVAL c)
{
        ADDR8   addr = psd->addr;
        int     linelen = psd->linelen * 3;
        MWUCHAR r, g, b;
        linelen/=2;
        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);
        x=x+(x<<1);
        r = PIXEL444RED(c);
        g = PIXEL444GREEN(c);
        b = PIXEL444BLUE(c);
 
        DRAWON;
                while(y1++ <= y2)
                {
                setpix(addr,x,y1,r);
                setpix(addr,x+1,y1,g);
                setpix(addr,x+2,y1,b);
                }
        DRAWOFF;
}
 
#if 0
/* srccopy bitblt, opcode is currently ignored*/
static void
xlinear12_blit(PSD dstpsd, MWCOORD dstx, MWCOORD dsty, MWCOORD w, MWCOORD h,
        PSD srcpsd, MWCOORD srcx, MWCOORD srcy, long op)
{
        ADDR8   dst = dstpsd->addr;
        ADDR8   src = srcpsd->addr;
        int     i;
        int     dlinelen = dstpsd->linelen * 3;
        int     slinelen = srcpsd->linelen * 3;
        int     dlinelen_minus_w = (dstpsd->linelen - w) * 3;
        int     slinelen_minus_w = (srcpsd->linelen - w) * 3;
#if ALPHABLEND
        unsigned int alpha;
#endif
 
        assert (dst != 0);
        assert (dstx >= 0 && dstx < dstpsd->xres);
        assert (dsty >= 0 && dsty < dstpsd->yres);
        assert (w > 0);
        assert (h > 0);
        assert (src != 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 += (dstx + dsty * dstpsd->linelen) * 3;
        src += (srcx + srcy * srcpsd->linelen) * 3;
 
#if ALPHABLEND
        if((op & MWROP_EXTENSION) != MWROP_BLENDCONSTANT)
                goto stdblit;
        alpha = op & 0xff;
 
        while(--h >= 0) {
                for(i=0; i<w; ++i) {
                        unsigned long s = *src++;
                        unsigned long d = *dst;
                        *dst++ = (unsigned char)(((s - d)*alpha)>>8) + d;
                        s = *src++;
                        d = *dst;
                        *dst++ = (unsigned char)(((s - d)*alpha)>>8) + d;
                        s = *src++;
                        d = *dst;
                        *dst++ = (unsigned char)(((s - d)*alpha)>>8) + d;
                }
                dst += dlinelen_minus_w;
                src += slinelen_minus_w;
        }
        DRAWOFF;
        return;
stdblit:
#endif
        while(--h >= 0) {
#if 1
                /* a _fast_ memcpy is a _must_ in this routine*/
                memcpy(dst, src, w*3);
                dst += dlinelen;
                src += slinelen;
#else
                for(i=0; i<w; ++i) {
                        *dst++ = *src++;
                        *dst++ = *src++;
                        *dst++ = *src++;
                }
                dst += dlinelen_minus_w;
                src += slinelen_minus_w;
#endif
        }
        DRAWOFF;
}
#endif
 
/* srccopy bitblt, opcode is currently ignored*/
static void
linear12_blit(PSD dstpsd, MWCOORD dstx, MWCOORD dsty, MWCOORD w, MWCOORD h,
        PSD srcpsd, MWCOORD srcx, MWCOORD srcy, long op)
{
        ADDR8   dst = dstpsd->addr;
        ADDR8   src = srcpsd->addr;
 
        /*if ((srcx & 0x01) || (dstx & 0x01))*/
        /* FIXME where is this if supposed to end?? */
 
        DRAWON;
        dst+=((dstx*3+1)/2)+480*dsty;
        src+=((srcx*3+1)/2)+480*srcx;
 
        assert (dst != 0);
        assert (dstx >= 0 && dstx < dstpsd->xres);
        assert (dsty >= 0 && dsty < dstpsd->yres);
        assert (w > 0);
        assert (h > 0);
        assert (src != 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);
 
 
        if((srcx & 0x01) && !(dstx & 0x01))
          {
          src+=1;
          /*w-=1;*/
          }
 
        if(!(srcx & 0x01) && (dstx & 0x01))
          {
          dst+=1;
          /*w-=1;*/
          }
 
        if((srcx & 0x01) && (dstx & 0x01))
          {
          /*w-=1;*/
          }
 
 
        while(--h >= 0) {
                /* a _fast_ memcpy is a _must_ in this routine*/
                memcpy(dst, src, (w*3+1)/2);
                dst += 480;
                src += 480;
        }
        DRAWOFF;
}
 
 
SUBDRIVER fblinear12 = {
        linear12_init,
        linear12_drawpixel,
        linear12_readpixel,
        linear12_drawhorzline,
        linear12_drawvertline,
        gen_fillrect,
        linear12_blit
};

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [drivers/] [fblin12.c] - Blame information for rev 174

Line No.	Rev	Author	Line
1	27	unneback	`/* by julian schroeder <detemp1@germany.cirrus.com>`
2			`* for Cirrus Logic based on fblin24.c`
3			`*`
4			`* Copyright (c) 2000 Greg Haerr <greg@censoft.com>`
5			`*`
6			`* 12bpp Linear Video Driver for Microwindows`
7			`*`
8			`* UNDER CONSTRUCTION`
9			`*/`
10			`/#define NDEBUG/`
11			`#include <assert.h>`
12			`#include <string.h>`
13			`#include "device.h"`
14			`#include "fb.h"`
15
16			`int gr_mode=MWMODE_XOR;`
17
18			`/* Calc linelen and mmap size, return 0 on fail*/`
19			`static int`
20			`linear12_init(PSD psd)`
21			`{`
22			`if (!psd->size) {`
23			`psd->size = 960*240/2;`
24			`/* convert linelen from byte to pixel len for bpp 16, 24, 32*/`
25			`psd->linelen *= 2;`
26			`psd->linelen /= 3; /* /1.5*/`
27			`}`
28			`return 1;`
29			`}`
30
31			`static inline void setpix(char *cptr,int x, int y, char c)`
32			`{`
33			`long adr;`
34
35			`adr=(x>>1) + (y480); / change, julian*/`
36
37			`if(gr_mode == MWMODE_XOR)`
38			`{`
39			`if(x & 0x01) cptr[adr]^=((c << 4) & 0xf0);`
40			`else cptr[adr]^=(c & 0x0f);`
41			`}`
42			`else`
43			`{`
44			`if(x & 0x01)`
45			`{`
46			`cptr[adr]&=0x0f;`
47			`cptr[adr]\|=((c << 4) & 0xf0);`
48			`}`
49			`else`
50			`{`
51			`cptr[adr]&=0xf0;`
52			`cptr[adr]\|=(c & 0x0f);`
53			`}`
54			`}`
55			`}`
56
57			`static inline char getpix(char *cptr,int x, int y)`
58			`{`
59			`long adr;`
60			`adr=(x>>1) + (y480); / change, julian*/`
61
62			`if(x & 0x01) return (cptr[adr] >> 4) & 0x0f;`
63			`return cptr[adr] & 0x0f;`
64			`}`
65
66
67			`/* Set pixel at x, y, to pixelval c*/`
68			`static void`
69			`linear12_drawpixel(PSD psd, MWCOORD x, MWCOORD y, MWPIXELVAL c)`
70			`{`
71			`ADDR8 addr = psd->addr;`
72			`MWUCHAR r, g, b;`
73
74			`assert (addr != 0);`
75			`assert (x >= 0 && x < psd->xres);`
76			`assert (y >= 0 && y < psd->yres);`
77			`assert (c < psd->ncolors);`
78
79			`r = PIXEL444RED(c);`
80			`g = PIXEL444GREEN(c);`
81			`b = PIXEL444BLUE(c);`
82			`x=x+(x<<1);`
83			`DRAWON;`
84			`setpix(addr,x,y,r);`
85			`setpix(addr,x+1,y,g);`
86			`setpix(addr,x+2,y,b);`
87			`DRAWOFF;`
88			`}`
89
90			`/* Read pixel at x, y*/`
91			`static MWPIXELVAL`
92			`linear12_readpixel(PSD psd, MWCOORD x, MWCOORD y)`
93			`{`
94			`ADDR8 addr = psd->addr;`
95
96			`assert (addr != 0);`
97			`assert (x >= 0 && x < psd->xres);`
98			`assert (y >= 0 && y < psd->yres);`
99			`x=x+(x<<1);`
100			`return RGB2PIXEL444(getpix(addr,x,y),getpix(addr,x+1,y),getpix(addr,x+2,y));`
101			`}`
102
103			`/* Draw horizontal line from x1,y to x2,y including final point*/`
104			`static void`
105			`linear12_drawhorzline(PSD psd, MWCOORD x1, MWCOORD x2, MWCOORD y, MWPIXELVAL c)`
106			`{`
107			`ADDR8 addr = psd->addr;`
108			`MWUCHAR r, g, b;`
109
110			`assert (addr != 0);`
111			`assert (x1 >= 0 && x1 < psd->xres);`
112			`assert (x2 >= 0 && x2 < psd->xres);`
113			`assert (x2 >= x1);`
114			`assert (y >= 0 && y < psd->yres);`
115			`assert (c < psd->ncolors);`
116
117			`r = PIXEL444RED(c);`
118			`g = PIXEL444GREEN(c);`
119			`b = PIXEL444BLUE(c);`
120			`DRAWON;`
121			`x1*=3;`
122			`x2*=3;`
123			`while((x1+=3) <= x2) {`
124			`setpix(addr,x1,y,r);`
125			`setpix(addr,x1+1,y,g);`
126			`setpix(addr,x1+2,y,b);`
127			`}`
128			`DRAWOFF;`
129			`}`
130
131			`/* Draw a vertical line from x,y1 to x,y2 including final point*/`
132			`static void`
133			`linear12_drawvertline(PSD psd, MWCOORD x, MWCOORD y1, MWCOORD y2, MWPIXELVAL c)`
134			`{`
135			`ADDR8 addr = psd->addr;`
136			`int linelen = psd->linelen * 3;`
137			`MWUCHAR r, g, b;`
138			`linelen/=2;`
139			`assert (addr != 0);`
140			`assert (x >= 0 && x < psd->xres);`
141			`assert (y1 >= 0 && y1 < psd->yres);`
142			`assert (y2 >= 0 && y2 < psd->yres);`
143			`assert (y2 >= y1);`
144			`assert (c < psd->ncolors);`
145			`x=x+(x<<1);`
146			`r = PIXEL444RED(c);`
147			`g = PIXEL444GREEN(c);`
148			`b = PIXEL444BLUE(c);`
149
150			`DRAWON;`
151			`while(y1++ <= y2)`
152			`{`
153			`setpix(addr,x,y1,r);`
154			`setpix(addr,x+1,y1,g);`
155			`setpix(addr,x+2,y1,b);`
156			`}`
157			`DRAWOFF;`
158			`}`
159
160			`#if 0`
161			`/* srccopy bitblt, opcode is currently ignored*/`
162			`static void`
163			`xlinear12_blit(PSD dstpsd, MWCOORD dstx, MWCOORD dsty, MWCOORD w, MWCOORD h,`
164			`PSD srcpsd, MWCOORD srcx, MWCOORD srcy, long op)`
165			`{`
166			`ADDR8 dst = dstpsd->addr;`
167			`ADDR8 src = srcpsd->addr;`
168			`int i;`
169			`int dlinelen = dstpsd->linelen * 3;`
170			`int slinelen = srcpsd->linelen * 3;`
171			`int dlinelen_minus_w = (dstpsd->linelen - w) * 3;`
172			`int slinelen_minus_w = (srcpsd->linelen - w) * 3;`
173			`#if ALPHABLEND`
174			`unsigned int alpha;`
175			`#endif`
176
177			`assert (dst != 0);`
178			`assert (dstx >= 0 && dstx < dstpsd->xres);`
179			`assert (dsty >= 0 && dsty < dstpsd->yres);`
180			`assert (w > 0);`
181			`assert (h > 0);`
182			`assert (src != 0);`
183			`assert (srcx >= 0 && srcx < srcpsd->xres);`
184			`assert (srcy >= 0 && srcy < srcpsd->yres);`
185			`assert (dstx+w <= dstpsd->xres);`
186			`assert (dsty+h <= dstpsd->yres);`
187			`assert (srcx+w <= srcpsd->xres);`
188			`assert (srcy+h <= srcpsd->yres);`
189
190			`DRAWON;`
191			`dst += (dstx + dsty * dstpsd->linelen) * 3;`
192			`src += (srcx + srcy * srcpsd->linelen) * 3;`
193
194			`#if ALPHABLEND`
195			`if((op & MWROP_EXTENSION) != MWROP_BLENDCONSTANT)`
196			`goto stdblit;`
197			`alpha = op & 0xff;`
198
199			`while(--h >= 0) {`
200			`for(i=0; i<w; ++i) {`
201			`unsigned long s = *src++;`
202			`unsigned long d = *dst;`
203			`dst++ = (unsigned char)(((s - d)alpha)>>8) + d;`
204			`s = *src++;`
205			`d = *dst;`
206			`dst++ = (unsigned char)(((s - d)alpha)>>8) + d;`
207			`s = *src++;`
208			`d = *dst;`
209			`dst++ = (unsigned char)(((s - d)alpha)>>8) + d;`
210			`}`
211			`dst += dlinelen_minus_w;`
212			`src += slinelen_minus_w;`
213			`}`
214			`DRAWOFF;`
215			`return;`
216			`stdblit:`
217			`#endif`
218			`while(--h >= 0) {`
219			`#if 1`
220			`/* a _fast_ memcpy is a _must_ in this routine*/`
221			`memcpy(dst, src, w*3);`
222			`dst += dlinelen;`
223			`src += slinelen;`
224			`#else`
225			`for(i=0; i<w; ++i) {`
226			`dst++ = src++;`
227			`dst++ = src++;`
228			`dst++ = src++;`
229			`}`
230			`dst += dlinelen_minus_w;`
231			`src += slinelen_minus_w;`
232			`#endif`
233			`}`
234			`DRAWOFF;`
235			`}`
236			`#endif`
237
238			`/* srccopy bitblt, opcode is currently ignored*/`
239			`static void`
240			`linear12_blit(PSD dstpsd, MWCOORD dstx, MWCOORD dsty, MWCOORD w, MWCOORD h,`
241			`PSD srcpsd, MWCOORD srcx, MWCOORD srcy, long op)`
242			`{`
243			`ADDR8 dst = dstpsd->addr;`
244			`ADDR8 src = srcpsd->addr;`
245
246			`/if ((srcx & 0x01) \|\| (dstx & 0x01))/`
247			`/* FIXME where is this if supposed to end?? */`
248
249			`DRAWON;`
250			`dst+=((dstx3+1)/2)+480dsty;`
251			`src+=((srcx3+1)/2)+480srcx;`
252
253			`assert (dst != 0);`
254			`assert (dstx >= 0 && dstx < dstpsd->xres);`
255			`assert (dsty >= 0 && dsty < dstpsd->yres);`
256			`assert (w > 0);`
257			`assert (h > 0);`
258			`assert (src != 0);`
259			`assert (srcx >= 0 && srcx < srcpsd->xres);`
260			`assert (srcy >= 0 && srcy < srcpsd->yres);`
261			`assert (dstx+w <= dstpsd->xres);`
262			`assert (dsty+h <= dstpsd->yres);`
263			`assert (srcx+w <= srcpsd->xres);`
264			`assert (srcy+h <= srcpsd->yres);`
265
266
267			`if((srcx & 0x01) && !(dstx & 0x01))`
268			`{`
269			`src+=1;`
270			`/w-=1;/`
271			`}`
272
273			`if(!(srcx & 0x01) && (dstx & 0x01))`
274			`{`
275			`dst+=1;`
276			`/w-=1;/`
277			`}`
278
279			`if((srcx & 0x01) && (dstx & 0x01))`
280			`{`
281			`/w-=1;/`
282			`}`
283
284
285			`while(--h >= 0) {`
286			`/* a _fast_ memcpy is a _must_ in this routine*/`
287			`memcpy(dst, src, (w*3+1)/2);`
288			`dst += 480;`
289			`src += 480;`
290			`}`
291			`DRAWOFF;`
292			`}`
293
294
295			`SUBDRIVER fblinear12 = {`
296			`linear12_init,`
297			`linear12_drawpixel,`
298			`linear12_readpixel,`
299			`linear12_drawhorzline,`
300			`linear12_drawvertline,`
301			`gen_fillrect,`
302			`linear12_blit`
303			`};`