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.
481 lines
14 KiB
481 lines
14 KiB
/******************************Module*Header***********************************\
|
|
* Module Name: palette.c
|
|
*
|
|
* Palette support.
|
|
*
|
|
* Copyright (c) 1994-1998 3Dlabs Inc. Ltd. All rights reserved.
|
|
* Copyright (c) 1995-1999 Microsoft Corporation. All rights reserved.
|
|
\******************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#include <math.h>
|
|
#define ALLOC_TAG ALLOC_TAG_AP2P
|
|
// 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
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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;
|
|
|
|
DBG_GDI((7, "bInitializePalette"));
|
|
|
|
if ( ppdev->iBitmapFormat == BMF_8BPP )
|
|
{
|
|
//
|
|
// Allocate our palette:
|
|
//
|
|
|
|
ppal = (PALETTEENTRY*)ENGALLOCMEM(FL_ZERO_MEMORY,
|
|
sizeof(PALETTEENTRY) * 256,
|
|
ALLOC_TAG);
|
|
|
|
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
|
|
{
|
|
DBG_GDI((7, "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:
|
|
DBG_GDI((0, "Failed bInitializePalette"));
|
|
return(FALSE);
|
|
|
|
}// bInitializePalette()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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;
|
|
|
|
if (ppdev->iBitmapFormat == BMF_8BPP)
|
|
{
|
|
// 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))
|
|
{
|
|
DBG_GDI((0, "Failed bEnablePalette"));
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
DBG_GDI((1, "Passed bEnablePalette"));
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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;
|
|
|
|
DBG_GDI((3, "DrvSetPalette called"));
|
|
|
|
ulMask = ppdev->flRed | ppdev->flGreen | ppdev->flBlue;
|
|
if (ulMask != 0)
|
|
{
|
|
DBG_GDI((1, "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))
|
|
{
|
|
DBG_GDI((0, "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))
|
|
{
|
|
DBG_GDI((0, "DrvSetPalette failed DeviceIoControl\n"));
|
|
goto ReturnFalse;
|
|
}
|
|
|
|
return(TRUE);
|
|
|
|
ReturnFalse:
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// BOOL bInstallGammaLUT
|
|
//
|
|
// Load a given gamma LUT into the RAMDAC and also save it in the registry.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
bInstallGammaLUT(PPDev ppdev, PVIDEO_CLUT pScreenClut)
|
|
{
|
|
ULONG ulReturnedDataLength;
|
|
BOOL bRet;
|
|
PERMEDIA_DECL;
|
|
|
|
// only do this for 16 or 32 bpp.
|
|
if ((ppdev->ulWhite == 0x0f0f0f) || (ppdev->cPelSize == P2DEPTH8))
|
|
return FALSE;
|
|
|
|
if (pScreenClut->NumEntries == 0)
|
|
{
|
|
DBG_GDI((1, "bInstallGammaLUT: Empty LUT"));
|
|
return TRUE;
|
|
}
|
|
|
|
// Set palette registers.
|
|
|
|
bRet = !EngDeviceIoControl(
|
|
ppdev->hDriver,
|
|
IOCTL_VIDEO_SET_COLOR_REGISTERS,
|
|
pScreenClut,
|
|
MAX_CLUT_SIZE,
|
|
NULL,
|
|
0,
|
|
&ulReturnedDataLength);
|
|
// if we succeeded save the ramp in the registry and locally
|
|
if (bRet)
|
|
bRegistrySaveGammaLUT(ppdev, pScreenClut);
|
|
|
|
return(bRet);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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)
|
|
{
|
|
PVIDEO_CLUTDATA pScreenClutData;
|
|
BYTE ajClutSpace[MAX_CLUT_SIZE];
|
|
PVIDEO_CLUT pScreenClut;
|
|
ULONG i;
|
|
UCHAR gc;
|
|
double gv;
|
|
double dcol;
|
|
PERMEDIA_DECL;
|
|
|
|
// gamma can't be zero or we blow up
|
|
if (ulgv == 0)
|
|
{
|
|
DBG_GDI((1, "can't use gamma value of zero"));
|
|
return;
|
|
}
|
|
|
|
// only do this for 16 or 32 bpp.
|
|
if ((ppdev->ulWhite == 0x0f0f0f) || (ppdev->cPelSize == P2DEPTH8))
|
|
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.
|
|
//
|
|
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))
|
|
RtlCopyMemory(&permediaInfo->gammaLUT, pScreenClut, MAX_CLUT_SIZE);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// BOOL DrvIcmSetDeviceGammaRamp
|
|
//
|
|
//@@BEGIN_DDKSPLIT
|
|
// TODO: provide description.
|
|
//@@END_DDKSPLIT
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL DrvIcmSetDeviceGammaRamp(
|
|
DHPDEV dhpdev,
|
|
ULONG iFormat,
|
|
LPVOID lpRamp
|
|
)
|
|
{
|
|
PPDev ppdev = (PPDev) dhpdev;
|
|
GAMMARAMP * pramp = (GAMMARAMP *) lpRamp;
|
|
PVIDEO_CLUTDATA pScreenClutData;
|
|
BYTE ajClutSpace[MAX_CLUT_SIZE];
|
|
PVIDEO_CLUT pScreenClut;
|
|
ULONG i;
|
|
ULONG ulReturnedDataLength;
|
|
BOOL bRet;
|
|
PERMEDIA_DECL;
|
|
|
|
DBG_GDI((3, "DrvIcmSetDeviceGammaRamp called"));
|
|
|
|
if(iFormat != IGRF_RGB_256WORDS)
|
|
return FALSE;
|
|
|
|
|
|
// only do this for 16 or 32 bpp. Not 15/16 for RGB640.
|
|
if ((ppdev->ulWhite == 0x0f0f0f) || (ppdev->cPelSize == P2DEPTH8))
|
|
return FALSE;
|
|
|
|
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)(pramp->Red[i] >> 8);
|
|
pScreenClutData[i].Green = (UCHAR)(pramp->Green[i] >> 8);
|
|
pScreenClutData[i].Blue = (UCHAR)(pramp->Blue[i] >> 8);
|
|
pScreenClutData[i].Unused = 0;
|
|
}
|
|
|
|
bRet = !EngDeviceIoControl(
|
|
ppdev->hDriver,
|
|
IOCTL_VIDEO_SET_COLOR_REGISTERS,
|
|
pScreenClut,
|
|
MAX_CLUT_SIZE,
|
|
NULL,
|
|
0,
|
|
&ulReturnedDataLength);
|
|
|
|
return bRet;
|
|
|
|
}
|
|
|