![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cfboldmfb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / cfb|
Return to cfboldmfb.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / cfb |
1.1 root 1: /*
2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
4:
5: All Rights Reserved
6:
7: Permission to use, copy, modify, and distribute this software and its
8: documentation for any purpose and without fee is hereby granted,
9: provided that the above copyright notice appear in all copies and that
10: both that copyright notice and this permission notice appear in
11: supporting documentation, and that the names of Digital or MIT not be
12: used in advertising or publicity pertaining to distribution of the
13: software without specific, written prior permission.
14:
15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21: SOFTWARE.
22:
23: */
24:
25: #include "Xmd.h"
26: #include "servermd.h"
27: #include "pixmapstr.h"
28: #include "../mfb/maskbits.h"
29:
30: /* mfbQuickBlt -- a quick and dirty bitblit routine
31: * copies from psrcBase(xSrc, ySrc) to pdstBase(xDst, yDst) an array of bits
32: * w wide by h high. It is assumed that psrcBase and pdstBase point at
33: * things reasonable to bitblt between. It is assumed that all clipping has
34: * been done. It is also assumed that the rectangle fits on the destination
35: * (that is, that (pdstBase + (yDst * h) + w) is a bit in the destination).
36: * This routine does no error-checking of any type, CAVEAT HACKER
37: */
38: mfbQuickBlt(psrcBase, pdstBase, xSrc, ySrc, xDst, yDst, w, h, wSrc, wDst)
39: int *psrcBase, *pdstBase, /* first bits in pixmaps */
40: xSrc, ySrc, /* origin of source */
41: xDst, yDst, /* origin for destination */
42: w, /* width to blt */
43: h, /* height to blt */
44: wSrc, wDst; /* width of pixmaps */
45: {
46:
47: int *psrcLine, *pdstLine;
48: int xdir, ydir;
49: int nl, startmask, endmask, nlMiddle, *psrc, *pdst, tmpSrc;
50:
51: if(psrcBase + wSrc * h < pdstBase ||
52: pdstBase + wDst * h < psrcBase)
53: {
54: /* the areas don't overlap right and down is fine */
55: xdir = ydir = 1;
56: }
57: else if(ySrc < yDst) /* move right and up */
58: {
59: xdir = 1;
60: ydir = -1;
61: }
62: else if(ySrc > yDst) /* move right and down */
63: {
64: xdir = 1;
65: ydir = 1;
66: }
67: else if(xSrc < xDst) /* move left and down */
68: {
69: xdir = -1;
70: ydir = 1;
71: }
72: else /* if xSrc <= xDst */ /* move right and down */
73: {
74: xdir = 1;
75: ydir = 1;
76: }
77:
78: if (ydir == -1) /* start at last scanline of rectangle */
79: {
80: psrcLine = psrcBase + (((ySrc + h) -1) * wSrc);
81: pdstLine = pdstBase + (((yDst + h) -1) * wDst);
82: wSrc = -wSrc;
83: wDst = -wDst;
84: }
85: else /* start at first scanline */
86: {
87: psrcLine = psrcBase + (ySrc * wSrc);
88: pdstLine = pdstBase + (yDst * wDst);
89: }
90:
91: /* x direction doesn't matter for < 1 longword */
92: if (w <= 32)
93: {
94: int srcBit, dstBit; /* bit offset of src and dst */
95:
96: pdstLine += (xDst >> 5);
97: psrcLine += (xSrc >> 5);
98: psrc = psrcLine;
99: pdst = pdstLine;
100:
101: srcBit = xSrc & 0x1f;
102: dstBit = xDst & 0x1f;
103:
104: while(h--)
105: {
106: getbits(psrc, srcBit, w, tmpSrc);
107: putbits(tmpSrc, dstBit, w, pdst);
108: psrc += wSrc;
109: pdst += wDst;
110: }
111: }
112: else
113: {
114: register int xoffSrc; /* offset (>= 0, < 32) from which to
115: fetch whole longwords fetched
116: in src */
117: int nstart; /* number of ragged bits
118: at start of dst */
119: int nend; /* number of ragged bits at end
120: of dst */
121: int srcStartOver; /* pulling nstart bits from src
122: overflows into the next word? */
123:
124: maskbits(xDst, w, startmask, endmask, nlMiddle);
125: if (startmask)
126: nstart = 32 - (xDst & 0x1f);
127: else
128: nstart = 0;
129: if (endmask)
130: nend = (xDst + w) & 0x1f;
131: else
132: nend = 0;
133:
134: xoffSrc = ((xSrc & 0x1f) + nstart) & 0x1f;
135: srcStartOver = ((xSrc & 0x1f) + nstart) > 31;
136:
137: if (xdir == 1) /* move left to right */
138: {
139: pdstLine += (xDst >> 5);
140: psrcLine += (xSrc >> 5);
141:
142: while (h--)
143: {
144: psrc = psrcLine;
145: pdst = pdstLine;
146:
147: if (startmask)
148: {
149: getbits(psrc, (xSrc & 0x1f), nstart, tmpSrc);
150: putbits(tmpSrc, (xDst & 0x1f), nstart, pdst);
151: pdst++;
152: if (srcStartOver)
153: psrc++;
154: }
155:
156: nl = nlMiddle;
157: while (nl--)
158: {
159: getbits(psrc, xoffSrc, 32, tmpSrc);
160: *pdst++ = tmpSrc;
161: psrc++;
162: }
163:
164: if (endmask)
165: {
166: getbits(psrc, xoffSrc, nend, tmpSrc);
167: putbits(tmpSrc, 0, nend, pdst);
168: }
169:
170: psrcLine += wSrc;
171: pdstLine += wDst;
172: }
173: }
174: else /* move right to left */
175: {
176: pdstLine += ((xDst + w) >> 5);
177: psrcLine += (xSrc + w >> 5);
178: /* if fetch of last partial bits from source crosses
179: a longword boundary, start at the previous longword
180: */
181: if (xoffSrc + nend >= 32)
182: --psrcLine;
183:
184: while (h--)
185: {
186: psrc = psrcLine;
187: pdst = pdstLine;
188:
189: if (endmask)
190: {
191: getbits(psrc, xoffSrc, nend, tmpSrc)
192: putbits(tmpSrc, 0, nend, pdst)
193: }
194:
195: nl = nlMiddle;
196: while (nl--)
197: {
198: --psrc;
199: getbits(psrc, xoffSrc, 32, tmpSrc)
200: *--pdst = tmpSrc;
201: }
202:
203: if (startmask)
204: {
205: if (srcStartOver)
206: --psrc;
207: --pdst;
208: getbits(psrc, (xSrc & 0x1f), nstart, tmpSrc)
209: putbits(tmpSrc, (xDst & 0x1f), nstart, pdst)
210: }
211:
212: pdstLine += wDst;
213: psrcLine += wSrc;
214: }
215: } /* move right to left */
216: }
217: }
218:
219:
220: /* Rotates bitmap pPix by w pixels to the right on the screen. Assumes that
221: * words are 32 bits wide, and that the least significant bit appears on the
222: * left.
223: */
224: void
225: cfbXRotateBitmap(pPix, rw)
226: PixmapPtr pPix;
227: register int rw;
228: {
229: register long *pw, *pwFinal, *pwNew;
230: register unsigned long t;
231: int size;
232:
233: if (pPix == NullPixmap)
234: return;
235:
236: pw = (long *)pPix->devPrivate;
237: rw %= pPix->width;
238: if (rw < 0)
239: rw += pPix->width;
240: if(pPix->width == 32)
241: {
242: pwFinal = pw + pPix->height;
243: while(pw < pwFinal)
244: {
245: t = *pw;
246: *pw++ = SCRRIGHT(t, rw) |
247: (SCRLEFT(t, (32-rw)) & endtab[rw]);
248: }
249: }
250: else
251: {
252: pwNew = (long *) Xalloc( pPix->height * pPix->devKind);
253:
254: /* o.k., divide pw (the pixmap) in two vertically at (w - rw)
255: * pick up the part on the left and make it the right of the new
256: * pixmap. then pick up the part on the right and make it the left
257: * of the new pixmap.
258: * now hook in the new part and throw away the old. All done.
259: */
260: size = PixmapWidthInPadUnits(pPix->width, 1);
261: mfbQuickBlt(pw, pwNew, 0, 0, rw, 0, pPix->width - rw, pPix->height,
262: size, size);
263: mfbQuickBlt(pw, pwNew, pPix->width - rw, 0, 0, 0, rw, pPix->height,
264: size, size);
265: pPix->devPrivate = (pointer) pwNew;
266: Xfree((char *) pw);
267:
268: }
269:
270: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.