![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOCursorBlits.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOGraphics|
Return to IOCursorBlits.h CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOGraphics |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22:
23: #define RBMASK 0xF0F0 /* Short, or 16 bit format */
24: #define GAMASK 0x0F0F /* Short, or 16 bit format */
25: #define AMASK 0x000F /* Short, or 16 bit format */
26:
27: #define short34to35WithGamma(x) \
28: ( (_bm34To35SampleTable[((x) & 0x00F0) >> 4]) \
29: | (_bm34To35SampleTable[((x) & 0x0F00) >> 8] << 5) \
30: | (_bm34To35SampleTable[(x) >> 12] << 10) )
31:
32: #define short35to34WithGamma(x) \
33: ( 0x000F \
34: | (_bm35To34SampleTable[x & 0x001F] << 4) \
35: | (_bm35To34SampleTable[(x & 0x03E0) >> 5] << 8) \
36: | (_bm35To34SampleTable[(x & 0x7C00) >> 10] << 12) )
37:
38: void IOFramebuffer::StdFBDisplayCursor555(
39: IOFramebuffer * inst,
40: StdFBShmem_t *shmem,
41: volatile unsigned short *vramPtr,
42: unsigned int cursStart,
43: unsigned int vramRow,
44: unsigned int cursRow,
45: int width,
46: int height )
47: {
48: int i, j;
49: volatile unsigned short *cursPtr;
50: volatile unsigned short *savePtr;
51: unsigned short s, d, f;
52: unsigned char *_bm34To35SampleTable;
53: unsigned char *_bm35To34SampleTable;
54:
55: savePtr = (volatile unsigned short *) inst->cursorSave;
56: cursPtr = (volatile unsigned short *) inst->cursorImages[ shmem->frame ];
57: cursPtr += cursStart;
58:
59: _bm34To35SampleTable = inst->colorConvert.t._bm34To35SampleTable;
60: _bm35To34SampleTable = inst->colorConvert.t._bm35To34SampleTable;
61:
62: for (i = height; --i >= 0; ) {
63: for (j = width; --j >= 0; ) {
64: d = *savePtr++ = *vramPtr;
65: if ( (s = *cursPtr++) == 0 )
66: { /* Transparent black area. Leave dst as is. */
67: ++vramPtr;
68: continue;
69: }
70: if ( (f = (~s) & (unsigned int)AMASK) == 0 )
71: { /* Opaque cursor pixel. Mark it. */
72: *vramPtr++ = short34to35WithGamma(s);
73: continue;
74: }
75: if ((f == AMASK))
76: { /* Transparent non black cursor pixel. xor it. */
77: *vramPtr++ = d ^ short34to35WithGamma(s);
78: continue;
79: }
80: /* Alpha is not 0 or 1.0. Sover the cursor. */
81: d = short35to34WithGamma(d);
82: d = s + (((((d & RBMASK)>>4)*f + GAMASK) & RBMASK)
83: | ((((d & GAMASK)*f+GAMASK)>>4) & GAMASK));
84: *vramPtr++ = short34to35WithGamma(d);
85: }
86: cursPtr += cursRow; /* starting point of next cursor line */
87: vramPtr += vramRow; /* starting point of next screen line */
88: }
89: }
90:
91: void IOFramebuffer::StdFBDisplayCursor444(
92: IOFramebuffer * inst,
93: StdFBShmem_t *shmem,
94: volatile unsigned short *vramPtr,
95: unsigned int cursStart,
96: unsigned int vramRow,
97: unsigned int cursRow,
98: int width,
99: int height )
100: {
101: int i, j;
102: volatile unsigned short *savePtr; /* saved screen data pointer */
103: volatile unsigned short *cursPtr;
104: unsigned short s, d, f;
105:
106: savePtr = (volatile unsigned short *) inst->cursorSave;
107: cursPtr = (volatile unsigned short *) inst->cursorImages[ shmem->frame ];
108: cursPtr += cursStart;
109:
110: for (i = height; --i >= 0; ) {
111: for (j = width; --j >= 0; ) {
112: d = *savePtr++ = *vramPtr;
113: if ( (s = *cursPtr++) == 0 )
114: { /* Transparent black area. Leave dst as is. */
115: ++vramPtr;
116: continue;
117: }
118: if ( (f = (~s) & (unsigned int)AMASK) == 0 )
119: { /* Opaque cursor pixel. Mark it. */
120: *vramPtr++ = s;
121: continue;
122: }
123: if ((f == AMASK))
124: { /* Transparent non black cursor pixel. xor it. */
125: *vramPtr++ = d ^ s;
126: continue;
127: }
128: /* Alpha is not 0 or 1.0. Sover the cursor. */
129: *vramPtr++ = s + (((((d & RBMASK)>>4)*f + GAMASK) & RBMASK)
130: | ((((d & GAMASK)*f+GAMASK)>>4) & GAMASK));
131: }
132: cursPtr += cursRow; /* starting point of next cursor line */
133: vramPtr += vramRow; /* starting point of next screen line */
134: }
135: }
136:
137: static inline unsigned int MUL32(unsigned int a, unsigned int b)
138: {
139: unsigned int v, w;
140:
141: v = ((a & 0xff00ff00) >> 8) * b;
142: v += ((v & 0xff00ff00) >> 8) + 0x00010001;
143: w = (a & 0x00ff00ff) * b;
144: w += ((w & 0xff00ff00) >> 8) + 0x00010001;
145:
146: return (v & 0xff00ff00) | ((w >> 8) & 0x00ff00ff);
147: }
148:
149: static inline unsigned char map32to256( unsigned char *directToLogical, unsigned int s)
150: {
151: unsigned char logicalValue;
152:
153: if ((s ^ (s>>8)) & 0x00ffff00) {
154: logicalValue = directToLogical[(s>>24) + 0] +
155: directToLogical[((s>>16)&0xff) + 256] +
156: directToLogical[((s>>8)&0xff) + 512];
157: } else {
158: logicalValue = directToLogical[(s>>24) + 768];
159: }
160: // final conversion to actual palette
161: return( directToLogical[ logicalValue + 1024 ]);
162: }
163:
164: void IOFramebuffer::StdFBDisplayCursor8P(
165: IOFramebuffer * inst,
166: StdFBShmem_t *shmem,
167: volatile unsigned char *vramPtr,
168: unsigned int cursStart,
169: unsigned int vramRow,
170: unsigned int cursRow,
171: int width,
172: int height )
173: {
174: int i, j;
175: volatile unsigned char *savePtr; /* saved screen data pointer */
176: volatile unsigned char *cursPtr;
177: unsigned char dst, src, alpha, white;
178: unsigned int rgb32val;
179: volatile unsigned char *maskPtr; /* cursor mask pointer */
180: unsigned int *_bm256To38SampleTable
181: = inst->colorConvert.t._bm256To38SampleTable;
182: unsigned char *_bm38To256SampleTable
183: = inst->colorConvert.t._bm38To256SampleTable;
184:
185: savePtr = (volatile unsigned char *) inst->cursorSave;
186: cursPtr = (volatile unsigned char *) inst->cursorImages[ shmem->frame ];
187: maskPtr = (volatile unsigned char *) inst->cursorMasks[ shmem->frame ];
188: cursPtr += cursStart;
189: maskPtr += cursStart;
190:
191: white = inst->white;
192: for (i = height; --i >= 0; ) {
193: for (j = width; --j >= 0; savePtr++,maskPtr++,cursPtr++,vramPtr++) {
194: dst = *savePtr = *vramPtr;
195: src = *cursPtr;
196: if ((alpha = *maskPtr)) {
197: if ((alpha = ~alpha)) {
198: rgb32val = _bm256To38SampleTable[dst];
199: rgb32val = (_bm256To38SampleTable[src] & ~0xff) +
200: MUL32(rgb32val, alpha);
201: *vramPtr = map32to256(_bm38To256SampleTable, rgb32val);
202: } else
203: *vramPtr = src;
204: } else if (src == white)
205: *vramPtr = map32to256(_bm38To256SampleTable,
206: _bm256To38SampleTable[dst] ^ 0xffffffff);
207: }
208: cursPtr += cursRow; /* starting point of next cursor line */
209: maskPtr += cursRow;
210: vramPtr += vramRow; /* starting point of next screen line */
211: }
212: }
213:
214:
215: void IOFramebuffer::StdFBDisplayCursor8G(
216: IOFramebuffer * inst,
217: StdFBShmem_t *shmem,
218: volatile unsigned char *vramPtr,
219: unsigned int cursStart,
220: unsigned int vramRow,
221: unsigned int cursRow,
222: int width,
223: int height )
224: {
225: int i, j;
226: volatile unsigned char *savePtr; /* saved screen data pointer */
227: unsigned short s, d, a;
228: volatile unsigned char *cursPtr;
229: volatile unsigned char *maskPtr; /* cursor mask pointer */
230:
231: savePtr = (volatile unsigned char *) inst->cursorSave;
232: cursPtr = (volatile unsigned char *) inst->cursorImages[ shmem->frame ];
233: maskPtr = (volatile unsigned char *) inst->cursorMasks[ shmem->frame ];
234: cursPtr += cursStart;
235: maskPtr += cursStart;
236:
237: for (i = height; --i >= 0; ) {
238: for (j = width; --j >= 0; ) {
239: int t;
240: d = *savePtr++ = *vramPtr;
241: s = *cursPtr++;
242: a = *maskPtr++;
243: if (a) {
244: t = d * (255 - *maskPtr++);
245: *vramPtr = s + ((t + (t >> 8) + 1) >> 8);
246: } else if (s)
247: *vramPtr = d ^ s;
248: vramPtr++;
249: }
250: cursPtr += cursRow; /* starting point of next cursor line */
251: maskPtr += cursRow;
252: vramPtr += vramRow; /* starting point of next screen line */
253: }
254: }
255:
256: void IOFramebuffer::StdFBDisplayCursor32Axxx(
257: IOFramebuffer * inst,
258: StdFBShmem_t *shmem,
259: volatile unsigned int *vramPtr,
260: unsigned int cursStart,
261: unsigned int vramRow,
262: unsigned int cursRow,
263: int width,
264: int height )
265: {
266: int i, j;
267: volatile unsigned int *savePtr; /* saved screen data pointer */
268: unsigned int s, d, f;
269: volatile unsigned int *cursPtr;
270:
271: savePtr = (volatile unsigned int *) inst->cursorSave;
272: cursPtr = (volatile unsigned int *) inst->cursorImages[ shmem->frame ];
273: cursPtr += cursStart;
274:
275: /* Pixel format is Axxx */
276: for (i = height; --i >= 0; ) {
277: for (j = width; --j >= 0; ) {
278: d = *savePtr++ = *vramPtr;
279: s = *cursPtr++;
280: f = s >> 24;
281: if (f) {
282: if (f == 0xff) // Opaque pixel
283: *vramPtr++ = s;
284: else { // SOVER the cursor pixel
285: s <<= 8; d <<= 8; /* Now pixels are xxxA */
286: f ^= 0xFF;
287: d = s+(((((d&0xFF00FF00)>>8)*f+0x00FF00FF)&0xFF00FF00)
288: | ((((d & 0x00FF00FF)*f+0x00FF00FF)>>8) &
289: 0x00FF00FF));
290: *vramPtr++ = (d>>8) | 0xff000000;
291: }
292: } else if (s) {
293: // Transparent non black cursor pixel. xor it.
294: *vramPtr++ = d ^ s;
295: continue;
296: } else // Transparent cursor pixel
297: vramPtr++;
298: }
299: cursPtr += cursRow; /* starting point of next cursor line */
300: vramPtr += vramRow; /* starting point of next screen line */
301: }
302: }
303:
304: void IOFramebuffer::StdFBDisplayCursor32xxxA(
305: IOFramebuffer * inst,
306: StdFBShmem_t *shmem,
307: volatile unsigned int *vramPtr,
308: unsigned int cursStart,
309: unsigned int vramRow,
310: unsigned int cursRow,
311: int width,
312: int height )
313: {
314: int i, j;
315: volatile unsigned int *savePtr; /* saved screen data pointer */
316: unsigned int s, d, f;
317: volatile unsigned int *cursPtr;
318:
319: savePtr = (volatile unsigned int *) inst->cursorSave;
320: cursPtr = (volatile unsigned int *) inst->cursorImages[ shmem->frame ];
321: cursPtr += cursStart;
322:
323: /* Pixel format is xxxA */
324: for (i = height; --i >= 0; ) {
325: for (j = width; --j >= 0; ) {
326: d = *savePtr++ = *vramPtr;
327: s = *cursPtr++;
328: f = s & (unsigned int)0xFF;
329: if (f) {
330: if (f == 0xff) // Opaque pixel
331: *vramPtr++ = s;
332: else { // SOVER the cursor pixel
333: f ^= 0xFF;
334: d = s+(((((d&0xFF00FF00)>>8)*f+0x00FF00FF)&0xFF00FF00)
335: | ((((d & 0x00FF00FF)*f+0x00FF00FF)>>8) &
336: 0x00FF00FF));
337: *vramPtr++ = d;
338: }
339: } else if (s) {
340: // Transparent non black cursor pixel. xor it.
341: *vramPtr++ = d ^ s;
342: continue;
343: } else // Transparent cursor pixel
344: vramPtr++;
345: }
346: cursPtr += cursRow; /* starting point of next cursor line */
347: vramPtr += vramRow; /* starting point of next screen line */
348: }
349: }
350:
351: void IOFramebuffer::StdFBRemoveCursor16(
352: IOFramebuffer * inst,
353: StdFBShmem_t *shmem,
354: volatile unsigned short *vramPtr,
355: unsigned int vramRow,
356: int width,
357: int height )
358: {
359: int i, j;
360: volatile unsigned short *savePtr;
361:
362: savePtr = (volatile unsigned short *) inst->cursorSave;
363:
364: for (i = height; --i >= 0; ) {
365: for (j = width; --j >= 0; )
366: *vramPtr++ = *savePtr++;
367: vramPtr += vramRow;
368: }
369: }
370:
371: void IOFramebuffer::StdFBRemoveCursor8(
372: IOFramebuffer * inst,
373: StdFBShmem_t *shmem,
374: volatile unsigned char *vramPtr,
375: unsigned int vramRow,
376: int width,
377: int height )
378: {
379: int i, j;
380: volatile unsigned char *savePtr;
381:
382: savePtr = (volatile unsigned char *) inst->cursorSave;
383:
384: for (i = height; --i >= 0; ) {
385: for (j = width; --j >= 0; )
386: *vramPtr++ = *savePtr++;
387: vramPtr += vramRow;
388: }
389: }
390:
391: void IOFramebuffer::StdFBRemoveCursor32(
392: IOFramebuffer * inst,
393: StdFBShmem_t *shmem,
394: volatile unsigned int *vramPtr,
395: unsigned int vramRow,
396: int width,
397: int height )
398: {
399: int i, j;
400: volatile unsigned int *savePtr;
401:
402: savePtr = (volatile unsigned int *) inst->cursorSave;
403:
404: for (i = height; --i >= 0; ) {
405: for (j = width; --j >= 0; )
406: *vramPtr++ = *savePtr++;
407: vramPtr += vramRow;
408: }
409: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.