![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to enable.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / framebuf|
Return to enable.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / framebuf |
Microsoft Windows NT Build 511 (DDK SDK) 11-01-1993
/******************************Module*Header*******************************\
* Module Name: enable.c
*
* This module contains the functions that enable and disable the
* driver, the pdev, and the surface.
*
\**************************************************************************/
// #define DFB_ENABLED 1
#include "driver.h"
#ifdef DFB_ENABLED
BOOL DrvDFBTextOut(
SURFOBJ *pso,
STROBJ *pstro,
FONTOBJ *pfo,
CLIPOBJ *pco,
RECTL *prclExtra,
RECTL *prclOpaque,
BRUSHOBJ *pboFore,
BRUSHOBJ *pboOpaque,
POINTL *pptlOrg,
MIX mix);
#endif
// The driver function table with all function index/address pairs
static DRVFN gadrvfn[] =
{
{ INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV },
{ INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV },
{ INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV },
{ INDEX_DrvEnableSurface, (PFN) DrvEnableSurface },
{ INDEX_DrvDisableSurface, (PFN) DrvDisableSurface },
{ INDEX_DrvAssertMode, (PFN) DrvAssertMode },
{ INDEX_DrvSetPalette, (PFN) DrvSetPalette },
{ INDEX_DrvMovePointer, (PFN) DrvMovePointer },
{ INDEX_DrvSetPointerShape, (PFN) DrvSetPointerShape },
{ INDEX_DrvDitherColor, (PFN) DrvDitherColor },
#ifdef DFB_ENABLED
{ INDEX_DrvCreateDeviceBitmap, (PFN) DrvCreateDeviceBitmap },
{ INDEX_DrvDeleteDeviceBitmap, (PFN) DrvDeleteDeviceBitmap },
{ INDEX_DrvStrokePath, (PFN) DrvStrokePath },
{ INDEX_DrvCopyBits, (PFN) DrvCopyBits },
{ INDEX_DrvTextOut, (PFN) DrvDFBTextOut },
#else
#ifdef MIPS
{ INDEX_DrvTextOut, (PFN) DrvTextOut },
#endif
#endif
{ INDEX_DrvGetModes, (PFN) DrvGetModes }
};
// Define the functions you want to hook for 8/16/24/32 pel formats
#ifdef MIPS
#define HOOKS_BMF8BPP HOOK_TEXTOUT
#else
#define HOOKS_BMF8BPP 0
#endif
#define HOOKS_BMF16BPP 0
#define HOOKS_BMF24BPP 0
#define HOOKS_BMF32BPP 0
/******************************Public*Routine******************************\
* DrvEnableDriver
*
* Enables the driver by retrieving the drivers function table and version.
*
\**************************************************************************/
BOOL DrvEnableDriver(
ULONG iEngineVersion,
ULONG cj,
PDRVENABLEDATA pded)
{
// Engine Version is passed down so future drivers can support previous
// engine versions. A next generation driver can support both the old
// and new engine conventions if told what version of engine it is
// working with. For the first version the driver does nothing with it.
iEngineVersion;
// Fill in as much as we can.
if (cj >= sizeof(DRVENABLEDATA))
pded->pdrvfn = gadrvfn;
if (cj >= (sizeof(ULONG) * 2))
pded->c = sizeof(gadrvfn) / sizeof(DRVFN);
// DDI version this driver was targeted for is passed back to engine.
// Future graphic's engine may break calls down to old driver format.
if (cj >= sizeof(ULONG))
pded->iDriverVersion = DDI_DRIVER_VERSION;
return(TRUE);
}
/******************************Public*Routine******************************\
* DrvDisableDriver
*
* Tells the driver it is being disabled. Release any resources allocated in
* DrvEnableDriver.
*
\**************************************************************************/
VOID DrvDisableDriver(VOID)
{
return;
}
/******************************Public*Routine******************************\
* DrvEnablePDEV
*
* DDI function, Enables the Physical Device.
*
* Return Value: device handle to pdev.
*
\**************************************************************************/
DHPDEV DrvEnablePDEV(
DEVMODEW *pDevmode, // Pointer to DEVMODE
PWSTR pwszLogAddress, // Logical address
ULONG cPatterns, // number of patterns
HSURF *ahsurfPatterns, // return standard patterns
ULONG cjGdiInfo, // Length of memory pointed to by pGdiInfo
ULONG *pGdiInfo, // Pointer to GdiInfo structure
ULONG cjDevInfo, // Length of following PDEVINFO structure
DEVINFO *pDevInfo, // physical device information structure
PWSTR pwszDataFile, // DataFile - not used
PWSTR pwszDeviceName, // DeviceName - not used
HANDLE hDriver) // Handle to base driver
{
GDIINFO GdiInfo;
DEVINFO DevInfo;
PPDEV ppdev = (PPDEV) NULL;
UNREFERENCED_PARAMETER(pwszLogAddress);
UNREFERENCED_PARAMETER(pwszDataFile);
UNREFERENCED_PARAMETER(pwszDeviceName);
// Allocate a physical device structure.
ppdev = (PPDEV) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(PDEV));
if (ppdev == (PPDEV) NULL)
{
RIP("DISP DrvEnablePDEV failed LocalAlloc\n");
return((DHPDEV) 0);
}
// Save the screen handle in the PDEV.
ppdev->hDriver = hDriver;
// Get the current screen mode information. Set up device caps and devinfo.
if (!bInitPDEV(ppdev, pDevmode, &GdiInfo, &DevInfo))
{
DISPDBG((1,"DISP DrvEnablePDEV failed\n"));
goto error_free;
}
// Initialize the cursor information.
if (!bInitPointer(ppdev, &DevInfo))
{
// Not a fatal error...
DISPDBG((0, "DISP DrvEnableSurface failed bInitPointer\n"));
}
// Initialize palette information.
if (!bInitPaletteInfo(ppdev, &DevInfo))
{
RIP("DISP DrvEnableSurface failed bInitPalette\n");
goto error_free;
}
// Initialize device standard patterns.
if (!bInitPatterns(ppdev, min(cPatterns, HS_DDI_MAX)))
{
RIP("DISP DrvEnablePDEV failed bInitPatterns\n");
vDisablePatterns(ppdev);
vDisablePalette(ppdev);
goto error_free;
}
// Copy the devinfo into the engine buffer.
memcpy(pDevInfo, &DevInfo, min(sizeof(DEVINFO), cjDevInfo));
// Set the ahsurfPatterns array to handles each of the standard
// patterns that were just created.
memcpy((PVOID)ahsurfPatterns, ppdev->ahbmPat, ppdev->cPatterns*sizeof(HBITMAP));
// Set the pdevCaps with GdiInfo we have prepared to the list of caps for this
// pdev.
memcpy(pGdiInfo, &GdiInfo, min(cjGdiInfo, sizeof(GDIINFO)));
return((DHPDEV) ppdev);
// Error case for failure.
error_free:
LocalFree(ppdev);
RIP("DISP DrvEnablePDEV failed\n");
return((DHPDEV) 0);
}
/******************************Public*Routine******************************\
* DrvCompletePDEV
*
* Store the HPDEV, the engines handle for this PDEV, in the DHPDEV.
*
\**************************************************************************/
VOID DrvCompletePDEV(
DHPDEV dhpdev,
HDEV hdev)
{
((PPDEV) dhpdev)->hdevEng = hdev;
}
/******************************Public*Routine******************************\
* DrvDisablePDEV
*
* Release the resources allocated in DrvEnablePDEV. If a surface has been
* enabled DrvDisableSurface will have already been called.
*
\**************************************************************************/
VOID DrvDisablePDEV(
DHPDEV dhpdev)
{
vDisablePalette((PPDEV) dhpdev);
vDisablePatterns((PPDEV) dhpdev);
LocalFree(dhpdev);
}
/******************************Public*Routine******************************\
* DrvEnableSurface
*
* Enable the surface for the device. Hook the calls this driver supports.
*
* Return: Handle to the surface if successful, 0 for failure.
*
\**************************************************************************/
HSURF DrvEnableSurface(
DHPDEV dhpdev)
{
PPDEV ppdev;
HSURF hsurf;
SIZEL sizl;
ULONG ulBitmapType;
FLONG flHooks;
// Create engine bitmap around frame buffer.
ppdev = (PPDEV) dhpdev;
if (!bInitSURF(ppdev, TRUE))
{
RIP("DISP DrvEnableSurface failed bInitSURF\n");
return(FALSE);
}
sizl.cx = ppdev->cxScreen;
sizl.cy = ppdev->cyScreen;
if (ppdev->ulBitCount == 8)
{
if (!bInit256ColorPalette(ppdev)) {
RIP("DISP DrvEnableSurface failed to init the 8bpp palette\n");
return(FALSE);
}
ulBitmapType = BMF_8BPP;
flHooks = HOOKS_BMF8BPP;
}
else if (ppdev->ulBitCount == 16)
{
ulBitmapType = BMF_16BPP;
flHooks = HOOKS_BMF16BPP;
}
else if (ppdev->ulBitCount == 24)
{
ulBitmapType = BMF_24BPP;
flHooks = HOOKS_BMF24BPP;
}
else
{
ulBitmapType = BMF_32BPP;
flHooks = HOOKS_BMF32BPP;
}
hsurf = (HSURF) EngCreateBitmap(sizl,
ppdev->lDeltaScreen,
ulBitmapType,
(ppdev->lDeltaScreen > 0) ? BMF_TOPDOWN : 0,
(PVOID) (ppdev->pjScreen));
if (hsurf == (HSURF) 0)
{
RIP("DISP DrvEnableSurface failed EngCreateBitmap\n");
return(FALSE);
}
if (!EngAssociateSurface(hsurf, ppdev->hdevEng, flHooks))
{
RIP("DISP DrvEnableSurface failed EngAssociateSurface\n");
EngDeleteSurface(hsurf);
return(FALSE);
}
ppdev->hsurfEng = hsurf;
return(hsurf);
}
/******************************Public*Routine******************************\
* DrvDisableSurface
*
* Free resources allocated by DrvEnableSurface. Release the surface.
*
\**************************************************************************/
VOID DrvDisableSurface(
DHPDEV dhpdev)
{
EngDeleteSurface(((PPDEV) dhpdev)->hsurfEng);
vDisableSURF((PPDEV) dhpdev);
((PPDEV) dhpdev)->hsurfEng = (HSURF) 0;
}
/******************************Public*Routine******************************\
* DrvAssertMode
*
* This asks the device to reset itself to the mode of the pdev passed in.
*
\**************************************************************************/
VOID DrvAssertMode(
DHPDEV dhpdev,
BOOL bEnable)
{
PPDEV ppdev = (PPDEV) dhpdev;
ULONG ulReturn;
if (bEnable)
{
// The screen must be reenabled, reinitialize the device to clean state.
bInitSURF(ppdev, FALSE);
}
else
{
// We must give up the display.
// Call the kernel driver to reset the device to a known state.
if (!DeviceIoControl(ppdev->hDriver,
IOCTL_VIDEO_RESET_DEVICE,
NULL,
0,
NULL,
0,
&ulReturn,
NULL))
{
RIP("DISP DrvAssertMode failed IOCTL");
}
}
return;
}
/******************************Public*Routine******************************\
* DrvGetModes
*
* Returns the list of available modes for the device.
*
\**************************************************************************/
ULONG DrvGetModes(
HANDLE hDriver,
ULONG cjSize,
DEVMODEW *pdm)
{
DWORD cModes;
DWORD cbOutputSize;
PVIDEO_MODE_INFORMATION pVideoModeInformation, pVideoTemp;
DWORD cOutputModes = cjSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
DWORD cbModeSize;
DISPDBG((3, "Framebuf.dll:DrvGetModes\n"));
cModes = getAvailableModes(hDriver,
(PVIDEO_MODE_INFORMATION *) &pVideoModeInformation,
&cbModeSize);
if (cModes == 0)
{
DISPDBG((0, "FRAMEBUF DISP DrvGetModes failed to get mode information"));
return 0;
}
if (pdm == NULL)
{
cbOutputSize = cModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
}
else
{
//
// Now copy the information for the supported modes back into the output
// buffer
//
cbOutputSize = 0;
pVideoTemp = pVideoModeInformation;
do
{
if (pVideoTemp->Length != 0)
{
if (cOutputModes == 0)
{
break;
}
//
// Zero the entire structure to start off with.
//
memset(pdm, 0, sizeof(DEVMODEW));
//
// Set the name of the device to the name of the DLL.
//
memcpy(&(pdm->dmDeviceName), L"framebuf", sizeof(L"framebuf"));
pdm->dmSpecVersion = DM_SPECVERSION;
pdm->dmDriverVersion = DM_SPECVERSION;
//
// We currently do not support Extra information in the driver
//
pdm->dmDriverExtra = DRIVER_EXTRA_SIZE;
pdm->dmSize = sizeof(DEVMODEW);
pdm->dmBitsPerPel = pVideoTemp->NumberOfPlanes *
pVideoTemp->BitsPerPlane;
pdm->dmPelsWidth = pVideoTemp->VisScreenWidth;
pdm->dmPelsHeight = pVideoTemp->VisScreenHeight;
pdm->dmDisplayFrequency = pVideoTemp->Frequency;
if (pVideoTemp->AttributeFlags & VIDEO_MODE_INTERLACED)
{
pdm->dmDisplayFlags |= DM_INTERLACED;
}
//
// Go to the next DEVMODE entry in the buffer.
//
cOutputModes--;
pdm = (LPDEVMODEW) ( ((ULONG)pdm) + sizeof(DEVMODEW) +
DRIVER_EXTRA_SIZE);
cbOutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
}
pVideoTemp = (PVIDEO_MODE_INFORMATION)
(((PUCHAR)pVideoTemp) + cbModeSize);
} while (--cModes);
}
LocalFree(pVideoModeInformation);
return cbOutputSize;
}
#ifdef DFB_ENABLED
/*----------------------------------------------------------------------------
Test DFB implementation. Note to get much better performance drawing to
bitmaps we should hook DrvBitBlt, DrvPaint and pass back to their Eng
counter parts. We don't now to test our simulations better.
*/
ULONG gulCount = 0;
BOOL bPrintDelete = FALSE;
HBITMAP DrvCreateDeviceBitmap (DHPDEV dhpdev, SIZEL sizl, ULONG iFormat)
{
HBITMAP hbmEngine;
PPDEV pDevice = (PPDEV)dhpdev;
hbmEngine = EngCreateBitmap(sizl,0,iFormat,BMF_TOPDOWN,0);
if (hbmEngine)
{
if (EngAssociateSurface((HSURF) hbmEngine, pDevice->hdevEng, 0))
{
HBITMAP hbmDevice;
SURFOBJ *psoTemp;
if (psoTemp = EngLockSurface((HSURF) hbmEngine))
{
hbmDevice = EngCreateDeviceBitmap((DHSURF) psoTemp,sizl,iFormat);
if (hbmDevice)
{
if (EngAssociateSurface((HSURF) hbmDevice,pDevice->hdevEng,
HOOK_COPYBITS | HOOK_TEXTOUT | HOOK_STROKEPATH ))
{
gulCount++;
return(hbmDevice);
}
EngDeleteSurface((HSURF) hbmDevice);
}
EngUnlockSurface(psoTemp);
}
}
EngDeleteSurface((HSURF) hbmEngine);
}
return(0);
}
VOID DrvDeleteDeviceBitmap(DHSURF dhsurf)
{
HSURF hsurf = (HSURF) ((SURFOBJ *) dhsurf)->hsurf;
EngUnlockSurface((SURFOBJ *) dhsurf);
if (!EngDeleteSurface(hsurf))
DISPDBG((0, "FRAMEBUF failed EngDeleteSurface"));
gulCount--;
if (bPrintDelete)
DISPDBG((0, "DrvDelete %lu", gulCount));
}
BOOL DrvStrokePath(
SURFOBJ *pso,
PATHOBJ *ppo,
CLIPOBJ *pco,
XFORMOBJ *pxo,
BRUSHOBJ *pbo,
POINTL *pptlBrushOrg,
LINEATTRS *plineattrs,
MIX mix)
{
return(EngStrokePath((SURFOBJ *) pso->dhsurf,
ppo,
pco,
pxo,
pbo,
pptlBrushOrg,
plineattrs,
mix));
}
BOOL DrvDFBTextOut(
SURFOBJ *pso,
STROBJ *pstro,
FONTOBJ *pfo,
CLIPOBJ *pco,
RECTL *prclExtra,
RECTL *prclOpaque,
BRUSHOBJ *pboFore,
BRUSHOBJ *pboOpaque,
POINTL *pptlOrg,
MIX mix)
{
if (pso->iType == STYPE_DEVBITMAP)
{
return(EngTextOut((SURFOBJ *) pso->dhsurf,
pstro,
pfo,
pco,
prclExtra,
prclOpaque,
pboFore,
pboOpaque,
pptlOrg,
mix));
}
else
{
#ifdef MIPS
return(DrvTextOut(pso,
pstro,
pfo,
pco,
prclExtra,
prclOpaque,
pboFore,
pboOpaque,
pptlOrg,
mix));
#else
return(EngTextOut(pso,
pstro,
pfo,
pco,
prclExtra,
prclOpaque,
pboFore,
pboOpaque,
pptlOrg,
mix));
#endif
}
}
BOOL DrvCopyBits(
SURFOBJ *psoTrg,
SURFOBJ *psoSrc,
CLIPOBJ *pco,
XLATEOBJ *pxlo,
RECTL *prclTrg,
POINTL *pptlSrc)
{
SURFOBJ *psoT;
SURFOBJ *psoS;
if (psoTrg->iType == STYPE_DEVBITMAP)
psoT = (SURFOBJ *) psoTrg->dhsurf;
else
psoT = psoTrg;
if (psoSrc->iType == STYPE_DEVBITMAP)
psoS = (SURFOBJ *) psoSrc->dhsurf;
else
psoS = psoSrc;
return(EngCopyBits(psoT,
psoS,
pco,
pxlo,
prclTrg,
pptlSrc));
}
#endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.