Return to palette.c CVS log

Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256

Annotation of ntddk/src/video/displays/vga256/palette.c, revision 1.1

1.1     ! root        1: /******************************Module*Header*******************************\
        !             2: * Module Name: palette.c
        !             3: *
        !             4: * Palette support.
        !             5: *
        !             6: * Copyright (c) 1992 Microsoft Corporation
        !             7: \**************************************************************************/
        !             8: 
        !             9: #include "driver.h"
        !            10: 
        !            11: // Global Table defining the 20 Window Default Colors.  For 256 color
        !            12: // palettes the first 10 must be put at the beginning of the palette
        !            13: // and the last 10 at the end of the palette.
        !            14: 
        !            15: const PALETTEENTRY BASEPALETTE[20] =
        !            16: {
        !            17:     { 0,   0,   0,   0 },       // 0
        !            18:     { 0x80,0,   0,   0 },       // 1
        !            19:     { 0,   0x80,0,   0 },       // 2
        !            20:     { 0x80,0x80,0,   0 },       // 3
        !            21:     { 0,   0,   0x80,0 },       // 4
        !            22:     { 0x80,0,   0x80,0 },       // 5
        !            23:     { 0,   0x80,0x80,0 },       // 6
        !            24:     { 0xC0,0xC0,0xC0,0 },       // 7
        !            25:     { 192, 220, 192, 0 },       // 8
        !            26:     { 166, 202, 240, 0 },       // 9
        !            27:     { 255, 251, 240, 0 },       // 10
        !            28:     { 160, 160, 164, 0 },       // 11
        !            29:     { 0x80,0x80,0x80,0 },       // 12
        !            30:     { 0xFF,0,   0   ,0 },       // 13
        !            31:     { 0,   0xFF,0   ,0 },       // 14
        !            32:     { 0xFF,0xFF,0   ,0 },       // 15
        !            33:     { 0   ,0,   0xFF,0 },       // 16
        !            34:     { 0xFF,0,   0xFF,0 },       // 17
        !            35:     { 0,   0xFF,0xFF,0 },       // 18
        !            36:     { 0xFF,0xFF,0xFF,0 },       // 19
        !            37: };
        !            38: 
        !            39: BOOL bInitDefaultPalette(PPDEV ppdev);
        !            40: 
        !            41: /******************************Public*Routine******************************\
        !            42: * bInitPaletteInfo
        !            43: *
        !            44: * Initializes the palette information for this PDEV.
        !            45: *
        !            46: * Called by DrvEnablePDEV.
        !            47: *
        !            48: \**************************************************************************/
        !            49: 
        !            50: BOOL bInitPaletteInfo(PPDEV ppdev)
        !            51: {
        !            52:     if (!bInitDefaultPalette(ppdev))
        !            53:         return(FALSE);
        !            54: 
        !            55:     return(TRUE);
        !            56: }
        !            57: 
        !            58: /******************************Public*Routine******************************\
        !            59: * vDisablePalette
        !            60: *
        !            61: * Frees resources allocated by bInitPaletteInfo.
        !            62: *
        !            63: \**************************************************************************/
        !            64: 
        !            65: VOID vDisablePalette(PPDEV ppdev)
        !            66: {
        !            67: // Delete the default palette if we created one.
        !            68: 
        !            69:     if (ppdev->hpalDefault)
        !            70:     {
        !            71:         EngDeletePalette(ppdev->hpalDefault);
        !            72:         ppdev->hpalDefault = (HPALETTE) 0;
        !            73:     }
        !            74: 
        !            75:     if (ppdev->pPal != (PPALETTEENTRY)NULL)
        !            76:         LocalFree((PVOID)ppdev->pPal);
        !            77: }
        !            78: 
        !            79: /******************************Public*Routine******************************\
        !            80: * bInitDefaultPalette
        !            81: *
        !            82: * Initializes default palette for PDEV.
        !            83: *
        !            84: \**************************************************************************/
        !            85: 
        !            86: BOOL bInitDefaultPalette(PPDEV ppdev)
        !            87: {
        !            88:     ULONG ulLoop;
        !            89:     BYTE  jRed;
        !            90:     BYTE  jGre;
        !            91:     BYTE  jBlu;
        !            92: 
        !            93:     // Allocate our palette
        !            94: 
        !            95:     ppdev->pPal = (PPALETTEENTRY)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
        !            96:             (sizeof(PALETTEENTRY) * 256));
        !            97: 
        !            98:     if ((ppdev->pPal) == NULL)
        !            99:     {
        !           100:         RIP("Couldn't allocate default palette");
        !           101:         return(FALSE);
        !           102:     }
        !           103: 
        !           104:     // Generate 256 (8*4*4) RGB combinations to fill the palette
        !           105: 
        !           106:     jRed = jGre = jBlu = 0;
        !           107: 
        !           108:     for (ulLoop = 0; ulLoop < 256; ulLoop++)
        !           109:     {
        !           110:         ppdev->pPal[ulLoop].peRed   = jRed;
        !           111:         ppdev->pPal[ulLoop].peGreen = jGre;
        !           112:         ppdev->pPal[ulLoop].peBlue  = jBlu;
        !           113:         ppdev->pPal[ulLoop].peFlags = (BYTE)0;
        !           114: 
        !           115:         if (!((jRed += 8) & 0x3F))
        !           116:             if (!((jGre += 8) & 0x3F))
        !           117:                 jBlu += 16;
        !           118:     }
        !           119: 
        !           120: // Fill in Windows Reserved Colors from the WIN 3.0 DDK
        !           121: // The Window Manager reserved the first and last 10 colors for
        !           122: // painting windows borders and for non-palette managed applications.
        !           123: 
        !           124:     for (ulLoop = 0; ulLoop < 10; ulLoop++)
        !           125:     {
        !           126:     // First 10
        !           127: 
        !           128:         ppdev->pPal[ulLoop].peRed   = BASEPALETTE[ulLoop].peRed   ;
        !           129:         ppdev->pPal[ulLoop].peGreen = BASEPALETTE[ulLoop].peGreen ;
        !           130:         ppdev->pPal[ulLoop].peBlue  = BASEPALETTE[ulLoop].peBlue  ;
        !           131:         ppdev->pPal[ulLoop].peFlags = BASEPALETTE[ulLoop].peFlags;
        !           132: 
        !           133:     // Last 10
        !           134: 
        !           135:         ppdev->pPal[246+ulLoop].peRed   = BASEPALETTE[ulLoop+10].peRed   ;
        !           136:         ppdev->pPal[246+ulLoop].peGreen = BASEPALETTE[ulLoop+10].peGreen ;
        !           137:         ppdev->pPal[246+ulLoop].peBlue  = BASEPALETTE[ulLoop+10].peBlue  ;
        !           138:         ppdev->pPal[246+ulLoop].peFlags = BASEPALETTE[ulLoop+10].peFlags;
        !           139:     }
        !           140: 
        !           141: // Create handle for palette.
        !           142: 
        !           143:     ppdev->hpalDefault = EngCreatePalette(PAL_INDEXED,
        !           144:                                                256,
        !           145:                                                (PULONG) ppdev->pPal,
        !           146:                                                0,0,0);
        !           147:     ppdev->pDevInfo->hpalDefault = ppdev->hpalDefault;
        !           148: 
        !           149:     if (ppdev->hpalDefault == (HPALETTE) 0)
        !           150:     {
        !           151:         RIP("Couldn't create default palette");
        !           152:         LocalFree(ppdev->pPal);
        !           153:         return(FALSE);
        !           154:     }
        !           155: 
        !           156: // Initialize the hardware with the initial palette.
        !           157: 
        !           158:     return(TRUE);
        !           159: }
        !           160: 
        !           161: /******************************Public*Routine******************************\
        !           162: * bInit256ColorPalette
        !           163: *
        !           164: * Initialize the hardware's palette registers.
        !           165: *
        !           166: \**************************************************************************/
        !           167: 
        !           168: BOOL bInit256ColorPalette(PPDEV ppdev)
        !           169: {
        !           170:     BYTE          ajClutSpace[MAX_CLUT_SIZE];
        !           171:     PVIDEO_CLUT   pScreenClut = (PVIDEO_CLUT) ajClutSpace;
        !           172:     ULONG         ulReturnedDataLength;
        !           173:     PALETTEENTRY* ppalFrom;
        !           174:     PALETTEENTRY* ppalTo;
        !           175:     PALETTEENTRY* ppalEnd;
        !           176: 
        !           177:     // Fill in pScreenClut header info
        !           178: 
        !           179:     pScreenClut->NumEntries = 256;
        !           180:     pScreenClut->FirstEntry = 0;
        !           181: 
        !           182:     // Copy Colors in.
        !           183: 
        !           184:     ppalFrom = ppdev->pPal;
        !           185:     ppalTo   = (PALETTEENTRY*) pScreenClut->LookupTable;
        !           186:     ppalEnd  = &ppalTo[256];
        !           187: 
        !           188:     for (; ppalTo < ppalEnd; ppalFrom++, ppalTo++)
        !           189:     {
        !           190:         ppalTo->peRed   = ppalFrom->peRed   >> 2;
        !           191:         ppalTo->peGreen = ppalFrom->peGreen >> 2;
        !           192:         ppalTo->peBlue  = ppalFrom->peBlue  >> 2;
        !           193:         ppalTo->peFlags = 0;
        !           194:     }
        !           195: 
        !           196:     // Set palette registers
        !           197: 
        !           198:     if (!DeviceIoControl(ppdev->hDriver,
        !           199:                          IOCTL_VIDEO_SET_COLOR_REGISTERS,
        !           200:                          pScreenClut,
        !           201:                          MAX_CLUT_SIZE,
        !           202:                          NULL,
        !           203:                          0,
        !           204:                          &ulReturnedDataLength,
        !           205:                          NULL))
        !           206:     {
        !           207:         return(FALSE);
        !           208:     }
        !           209: 
        !           210:     return(TRUE);
        !           211: }
        !           212: 
        !           213: /******************************Public*Routine******************************\
        !           214: * DrvSetPalette
        !           215: *
        !           216: * DDI entry point for manipulating the palette.
        !           217: *
        !           218: \**************************************************************************/
        !           219: 
        !           220: BOOL DrvSetPalette(
        !           221: IN DHPDEV dhpdev,
        !           222: IN PALOBJ *ppalo,
        !           223: IN FLONG  fl,
        !           224: IN ULONG  iStart,
        !           225: IN ULONG  cColors)
        !           226: {
        !           227:     BYTE          ajClutSpace[MAX_CLUT_SIZE];
        !           228:     PVIDEO_CLUT   pScreenClut = (PVIDEO_CLUT) ajClutSpace;
        !           229:     PALETTEENTRY* ppal;
        !           230:     PALETTEENTRY* ppalEnd;
        !           231: 
        !           232:     UNREFERENCED_PARAMETER(fl);
        !           233: 
        !           234: // Fill in pScreenClut header info
        !           235: 
        !           236:     pScreenClut->NumEntries = (USHORT) cColors;
        !           237:     pScreenClut->FirstEntry = (USHORT) iStart;
        !           238: 
        !           239:     ppal = (PPALETTEENTRY) (pScreenClut->LookupTable);
        !           240: 
        !           241:     if (cColors != PALOBJ_cGetColors(ppalo, iStart, cColors, (PULONG) ppal))
        !           242:     {
        !           243:         return(FALSE);
        !           244:     }
        !           245: 
        !           246: // Set the high reserved byte in each palette entry to 0.
        !           247: 
        !           248:     for (ppalEnd = &ppal[cColors]; ppal < ppalEnd; ppal++)
        !           249:     {
        !           250:         ppal->peRed   >>= 2;
        !           251:         ppal->peGreen >>= 2;
        !           252:         ppal->peBlue  >>= 2;
        !           253:         ppal->peFlags = 0;
        !           254:     }
        !           255: 
        !           256: // Set palette registers
        !           257: 
        !           258:     if (!DeviceIoControl(((PPDEV)(dhpdev))->hDriver,
        !           259:                           IOCTL_VIDEO_SET_COLOR_REGISTERS,
        !           260:                           pScreenClut,
        !           261:                           MAX_CLUT_SIZE,
        !           262:                           NULL,
        !           263:                           0,
        !           264:                           &cColors,
        !           265:                           NULL))
        !           266:     {
        !           267:         return(FALSE);
        !           268:     }
        !           269: 
        !           270:     return(TRUE);
        !           271: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.