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] }