Return to IOCursorBlits.h CVS log

Up to [Apple XNU] / XNU / iokit / Families / IOGraphics

Annotation of XNU/iokit/Families/IOGraphics/IOCursorBlits.h, revision 1.1

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.