You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
538 lines
16 KiB
538 lines
16 KiB
/******************************Module*Header**********************************\
|
|
*
|
|
* *******************
|
|
* * GDI SAMPLE CODE *
|
|
* *******************
|
|
*
|
|
* Module Name: palette.c
|
|
*
|
|
* Content: Palette support.
|
|
*
|
|
* Copyright (c) 1994-1999 3Dlabs Inc. Ltd. All rights reserved.
|
|
* Copyright (c) 1995-2003 Microsoft Corporation. All rights reserved.
|
|
\*****************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#include "glint.h"
|
|
#include <math.h>
|
|
|
|
// Global Table defining the 20 Window default colours. For 256 colour
|
|
// palettes the first 10 must be put at the beginning of the palette
|
|
// and the last 10 at the end of the palette.
|
|
|
|
PALETTEENTRY gapalBase[20] =
|
|
{
|
|
{ 0, 0, 0, 0 }, // 0
|
|
{ 0x80,0, 0, 0 }, // 1
|
|
{ 0, 0x80,0, 0 }, // 2
|
|
{ 0x80,0x80,0, 0 }, // 3
|
|
{ 0, 0, 0x80,0 }, // 4
|
|
{ 0x80,0, 0x80,0 }, // 5
|
|
{ 0, 0x80,0x80,0 }, // 6
|
|
{ 0xC0,0xC0,0xC0,0 }, // 7
|
|
{ 192, 220, 192, 0 }, // 8
|
|
{ 166, 202, 240, 0 }, // 9
|
|
{ 255, 251, 240, 0 }, // 10
|
|
{ 160, 160, 164, 0 }, // 11
|
|
{ 0x80,0x80,0x80,0 }, // 12
|
|
{ 0xFF,0, 0 ,0 }, // 13
|
|
{ 0, 0xFF,0 ,0 }, // 14
|
|
{ 0xFF,0xFF,0 ,0 }, // 15
|
|
{ 0 ,0, 0xFF,0 }, // 16
|
|
{ 0xFF,0, 0xFF,0 }, // 17
|
|
{ 0, 0xFF,0xFF,0 }, // 18
|
|
{ 0xFF,0xFF,0xFF,0 }, // 19
|
|
};
|
|
|
|
/******************************Public*Routine******************************\
|
|
* BOOL bInitializePalette
|
|
*
|
|
* Initializes default palette for PDEV.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL bInitializePalette(
|
|
PDEV* ppdev,
|
|
DEVINFO* pdi)
|
|
{
|
|
PALETTEENTRY* ppal;
|
|
PALETTEENTRY* ppalTmp;
|
|
ULONG ulLoop;
|
|
ULONG ulMask;
|
|
BYTE jRed;
|
|
BYTE jGre;
|
|
BYTE jBlu;
|
|
HPALETTE hpal;
|
|
|
|
DISPDBG((DBGLVL, "bInitializePalette called"));
|
|
|
|
// mask is zero for palette driven modes
|
|
ulMask = ppdev->flRed | ppdev->flGreen | ppdev->flBlue;
|
|
if ((ppdev->iBitmapFormat == BMF_8BPP) && (ulMask == 0))
|
|
{
|
|
// Allocate our palette:
|
|
|
|
ppal = (PALETTEENTRY*)ENGALLOCMEM(FL_ZERO_MEMORY,
|
|
(sizeof(PALETTEENTRY) * 256), ALLOC_TAG_GDI(F));
|
|
if (ppal == NULL)
|
|
{
|
|
goto ReturnFalse;
|
|
}
|
|
|
|
ppdev->pPal = ppal;
|
|
|
|
// Generate 256 (8*8*4) RGB combinations to fill the palette
|
|
|
|
jRed = 0;
|
|
jGre = 0;
|
|
jBlu = 0;
|
|
|
|
ppalTmp = ppal;
|
|
|
|
for (ulLoop = 256; ulLoop != 0; ulLoop--)
|
|
{
|
|
ppalTmp->peRed = jRed;
|
|
ppalTmp->peGreen = jGre;
|
|
ppalTmp->peBlue = jBlu;
|
|
ppalTmp->peFlags = 0;
|
|
|
|
ppalTmp++;
|
|
|
|
if (!(jRed += 32))
|
|
{
|
|
if (!(jGre += 32))
|
|
{
|
|
jBlu += 64;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fill in Windows reserved colours from the WIN 3.0 DDK
|
|
// The Window Manager reserved the first and last 10 colours for
|
|
// painting windows borders and for non-palette managed applications.
|
|
|
|
for (ulLoop = 0; ulLoop < 10; ulLoop++)
|
|
{
|
|
// First 10
|
|
|
|
ppal[ulLoop] = gapalBase[ulLoop];
|
|
|
|
// Last 10
|
|
|
|
ppal[246 + ulLoop] = gapalBase[ulLoop+10];
|
|
}
|
|
|
|
// Create handle for palette.
|
|
|
|
hpal = EngCreatePalette(PAL_INDEXED, 256, (ULONG*) ppal, 0, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
DISPDBG((DBGLVL, "creating True Color palette, "
|
|
"masks rgb = 0x%x, 0x%x, 0x%x",
|
|
ppdev->flRed, ppdev->flGreen, ppdev->flBlue));
|
|
|
|
hpal = EngCreatePalette(PAL_BITFIELDS, 0, NULL,
|
|
ppdev->flRed, ppdev->flGreen, ppdev->flBlue);
|
|
}
|
|
|
|
ppdev->hpalDefault = hpal;
|
|
pdi->hpalDefault = hpal;
|
|
|
|
if (hpal == 0)
|
|
{
|
|
goto ReturnFalse;
|
|
}
|
|
|
|
return(TRUE);
|
|
|
|
ReturnFalse:
|
|
|
|
DISPDBG((WRNLVL, "Failed bInitializePalette"));
|
|
return(FALSE);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* VOID vUninitializePalette
|
|
*
|
|
* Frees resources allocated by bInitializePalette.
|
|
*
|
|
* Note: In an error case, this may be called before bInitializePalette.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID vUninitializePalette(PDEV* ppdev)
|
|
{
|
|
// Delete the default palette if we created one:
|
|
|
|
if (ppdev->hpalDefault != 0)
|
|
{
|
|
EngDeletePalette(ppdev->hpalDefault);
|
|
}
|
|
|
|
if (ppdev->pPal != (PALETTEENTRY*) NULL)
|
|
{
|
|
ENGFREEMEM(ppdev->pPal);
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* BOOL bEnablePalette
|
|
*
|
|
* Initialize the hardware's 8bpp palette registers.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL bEnablePalette(PDEV* ppdev)
|
|
{
|
|
BYTE ajClutSpace[MAX_CLUT_SIZE];
|
|
PVIDEO_CLUT pScreenClut;
|
|
ULONG ulReturnedDataLength;
|
|
ULONG ulMask;
|
|
|
|
DISPDBG((DBGLVL, "bEnablePalette called"));
|
|
|
|
ulMask = ppdev->flRed | ppdev->flGreen | ppdev->flBlue;
|
|
|
|
if ((ppdev->iBitmapFormat == BMF_8BPP) && (ulMask == 0))
|
|
{
|
|
// Fill in pScreenClut header info:
|
|
pScreenClut = (PVIDEO_CLUT) ajClutSpace;
|
|
pScreenClut->NumEntries = 256;
|
|
pScreenClut->FirstEntry = 0;
|
|
|
|
// Copy colours in:
|
|
//@@BEGIN_DDKSPLIT
|
|
#pragma prefast(suppress: 203, "pScreenClut points to sufficient ajClutSpace (PREfast bug 611168)")
|
|
//@@END_DDKSPLIT
|
|
RtlCopyMemory(pScreenClut->LookupTable, ppdev->pPal,
|
|
sizeof(ULONG) * 256);
|
|
|
|
// Set palette registers:
|
|
if (EngDeviceIoControl(ppdev->hDriver,
|
|
IOCTL_VIDEO_SET_COLOR_REGISTERS,
|
|
pScreenClut,
|
|
MAX_CLUT_SIZE,
|
|
NULL,
|
|
0,
|
|
&ulReturnedDataLength))
|
|
{
|
|
DISPDBG((WRNLVL, "Failed bEnablePalette"));
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
DISPDBG((DBGLVL, "Passed bEnablePalette"));
|
|
return(TRUE);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* VOID vDisablePalette
|
|
*
|
|
* Undoes anything done in bEnablePalette.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID vDisablePalette(
|
|
PDEV* ppdev)
|
|
{
|
|
// Nothin' to do
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* VOID vAssertModePalette
|
|
*
|
|
* Sets/resets the palette in preparation for full-screen/graphics mode.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID vAssertModePalette(
|
|
PDEV* ppdev,
|
|
BOOL bEnable)
|
|
{
|
|
// USER immediately calls DrvSetPalette after switching out of
|
|
// full-screen, so we don't have to worry about resetting the
|
|
// palette here.
|
|
#if(_WIN32_WINNT >= 0x500)
|
|
// UPDATE: Windows 2000 in multi-monitor mode: DrvSetPalette only sent
|
|
// to the primary monitor on exit from fullscreen (and then only if the
|
|
// primary is in 8bpp mode). If the primary is not 8bpp indexed, but
|
|
// the secondary is, there is no DrvSetPalette for the secondary, even
|
|
// though it was sent DrvAssertMode(FALSE)
|
|
if(bEnable)
|
|
bEnablePalette(ppdev);
|
|
else
|
|
vDisablePalette(ppdev);
|
|
#endif
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* BOOL DrvSetPalette
|
|
*
|
|
* DDI entry point for manipulating the palette.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL DrvSetPalette(
|
|
DHPDEV dhpdev,
|
|
PALOBJ* ppalo,
|
|
FLONG fl,
|
|
ULONG iStart,
|
|
ULONG cColors)
|
|
{
|
|
BYTE ajClutSpace[MAX_CLUT_SIZE];
|
|
PVIDEO_CLUT pScreenClut;
|
|
PVIDEO_CLUTDATA pScreenClutData;
|
|
PDEV* ppdev;
|
|
ULONG ulMask;
|
|
|
|
UNREFERENCED_PARAMETER(fl);
|
|
|
|
ppdev = (PDEV*) dhpdev;
|
|
|
|
ulMask = ppdev->flRed | ppdev->flGreen | ppdev->flBlue;
|
|
|
|
if (ulMask != 0)
|
|
{
|
|
DISPDBG((WRNLVL, "DrvSetPalette: trying to set true color palette"));
|
|
return FALSE;
|
|
}
|
|
|
|
// Fill in pScreenClut header info:
|
|
|
|
pScreenClut = (PVIDEO_CLUT) ajClutSpace;
|
|
pScreenClut->NumEntries = (USHORT) cColors;
|
|
pScreenClut->FirstEntry = (USHORT) iStart;
|
|
|
|
pScreenClutData = (PVIDEO_CLUTDATA) (&(pScreenClut->LookupTable[0]));
|
|
|
|
if (cColors != PALOBJ_cGetColors(ppalo, iStart, cColors,
|
|
(ULONG*) pScreenClutData))
|
|
{
|
|
DISPDBG((WRNLVL, "DrvSetPalette failed PALOBJ_cGetColors\n"));
|
|
goto ReturnFalse;
|
|
}
|
|
|
|
// Set the high reserved byte in each palette entry to 0.
|
|
|
|
while(cColors--)
|
|
{
|
|
pScreenClutData[cColors].Unused = 0;
|
|
}
|
|
|
|
// Set palette registers
|
|
|
|
if (EngDeviceIoControl(ppdev->hDriver,
|
|
IOCTL_VIDEO_SET_COLOR_REGISTERS,
|
|
(PVOID)pScreenClut,
|
|
MAX_CLUT_SIZE,
|
|
NULL,
|
|
0,
|
|
&cColors))
|
|
{
|
|
DISPDBG((WRNLVL, "DrvSetPalette failed DeviceIoControl\n"));
|
|
goto ReturnFalse;
|
|
}
|
|
|
|
return(TRUE);
|
|
|
|
ReturnFalse:
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* BOOL bInstallGammaLUT
|
|
*
|
|
* Load a given gamma LUT into the RAMDAC and also save it in the registry.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL
|
|
bInstallGammaLUT(PPDEV ppdev, PVIDEO_CLUT pScreenClut, BOOL waitVBlank)
|
|
{
|
|
ULONG ulReturnedDataLength;
|
|
BOOL bRet;
|
|
GLINT_DECL;
|
|
|
|
// only do this for 15, 16 or 32 bpp. Not 15/16 for RGB640.
|
|
if ((ppdev->ulWhite == 0x0f0f0f) || (ppdev->cPelSize == 0) ||
|
|
((ppdev->flCaps & CAPS_RGB640_POINTER) && (ppdev->cPelSize == 1)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (glintInfo->OverlayMode == GLINT_ENABLE_OVERLAY)
|
|
{
|
|
DISPDBG((WRNLVL, "Overlays enabled. cannot install GAMMA LUT"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (pScreenClut->NumEntries == 0)
|
|
{
|
|
DISPDBG((WRNLVL, "bInstallGammaLUT: Empty LUT"));
|
|
return TRUE;
|
|
}
|
|
|
|
// Set palette registers.
|
|
if (waitVBlank)
|
|
{
|
|
GLINT_WAIT_FOR_VBLANK;
|
|
}
|
|
|
|
bRet = !EngDeviceIoControl(
|
|
ppdev->hDriver,
|
|
IOCTL_VIDEO_SET_COLOR_REGISTERS,
|
|
pScreenClut,
|
|
MAX_CLUT_SIZE,
|
|
NULL,
|
|
0,
|
|
&ulReturnedDataLength);
|
|
|
|
//@@BEGIN_DDKSPLIT
|
|
#if 0
|
|
// if we succeeded save the ramp in the registry and locally
|
|
|
|
if (bRet)
|
|
{
|
|
bGlintRegistrySaveGammaLUT(ppdev, pScreenClut);
|
|
}
|
|
#endif
|
|
//@@END_DDKSPLIT
|
|
|
|
return(bRet);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* VOID vSetNewGammaValue
|
|
*
|
|
* Loads up a true color palette with the specified gamma correction factor.
|
|
* This is straightforward for 24 bit true color. For 15 and 16 bpp we rely
|
|
* on the miniport having enabled the palette for sparse lookup. i.e. each
|
|
* 5 or 6 bit component is shifted left to create an 8 bit component before
|
|
* the lookup.
|
|
*
|
|
* Note: the display driver shouldn't really do anything with floats or
|
|
* doubles. I restrict their use to this function which is why the gamma
|
|
* value is presented as a 16.16 fixed point number. And this function must
|
|
* be called only from within an OPELGL escape. On NT 4 FP regs are saved
|
|
* and restored for OGL escapes only.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
vSetNewGammaValue(PPDEV ppdev, ULONG ulgv, BOOL waitVBlank)
|
|
{
|
|
PVIDEO_CLUTDATA pScreenClutData;
|
|
BYTE ajClutSpace[MAX_CLUT_SIZE];
|
|
PVIDEO_CLUT pScreenClut;
|
|
ULONG i;
|
|
UCHAR gc;
|
|
double gv;
|
|
double dcol;
|
|
GLINT_DECL;
|
|
|
|
// gamma can't be zero or we blow up
|
|
if (ulgv == 0)
|
|
{
|
|
DISPDBG((WRNLVL, "can't use gamma value of zero"));
|
|
return;
|
|
}
|
|
|
|
// only do this for 15, 16 or 32 bpp.
|
|
|
|
if ((ppdev->ulWhite == 0x0f0f0f) || (ppdev->cPelSize == 0))
|
|
{
|
|
return;
|
|
}
|
|
|
|
pScreenClut = (PVIDEO_CLUT) ajClutSpace;
|
|
pScreenClut->NumEntries = 256;
|
|
pScreenClut->FirstEntry = 0;
|
|
|
|
pScreenClutData = (PVIDEO_CLUTDATA) (&(pScreenClut->LookupTable[0]));
|
|
|
|
//
|
|
// special case gamma of 1.0 so we can load the LUT at startup without
|
|
// needing any floating point calculations. NT 4 only allows FP ops in
|
|
// an OGL escape. Can't use FLOATOBJ because we need to use pow().
|
|
//
|
|
if (ulgv == 0x10000)
|
|
{
|
|
for (i = 0; i < 256; ++i)
|
|
{
|
|
pScreenClutData[i].Red = (UCHAR)i;
|
|
pScreenClutData[i].Green = (UCHAR)i;
|
|
pScreenClutData[i].Blue = (UCHAR)i;
|
|
pScreenClutData[i].Unused = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// pre-work out 1/gamma
|
|
gv = (double)(ulgv >> 16) + (double)(ulgv & 0xffff) / 65536.0;
|
|
gv = 1.0 / gv;
|
|
|
|
for (i = 0; i < 256; ++i)
|
|
{
|
|
dcol = (double)i;
|
|
gc = (UCHAR)(255.0 * pow((dcol/255.0), gv));
|
|
|
|
pScreenClutData[i].Red = gc;
|
|
pScreenClutData[i].Green = gc;
|
|
pScreenClutData[i].Blue = gc;
|
|
pScreenClutData[i].Unused = 0;
|
|
}
|
|
}
|
|
|
|
if (bInstallGammaLUT(ppdev, pScreenClut, waitVBlank))
|
|
{
|
|
RtlCopyMemory(&glintInfo->gammaLUT, pScreenClut, MAX_CLUT_SIZE);
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// FUNC: DrvIcmSetDeviceGammaRamp
|
|
// ARGS: dhpdev (I) - handle to physical device object
|
|
// iFormat (I) - always IGRF_RGB_256WORDS
|
|
// lpRamp (I) - when iFormat == IGRF_RGB_256WORDS, this points to a
|
|
// GAMMARAMP structure
|
|
// RETN: TRUE if successful
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the hardware Gamma ramp
|
|
//*****************************************************************************
|
|
|
|
BOOL DrvIcmSetDeviceGammaRamp(DHPDEV dhpdev, ULONG iFormat, VOID *pRamp)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
PDEV *ppdev = (PDEV *) dhpdev;
|
|
GAMMARAMP *pgr = (GAMMARAMP *)pRamp;
|
|
PVIDEO_CLUTDATA pScreenClutData;
|
|
BYTE ajClutSpace[MAX_CLUT_SIZE];
|
|
PVIDEO_CLUT pScreenClut;
|
|
ULONG i;
|
|
ULONG cj;
|
|
|
|
DISPDBG((DBGLVL, "DrvIcmSetDeviceGammaRamp"));
|
|
|
|
if(iFormat == IGRF_RGB_256WORDS)
|
|
{
|
|
pScreenClut = (PVIDEO_CLUT) ajClutSpace;
|
|
pScreenClut->NumEntries = 256;
|
|
pScreenClut->FirstEntry = 0;
|
|
|
|
pScreenClutData = (PVIDEO_CLUTDATA) (&(pScreenClut->LookupTable[0]));
|
|
|
|
for (i = 0; i < 256; ++i)
|
|
{
|
|
pScreenClutData[i].Red = (UCHAR)(pgr->Red[i] >> 8);
|
|
pScreenClutData[i].Green = (UCHAR)(pgr->Green[i] >> 8);
|
|
pScreenClutData[i].Blue = (UCHAR)(pgr->Blue[i] >> 8);
|
|
pScreenClutData[i].Unused = 0;
|
|
}
|
|
|
|
bRet = bInstallGammaLUT(ppdev, pScreenClut, FALSE);
|
|
}
|
|
|
|
return(bRet);
|
|
}
|