void InitializeDevInfo(PVIDEO_MODE_INFORMATION pVideoModeInfo, PPDEV pDev,
DEVINFO *pDevInfo, ULONG ulDevInfoSize)
{
if ( pVideoModeInfo == NULL || pDevInfo == NULL ||
ulDevInfoSize < sizeof(DEVINFO) )
{
XenVesaDebugPrint(DEBUG_LEVEL_ERROR,
"Invalid input to initialize dev info!\n");
return;
}
RtlZeroMemory(pDevInfo, sizeof(DEVINFO));
pDevInfo->flGraphicsCaps = GCAPS_OPAQUERECT | GCAPS_LAYERED;
pDevInfo->cxDither = 8;
pDevInfo->cyDither = 8;
GetHTAndBMPFormat(
pVideoModeInfo->NumberOfPlanes * pVideoModeInfo->BitsPerPlane,
NULL, &pDevInfo->iDitherFormat);
/* Note: Taking the color mask from video mode info
* is resulting in palette display issues. So, going with
* the below.
*/
pDev->hPalette = pDevInfo->hpalDefault = EngCreatePalette(PAL_BITFIELDS,
0, NULL, 0xFF0000, 0xFF00, 0xFF);
}
SCODE
S3C6410Disp::SetMode (INT modeId, HPALETTE *palette)
{
SCODE scRet = S_OK;
ULONG *gBitMasks;
gBitMasks=DrvGetMasks(NULL);
RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++%s(%d)\n\r"), _T(__FUNCTION__), modeId));
if (modeId == 0)
{
m_dwPhysicalModeID = m_pMode->modeId;
// Create Palette
if (palette)
{
*palette = EngCreatePalette(PAL_BITFIELDS, 0, NULL, gBitMasks[0], gBitMasks[1], gBitMasks[2]);
}
}
else
{
RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] %s() : modeId = %d, Driver Support Only Mode 0\n\r"), _T(__FUNCTION__), modeId));
scRet = E_INVALIDARG;
}
RETAILMSG(DISP_ZONE_ENTER,(_T("[DISPDRV] --%s()\n\r"), _T(__FUNCTION__)));
return scRet;
}
BOOL
IntInitDefaultPalette(
PPDEV ppdev,
PDEVINFO pDevInfo)
{
ULONG ColorLoop;
PPALETTEENTRY PaletteEntryPtr;
if (ppdev->BitsPerPixel > 8)
{
ppdev->DefaultPalette = pDevInfo->hpalDefault =
EngCreatePalette(PAL_BITFIELDS, 0, NULL,
ppdev->RedMask, ppdev->GreenMask, ppdev->BlueMask);
}
else
{
ppdev->PaletteEntries = EngAllocMem(0, sizeof(PALETTEENTRY) << 8, ALLOC_TAG);
if (ppdev->PaletteEntries == NULL)
{
return FALSE;
}
for (ColorLoop = 256, PaletteEntryPtr = ppdev->PaletteEntries;
ColorLoop != 0;
ColorLoop--, PaletteEntryPtr++)
{
PaletteEntryPtr->peRed = ((ColorLoop >> 5) & 7) * 255 / 7;
PaletteEntryPtr->peGreen = ((ColorLoop >> 3) & 3) * 255 / 3;
PaletteEntryPtr->peBlue = (ColorLoop & 7) * 255 / 7;
PaletteEntryPtr->peFlags = 0;
}
memcpy(ppdev->PaletteEntries, BASEPALETTE, 10 * sizeof(PALETTEENTRY));
memcpy(ppdev->PaletteEntries + 246, BASEPALETTE + 10, 10 * sizeof(PALETTEENTRY));
ppdev->DefaultPalette = pDevInfo->hpalDefault =
EngCreatePalette(PAL_INDEXED, 256, (PULONG)ppdev->PaletteEntries, 0, 0, 0);
}
return ppdev->DefaultPalette != NULL;
}
BOOL InitPDEV(
LPFAXDEV lpCliFaxDev, // Pointer to the client side FAXDEV
LPFAXDEV lpSrvFaxDev, // Pointer to the server side FAXDEV
ULONG cPatterns, // Count of standard patterns
HSURF *phsurfPatterns, // Buffer for standard patterns
ULONG cjGdiInfo, // Size of buffer for GdiInfo
ULONG *pulGdiInfo, // Buffer for GDIINFO
ULONG cjDevInfo, // Number of bytes in devinfo
DEVINFO *pdevinfo // Device info
)
{
PGDIINFO pgdiinfo = (PGDIINFO)pulGdiInfo;
ULONG uColors[2];
if (!ValidateFaxDev(lpCliFaxDev)) {
return FALSE;
}
// lpSrvFaxDev hasn't been initialized yet, so just check pointer.
if (lpSrvFaxDev == NULL) {
LOGDEBUG(("WOWFAX!InitPDEV, failed, NULL lpSrvFaxDev parameter\n"));
return FALSE;
}
// Copy client FAXDEV to server.
RtlCopyMemory(lpSrvFaxDev, lpCliFaxDev, sizeof(FAXDEV));
// Copy GDIINFO from client FAXDEV to the GDI buffer for GDIINFO.
RtlCopyMemory(pgdiinfo, &(lpCliFaxDev->gdiinfo), sizeof(GDIINFO));
// Initialize the DEVINFO structure.
uColors[0] = RGB(0x00, 0x00, 0x00);
uColors[1] = RGB(0xff, 0xff, 0xff);
pdevinfo->hpalDefault = EngCreatePalette(PAL_INDEXED, 2, uColors, 0, 0, 0);
pdevinfo->iDitherFormat = BMF_1BPP;
// Make sure we don't journal.
pdevinfo->flGraphicsCaps |= GCAPS_DONTJOURNAL;
// Make sure we do dither.
pdevinfo->flGraphicsCaps |= GCAPS_HALFTONE | GCAPS_MONO_DITHER |
GCAPS_COLOR_DITHER;
// Copy the DEVINFO data to the server side FAXDEV.
RtlCopyMemory(&(lpSrvFaxDev->devinfo), pdevinfo, sizeof(DEVINFO));
return TRUE;
}
BOOL bInitializePalette(
PDEV* ppdev,
DEVINFO* pdi)
{
HPALETTE hpal;
hpal = EngCreatePalette(PAL_INDEXED, 16, (ULONG*) (logPalVGA.palPalEntry),
0, 0, 0);
if (hpal == 0)
goto ReturnFalse;
ppdev->hpalDefault = hpal;
pdi->hpalDefault = hpal;
return(TRUE);
ReturnFalse:
DISPDBG((0, "Failed bInitializePalette"));
return(FALSE);
}
BOOL bInitializePalette(
PDEV* ppdev,
DEVINFO* pdi)
{
PALETTEENTRY* ppal;
PALETTEENTRY* ppalTmp;
ULONG ulLoop;
BYTE jRed;
BYTE jGre;
BYTE jBlu;
HPALETTE hpal;
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*4*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
{
ASSERTDD((ppdev->iBitmapFormat == BMF_16BPP) ||
(ppdev->iBitmapFormat == BMF_24BPP) ||
(ppdev->iBitmapFormat == BMF_32BPP),
"This case handles only 16, 24 or 32bpp");
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((0, "Failed bInitializePalette"));
return(FALSE);
}
/* Creates default device palette */
int VBoxDispInitPalette(PVBOXDISPDEV pDev, DEVINFO *pDevInfo)
{
if (pDev->mode.ulBitsPerPel!=8)
{
pDev->hDefaultPalette = EngCreatePalette(PAL_BITFIELDS, 0, NULL,
pDev->mode.flMaskR, pDev->mode.flMaskG, pDev->mode.flMaskB);
if (!pDev->hDefaultPalette)
{
WARN(("EngCreatePalette failed"));
return VERR_GENERAL_FAILURE;
}
pDevInfo->hpalDefault = pDev->hDefaultPalette;
return VINF_SUCCESS;
}
/* Create driver managed palette.
* First entry should be black (0,0,0), last should be while (255, 255, 255).
* Note: Other entries should be set in similar way, so that entries with complementing indicies
* have quite contrast colors stored.
*/
pDev->pPalette = (PPALETTEENTRY) EngAllocMem(0, sizeof(PALETTEENTRY) * 256, MEM_ALLOC_TAG);
if (!pDev->pPalette)
{
WARN(("not enough memory!"));
return VERR_NO_MEMORY;
}
BYTE r=0, g=0, b=0;
for (ULONG i=0; i<256; ++i)
{
pDev->pPalette[i].peRed = r;
pDev->pPalette[i].peGreen = g;
pDev->pPalette[i].peBlue = b;
pDev->pPalette[i].peFlags = 0;
r += 32;
if (!r)
{
g += 32;
if (!g)
{
b += 64;
}
}
}
/* Now overwrite window decoration colors by common ones */
for (ULONG i=0; i<RT_ELEMENTS(defPal); ++i)
{
pDev->pPalette[i] = defPal[i];
pDev->pPalette[(~i)&0xFF] = defPalComp[i];
}
/* Sanity check in case we'd change palette filling */
Assert(pDev->pPalette[0].peRed==0 && pDev->pPalette[0].peGreen==0 && pDev->pPalette[0].peBlue==0);
Assert(pDev->pPalette[255].peRed==255 && pDev->pPalette[255].peGreen==255 && pDev->pPalette[255].peBlue==255);
pDev->hDefaultPalette = EngCreatePalette(PAL_INDEXED, 256, (PULONG)pDev->pPalette, 0, 0, 0);
if (!pDev->hDefaultPalette)
{
WARN(("EngCreatePalette failed"));
EngFreeMem(pDev->pPalette);
pDev->pPalette = NULL;
return VERR_GENERAL_FAILURE;
}
pDevInfo->hpalDefault = pDev->hDefaultPalette;
return VINF_SUCCESS;
}
BOOL bInitDefaultPalette(PPDEV ppdev, DEVINFO *pDevInfo)
{
if (ppdev->ulBitCount == 8)
{
ULONG ulLoop;
BYTE jRed,jGre,jBlu;
// Allocate our palette
ppdev->pPal = (PPALETTEENTRY)EngAllocMem(0, sizeof(PALETTEENTRY) * 256,
ALLOC_TAG);
if ((ppdev->pPal) == NULL) {
DISPDBG((0, "bInitDefaultPalette() failed EngAllocMem\n"));
return(FALSE);
}
// Generate 256 (8*4*4) RGB combinations to fill the palette
jRed = jGre = jBlu = 0;
for (ulLoop = 0; ulLoop < 256; ulLoop++)
{
ppdev->pPal[ulLoop].peRed = jRed;
ppdev->pPal[ulLoop].peGreen = jGre;
ppdev->pPal[ulLoop].peBlue = jBlu;
ppdev->pPal[ulLoop].peFlags = (BYTE)0;
if (!(jRed += 32))
if (!(jGre += 32))
jBlu += 64;
}
// Fill in Windows Reserved Colors from the WIN 3.0 DDK
// The Window Manager reserved the first and last 10 colors for
// painting windows borders and for non-palette managed applications.
for (ulLoop = 0; ulLoop < 10; ulLoop++)
{
// First 10
ppdev->pPal[ulLoop] = BASEPALETTE[ulLoop];
// Last 10
ppdev->pPal[246 + ulLoop] = BASEPALETTE[ulLoop+10];
}
// Create handle for palette.
ppdev->hpalDefault =
pDevInfo->hpalDefault = EngCreatePalette(PAL_INDEXED,
256,
(PULONG) ppdev->pPal,
0,0,0);
if (ppdev->hpalDefault == (HPALETTE) 0)
{
DISPDBG((0, "bInitDefaultPalette failed EngCreatePalette\n"));
EngFreeMem(ppdev->pPal);
return(FALSE);
}
// Initialize the hardware with the initial palette.
return(TRUE);
} else {
ppdev->hpalDefault =
pDevInfo->hpalDefault = EngCreatePalette(PAL_BITFIELDS,
0,(PULONG) NULL,
ppdev->flRed,
ppdev->flGreen,
ppdev->flBlue);
if (ppdev->hpalDefault == (HPALETTE) 0)
{
DISPDBG((0, "bInitDefaultPalette failed EngCreatePalette\n"));
return(FALSE);
}
}
return(TRUE);
}
DHPDEV DrvEnablePDEV
(
DEVMODEW *pdrivw,
PWSTR pwszLogAddress,
ULONG cPatterns,
HSURF *ahsurfPatterns,
ULONG cjGdiInfo,
ULONG *pdevcaps,
ULONG cb,
PDEVINFO pdevinfo,
HDEV hdev, // HDEV, used for callbacks
PWSTR pwszDeviceName,
HANDLE hDriver // Handle to base driver
)
{
PPDEV ppdev;
DISPDBG((2, "enabling PDEV\n"));
//
// Define flag to keep track of allocation
//
ppdev = (PPDEV) EngAllocMem(0, sizeof(PDEV), ALLOC_TAG);
if (ppdev == NULL)
{
goto errorAllocPDEV;
}
memset(ppdev, 0, sizeof(PDEV));
//
// Identifier, for debugging purposes
//
ppdev->ident = PDEV_IDENT;
//
// Cache the device driver handle away for later use.
//
ppdev->hDriver = hDriver;
//
// Initialize the cursor stuff. We can violate the atomic rule here
// since nobody can talk to the driver yet.
//
ppdev->xyCursor.x = 320; // Non-atomic
ppdev->xyCursor.y = 240; // Non-atomic
ppdev->ptlExtent.x = 0;
ppdev->ptlExtent.y = 0;
ppdev->cExtent = 0;
ppdev->flCursor = CURSOR_DOWN;
//
// Get the current screen mode information. Set up device caps and devinfo.
//
if (!bInitPDEV(ppdev, pdrivw, &gaulCap, &devinfoVGA))
{
DISPDBG((1, "DrvEnablePDEV failed bInitPDEV\n"));
goto errorbInitPDEV;
}
cjGdiInfo=min(cjGdiInfo, sizeof(GDIINFO));
memcpy(pdevcaps, &gaulCap, cjGdiInfo);
// Now let's pass back the devinfo
devinfoVGA.hpalDefault = EngCreatePalette(PAL_INDEXED, 16,
(PULONG) (logPalVGA.palPalEntry),
0, 0, 0);
if (devinfoVGA.hpalDefault == (HPALETTE) 0)
{
goto errorEngCreatePalette;
}
*pdevinfo = devinfoVGA;
// Try to preallocate a saved screen bits buffer. If we fail, set the flag
// to indicate the buffer is in use, so that we'll never attempt to use it.
// If we succeed, mark the buffer as free.
if ((ppdev->pjPreallocSSBBuffer = (PUCHAR)
EngAllocMem(0, PREALLOC_SSB_SIZE, ALLOC_TAG)) != NULL)
{
ppdev->flPreallocSSBBufferInUse = FALSE;
ppdev->ulPreallocSSBSize = PREALLOC_SSB_SIZE;
}
else
{
ppdev->flPreallocSSBBufferInUse = TRUE;
}
// Fill in the DIB4->VGA conversion tables. Allow 256 extra bytes so that
// we can always safely align the tables to a 256-byte boundary, for
// look-up reasons. There are four tables, each 256 bytes long
ppdev->pucDIB4ToVGAConvBuffer =
(UCHAR *) EngAllocMem(0, (256*4+256)*sizeof(UCHAR), ALLOC_TAG);
if (ppdev->pucDIB4ToVGAConvBuffer == NULL)
{
goto errorAllocpucDIB4ToVGAConvBuffer;
}
// Round the table start up to the nearest 256 byte boundary, because the
// tables must start on 256-byte boundaries for look-up reasons
ppdev->pucDIB4ToVGAConvTables =
(UCHAR *) ((ULONG) (ppdev->pucDIB4ToVGAConvBuffer + 0xFF) & ~0xFF);
vSetDIB4ToVGATables(ppdev->pucDIB4ToVGAConvTables);
return((DHPDEV) ppdev);
errorAllocpucDIB4ToVGAConvBuffer:
//
// Free the preallocated saved screen bits buffer, if there is one.
//
if (ppdev->pjPreallocSSBBuffer != NULL)
{
EngFreeMem(ppdev->pjPreallocSSBBuffer);
}
EngDeletePalette(devinfoVGA.hpalDefault);
errorEngCreatePalette:
errorbInitPDEV:
EngFreeMem(ppdev);
errorAllocPDEV:
return((DHPDEV) 0);
UNREFERENCED_PARAMETER(cb);
UNREFERENCED_PARAMETER(pwszLogAddress);
UNREFERENCED_PARAMETER(pwszDeviceName);
}
BOOL bInitDefaultPalette(PPDEV ppdev, DEVINFO *pDevInfo)
{
// eVb: 4.3 [VGARISC Change] - VGA Palette is static, no need to build
#if 0
if (ppdev->ulBitCount == 8)
{
ULONG ulLoop;
BYTE jRed,jGre,jBlu;
//
// Allocate our palette
//
ppdev->pPal = (PPALETTEENTRY)EngAllocMem(0, sizeof(PALETTEENTRY) * 256,
ALLOC_TAG);
if ((ppdev->pPal) == NULL) {
RIP("DISP bInitDefaultPalette() failed EngAllocMem\n");
return(FALSE);
}
//
// Generate 256 (8*4*4) RGB combinations to fill the palette
//
jRed = jGre = jBlu = 0;
for (ulLoop = 0; ulLoop < 256; ulLoop++)
{
ppdev->pPal[ulLoop].peRed = jRed;
ppdev->pPal[ulLoop].peGreen = jGre;
ppdev->pPal[ulLoop].peBlue = jBlu;
ppdev->pPal[ulLoop].peFlags = (BYTE)0;
if (!(jRed += 32))
if (!(jGre += 32))
jBlu += 64;
}
//
// Fill in Windows Reserved Colors from the WIN 3.0 DDK
// The Window Manager reserved the first and last 10 colors for
// painting windows borders and for non-palette managed applications.
//
for (ulLoop = 0; ulLoop < 10; ulLoop++)
{
//
// First 10
//
ppdev->pPal[ulLoop] = BASEPALETTE[ulLoop];
//
// Last 10
//
ppdev->pPal[246 + ulLoop] = BASEPALETTE[ulLoop+10];
}
#endif
// eVb: 4.3 [END]
//
// Create handle for palette.
//
ppdev->hpalDefault =
pDevInfo->hpalDefault = EngCreatePalette(PAL_INDEXED,
// eVb: 4.4 [VGARISC Change] - VGA Palette is 16 colors, not 256, and static
16,
(PULONG) &logPalVGA.palPalEntry,
// eVb: 4.4 [END]
0,0,0);
if (ppdev->hpalDefault == (HPALETTE) 0)
{
RIP("DISP bInitDefaultPalette failed EngCreatePalette\n");
// eVb: 4.5 [VGARISC Change] - VGA Palette is static, no need to free
//EngFreeMem(ppdev->pPal);
// eVb: 4.5 [END]
return(FALSE);
}
//
// Initialize the hardware with the initial palette.
//
return(TRUE);
// eVb: 4.6 [VGARISC Change] - VGA Palette is static, no bitfield palette needed
#if 0
} else {
ppdev->hpalDefault =
pDevInfo->hpalDefault = EngCreatePalette(PAL_BITFIELDS,
0,(PULONG) NULL,
ppdev->flRed,
ppdev->flGreen,
ppdev->flBlue);
if (ppdev->hpalDefault == (HPALETTE) 0)
{
RIP("DISP bInitDefaultPalette failed EngCreatePalette\n");
return(FALSE);
}
}
return(TRUE);
#endif
// eVb: 4.6 [END]
}
