OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 unneback 
/*
2 
 * Copyright (c) 1999 Greg Haerr <greg@censoft.com>
3 
 *
4 
 * 4bpp Packed Linear SH3 Video Driver for Microwindows
5 
 *
6 
 *      In this driver, psd->linelen is line byte length, not line pixel length
7 
 */
8 
/*
9 
        This is modified for SH3 LittleEndian system.
10 
        4bpp linear video driver,
11 
        Frame buffer sturcture and LCD Pixel is
12 
 
13 
        32                 16 15                0
14 
        -----------------------------------------
15 
        | P0 | P1 | P2 | P3 | P4 | P5 | P6 | P7 |
16 
        -----------------------------------------
17 
 
18 
 */
19 
 
20 
/*#define NDEBUG*/
21 
#include <assert.h>
22 
#include <string.h>
23 
#include "device.h"
24 
#include "fb.h"
25 
 
26 
static unsigned char notmask[2] = { 0x0f, 0xf0};
27 
 
28 
/* Calc linelen and mmap size, return 0 on fail*/
29 
static int
30 
linear4_init(PSD psd)
31 
{
32 
        if (!psd->size)
33 
                psd->size = psd->yres * psd->linelen;
34 
        /* linelen in bytes for bpp 1, 2, 4, 8 so no change*/
35 
        return 1;
36 
}
37 
 
38 
/* Set pixel at x, y, to pixelval c*/
39 
static void
40 
linear4_drawpixel(PSD psd, MWCOORD x, MWCOORD y, MWPIXELVAL c)
41 
{
42 
        ADDR8   addr = psd->addr;
43 
 
44 
        assert (addr != 0);
45 
        assert (x >= 0 && x < psd->xres);
46 
        assert (y >= 0 && y < psd->yres);
47 
        assert (c < psd->ncolors);
48 
 
49 
        DRAWON;
50 
        addr += ((x>>1)^3) + y * psd->linelen;
51 
        if(gr_mode == MWMODE_XOR)
52 
                *addr ^= c << ((1-(x&1))<<2);
53 
        else
54 
                *addr = (*addr & notmask[x&1]) | (c << ((1-(x&1))<<2));
55 
        DRAWOFF;
56 
}
57 
 
58 
/* Read pixel at x, y*/
59 
static MWPIXELVAL
60 
linear4_readpixel(PSD psd, MWCOORD x, MWCOORD y)
61 
{
62 
        ADDR8   addr = psd->addr;
63 
 
64 
        assert (addr != 0);
65 
        assert (x >= 0 && x < psd->xres);
66 
        assert (y >= 0 && y < psd->yres);
67 
 
68 
        return (addr[((x>>1)^3) + y * psd->linelen] >> ((1-(x&1))<<2) ) & 0x0f;
69 
}
70 
 
71 
/* Draw horizontal line from x1,y to x2,y including final point*/
72 
static void
73 
linear4_drawhorzline(PSD psd, MWCOORD x1, MWCOORD x2, MWCOORD y, MWPIXELVAL c)
74 
{
75 
        ADDR8   addr = psd->addr;
76 
 
77 
        assert (addr != 0);
78 
        assert (x1 >= 0 && x1 < psd->xres);
79 
        assert (x2 >= 0 && x2 < psd->xres);
80 
        assert (x2 >= x1);
81 
        assert (y >= 0 && y < psd->yres);
82 
        assert (c < psd->ncolors);
83 
 
84 
        DRAWON;
85 
        addr += ( (x1>>1)^3 ) + y * psd->linelen;
86 
        if(gr_mode == MWMODE_XOR) {
87 
                while(x1 <= x2) {
88 
                        *addr ^= c << ((1-(x1&1))<<2);
89 
                        if((++x1 & 1) == 0) {
90 
                        /*      ++addr;    */
91 
                        addr = psd->addr + ( (x1>>1)^3 ) + y * psd->linelen;
92 
                        }
93 
                }
94 
        } else {
95 
                while(x1 <= x2) {
96 
                        *addr = (*addr & notmask[x1&1]) | (c << ((1-(x1&1))<<2));
97 
                        if((++x1 & 1) == 0) {
98 
                        /*      ++addr;    */
99 
                        addr = psd->addr + ( (x1>>1)^3 ) + y * psd->linelen;
100 
                        }
101 
                }
102 
        }
103 
        DRAWOFF;
104 
}
105 
 
106 
/* Draw a vertical line from x,y1 to x,y2 including final point*/
107 
static void
108 
linear4_drawvertline(PSD psd, MWCOORD x, MWCOORD y1, MWCOORD y2, MWPIXELVAL c)
109 
{
110 
        ADDR8   addr = psd->addr;
111 
        int     linelen = psd->linelen;
112 
 
113 
        assert (addr != 0);
114 
        assert (x >= 0 && x < psd->xres);
115 
        assert (y1 >= 0 && y1 < psd->yres);
116 
        assert (y2 >= 0 && y2 < psd->yres);
117 
        assert (y2 >= y1);
118 
        assert (c < psd->ncolors);
119 
 
120 
        DRAWON;
121 
        addr += ( (x>>1)^3 ) + y1 * linelen;
122 
        if(gr_mode == MWMODE_XOR)
123 
                while(y1++ <= y2) {
124 
                        *addr ^= c << ((1-(x&1))<<2);
125 
                        addr += linelen;
126 
                }
127 
        else
128 
                while(y1++ <= y2) {
129 
                        *addr = (*addr & notmask[x&1]) | (c << ((1-(x&1))<<2));
130 
                        addr += linelen;
131 
                }
132 
        DRAWOFF;
133 
}
134 
 
135 
/* srccopy bitblt, opcode is currently ignored*/
136 
static void
137 
linear4_blit(PSD dstpsd, MWCOORD dstx, MWCOORD dsty, MWCOORD w, MWCOORD h,
138 
        PSD srcpsd, MWCOORD srcx, MWCOORD srcy, long op)
139 
{
140 
        ADDR8   dst;
141 
        ADDR8   src;
142 
        int     i;
143 
        int     dlinelen = dstpsd->linelen;
144 
        int     slinelen = srcpsd->linelen;
145 
 
146 
        assert (dstpsd->addr != 0);
147 
        assert (dstx >= 0 && dstx < dstpsd->xres);
148 
        assert (dsty >= 0 && dsty < dstpsd->yres);
149 
        assert (w > 0);
150 
        assert (h > 0);
151 
        assert (srcpsd->addr != 0);
152 
        assert (srcx >= 0 && srcx < srcpsd->xres);
153 
        assert (srcy >= 0 && srcy < srcpsd->yres);
154 
        assert (dstx+w <= dstpsd->xres);
155 
        assert (dsty+h <= dstpsd->yres);
156 
        assert (srcx+w <= srcpsd->xres);
157 
        assert (srcy+h <= srcpsd->yres);
158 
 
159 
        DRAWON;
160 
#ifdef SH3_LITTLE_ENDIAN   /* not used */
161 
        dst = dstpsd->addr + ( (dstx>>1)^3 ) + dsty * dlinelen;
162 
        src = srcpsd->addr + ( (srcx>>1)^3 ) + srcy * slinelen;
163 
        while(--h >= 0) {
164 
                ADDR8   d = dst;
165 
                ADDR8   s = src;
166 
                MWCOORD dx = dstx;
167 
                MWCOORD sx = srcx;
168 
                for(i=0; i<w; ++i) {
169 
                        *d = (*d & notmask[dx&1]) |
170 
                           ((*s >> ((1-(sx&1))<<2) & 0x0f) << ((1-(dx&1))<<2));
171 
                        if((++dx & 1) == 0)
172 
                                ++d;
173 
                        if((++sx & 1) == 0)
174 
                                ++s;
175 
                }
176 
                dst += dlinelen;
177 
                src += slinelen;
178 
        }
179 
#else
180 
        dst = dstpsd->addr + dsty * dlinelen;
181 
        src = srcpsd->addr + srcy * slinelen;
182 
        while(--h >= 0) {
183 
                ADDR8   d = dst + ( (dstx>>1)^3 );
184 
                ADDR8   s = src + ( (srcx>>1)^3 );
185 
                MWCOORD dx = dstx;
186 
                MWCOORD sx = srcx;
187 
                for(i=0; i<w; ++i) {
188 
                        *d = (*d & notmask[dx&1]) |
189 
                           ((*s >> ((1-(sx&1))<<2) & 0x0f) << ((1-(dx&1))<<2));
190 
                        if((++dx & 1) == 0)
191 
                                d = dst + ( (dx >> 1)^3 );
192 
                        if((++sx & 1) == 0)
193 
                                s = src + ( (sx >> 1)^3 );
194 
                }
195 
                dst += dlinelen;
196 
                src += slinelen;
197 
        }
198 
#endif
199 
        DRAWOFF;
200 
}
201 
 
202 
SUBDRIVER fblinear4 = {
203 
        linear4_init,
204 
        linear4_drawpixel,
205 
        linear4_readpixel,
206 
        linear4_drawhorzline,
207 
        linear4_drawvertline,
208 
        gen_fillrect,
209 
        linear4_blit
210 
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.