reactos/win32ss/gdi/eng/ldevobj.c
Andriy Shevchenko 2ea03b5b22
[REACTOS] Fix typos in comments (#5591)
Fixing typos in code comments enhances code readability and comprehension for developers and collaborators.
2023-08-22 16:20:29 +03:00

952 lines
28 KiB
C

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Win32k subsystem
* PURPOSE: Support for logical devices
* FILE: win32ss/gdi/eng/ldevobj.c
* PROGRAMER: Timo Kreuzer (timo.kreuzer@reactos.org)
*/
#include <win32k.h>
#define NDEBUG
#include <debug.h>
DBG_DEFAULT_CHANNEL(EngLDev);
#ifndef RVA_TO_ADDR
#define RVA_TO_ADDR(Base,Rva) ((PVOID)(((ULONG_PTR)(Base)) + (Rva)))
#endif
/** Globals *******************************************************************/
static HSEMAPHORE ghsemLDEVList;
static LIST_ENTRY gleLdevListHead;
static LDEVOBJ *gpldevWin32k = NULL;
/** Private functions *********************************************************/
CODE_SEG("INIT")
NTSTATUS
NTAPI
InitLDEVImpl(VOID)
{
ULONG cbSize;
/* Initialize the LDEV list head */
InitializeListHead(&gleLdevListHead);
/* Initialize the loader lock */
ghsemLDEVList = EngCreateSemaphore();
if (!ghsemLDEVList)
{
ERR("Failed to create ghsemLDEVList\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
/* Allocate a LDEVOBJ for win32k */
gpldevWin32k = ExAllocatePoolWithTag(PagedPool,
sizeof(LDEVOBJ) +
sizeof(SYSTEM_GDI_DRIVER_INFORMATION),
GDITAG_LDEV);
if (!gpldevWin32k)
{
return STATUS_NO_MEMORY;
}
/* Initialize the LDEVOBJ for win32k */
gpldevWin32k->leLink.Flink = NULL;
gpldevWin32k->leLink.Blink = NULL;
gpldevWin32k->ldevtype = LDEV_DEVICE_DISPLAY;
gpldevWin32k->cRefs = 1;
gpldevWin32k->ulDriverVersion = GDI_ENGINE_VERSION;
gpldevWin32k->pGdiDriverInfo = (PVOID)(gpldevWin32k + 1);
RtlInitUnicodeString(&gpldevWin32k->pGdiDriverInfo->DriverName,
L"\\SystemRoot\\System32\\win32k.sys");
gpldevWin32k->pGdiDriverInfo->ImageAddress = &__ImageBase;
gpldevWin32k->pGdiDriverInfo->SectionPointer = NULL;
gpldevWin32k->pGdiDriverInfo->EntryPoint = (PVOID)DriverEntry;
gpldevWin32k->pGdiDriverInfo->ExportSectionPointer =
RtlImageDirectoryEntryToData(&__ImageBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_EXPORT,
&cbSize);
gpldevWin32k->pGdiDriverInfo->ImageLength = 0; // FIXME
return STATUS_SUCCESS;
}
static
PLDEVOBJ
LDEVOBJ_AllocLDEV(
_In_ LDEVTYPE ldevtype)
{
PLDEVOBJ pldev;
/* Allocate the structure from paged pool */
pldev = ExAllocatePoolWithTag(PagedPool, sizeof(LDEVOBJ), GDITAG_LDEV);
if (!pldev)
{
ERR("Failed to allocate LDEVOBJ.\n");
return NULL;
}
/* Zero out the structure */
RtlZeroMemory(pldev, sizeof(LDEVOBJ));
/* Set the ldevtype */
pldev->ldevtype = ldevtype;
return pldev;
}
static
VOID
LDEVOBJ_vFreeLDEV(
_In_ _Post_ptr_invalid_ PLDEVOBJ pldev)
{
/* Make sure we don't have a driver loaded */
ASSERT(pldev && pldev->pGdiDriverInfo == NULL);
ASSERT(pldev->cRefs == 0);
/* Free the memory */
ExFreePoolWithTag(pldev, GDITAG_LDEV);
}
static
BOOL
LDEVOBJ_bLoadImage(
_Inout_ PLDEVOBJ pldev,
_In_ PUNICODE_STRING pustrPathName)
{
PSYSTEM_GDI_DRIVER_INFORMATION pDriverInfo;
NTSTATUS Status;
ULONG cbSize;
/* Make sure no image is loaded yet */
ASSERT(pldev && pldev->pGdiDriverInfo == NULL);
/* Allocate a SYSTEM_GDI_DRIVER_INFORMATION structure */
cbSize = sizeof(SYSTEM_GDI_DRIVER_INFORMATION) + pustrPathName->Length;
pDriverInfo = ExAllocatePoolWithTag(PagedPool, cbSize, GDITAG_LDEV);
if (!pDriverInfo)
{
ERR("Failed to allocate SYSTEM_GDI_DRIVER_INFORMATION\n");
return FALSE;
}
/* Initialize the UNICODE_STRING and copy the driver name */
RtlInitEmptyUnicodeString(&pDriverInfo->DriverName,
(PWSTR)(pDriverInfo + 1),
pustrPathName->Length);
RtlCopyUnicodeString(&pDriverInfo->DriverName, pustrPathName);
/* Try to load the driver */
Status = ZwSetSystemInformation(SystemLoadGdiDriverInformation,
pDriverInfo,
sizeof(SYSTEM_GDI_DRIVER_INFORMATION));
if (!NT_SUCCESS(Status))
{
ERR("Failed to load a GDI driver: '%wZ', Status = 0x%lx\n",
pustrPathName, Status);
/* Free the allocated memory */
ExFreePoolWithTag(pDriverInfo, GDITAG_LDEV);
return FALSE;
}
/* Set the driver info */
pldev->pGdiDriverInfo = pDriverInfo;
/* Return success. */
return TRUE;
}
static
BOOL
LDEVOBJ_bEnableDriver(
_Inout_ PLDEVOBJ pldev,
_In_ PFN_DrvEnableDriver pfnEnableDriver)
{
DRVENABLEDATA ded;
ULONG i;
TRACE("LDEVOBJ_bEnableDriver('%wZ')\n", &pldev->pGdiDriverInfo->DriverName);
ASSERT(pldev);
ASSERT(pldev->cRefs == 0);
if (pldev->ldevtype == LDEV_IMAGE)
return TRUE;
/* Call the drivers DrvEnableDriver function */
RtlZeroMemory(&ded, sizeof(ded));
if (!pfnEnableDriver(GDI_ENGINE_VERSION, sizeof(ded), &ded))
{
ERR("DrvEnableDriver failed\n");
return FALSE;
}
/* Copy the returned driver version */
pldev->ulDriverVersion = ded.iDriverVersion;
/* Fill the driver function array */
for (i = 0; i < ded.c; i++)
{
pldev->apfn[ded.pdrvfn[i].iFunc] = ded.pdrvfn[i].pfn;
}
/* Return success. */
return TRUE;
}
static
VOID
LDEVOBJ_vDisableDriver(
_Inout_ PLDEVOBJ pldev)
{
ASSERT(pldev);
ASSERT(pldev->cRefs == 0);
TRACE("LDEVOBJ_vDisableDriver('%wZ')\n", &pldev->pGdiDriverInfo->DriverName);
if (pldev->ldevtype == LDEV_IMAGE)
return;
if (pldev->pfn.DisableDriver)
{
/* Call the unload function */
pldev->pfn.DisableDriver();
}
}
static
PVOID
LDEVOBJ_pvFindImageProcAddress(
_In_ PLDEVOBJ pldev,
_In_z_ LPSTR pszProcName)
{
PVOID pvImageBase;
PIMAGE_EXPORT_DIRECTORY pExportDir;
PVOID pvProcAdress = NULL;
PUSHORT pOrdinals;
PULONG pNames, pAddresses;
ULONG i;
/* Make sure we have a driver info */
ASSERT(pldev && pldev->pGdiDriverInfo != NULL);
/* Get the pointer to the export directory */
pvImageBase = pldev->pGdiDriverInfo->ImageAddress;
pExportDir = pldev->pGdiDriverInfo->ExportSectionPointer;
if (!pExportDir)
{
ERR("LDEVOBJ_pvFindImageProcAddress: no export section found\n");
return NULL;
}
/* Get pointers to some tables */
pNames = RVA_TO_ADDR(pvImageBase, pExportDir->AddressOfNames);
pOrdinals = RVA_TO_ADDR(pvImageBase, pExportDir->AddressOfNameOrdinals);
pAddresses = RVA_TO_ADDR(pvImageBase, pExportDir->AddressOfFunctions);
/* Loop the export table */
for (i = 0; i < pExportDir->NumberOfNames; i++)
{
/* Compare the name */
if (_stricmp(pszProcName, RVA_TO_ADDR(pvImageBase, pNames[i])) == 0)
{
/* Found! Calculate the procedure address */
pvProcAdress = RVA_TO_ADDR(pvImageBase, pAddresses[pOrdinals[i]]);
break;
}
}
/* Return the address */
return pvProcAdress;
}
static
BOOL
LDEVOBJ_bUnloadImage(
_Inout_ PLDEVOBJ pldev)
{
NTSTATUS Status;
/* Make sure we have a driver info */
ASSERT(pldev && pldev->pGdiDriverInfo != NULL);
ASSERT(pldev->cRefs == 0);
TRACE("LDEVOBJ_bUnloadImage('%wZ')\n", &pldev->pGdiDriverInfo->DriverName);
/* Unload the driver */
#if 0
Status = ZwSetSystemInformation(SystemUnloadGdiDriverInformation,
&pldev->pGdiDriverInfo->SectionPointer,
sizeof(HANDLE));
#else
/* Unfortunately, ntoskrnl allows unloading a driver, but fails loading
* it again with STATUS_IMAGE_ALREADY_LOADED. Prevent this problem by
* never unloading any driver.
*/
UNIMPLEMENTED;
Status = STATUS_NOT_IMPLEMENTED;
#endif
if (!NT_SUCCESS(Status))
return FALSE;
ExFreePoolWithTag(pldev->pGdiDriverInfo, GDITAG_LDEV);
pldev->pGdiDriverInfo = NULL;
return TRUE;
}
PLDEVOBJ
LDEVOBJ_pLoadInternal(
_In_ PFN_DrvEnableDriver pfnEnableDriver,
_In_ ULONG ldevtype)
{
PLDEVOBJ pldev;
TRACE("LDEVOBJ_pLoadInternal(%lu)\n", ldevtype);
/* Lock loader */
EngAcquireSemaphore(ghsemLDEVList);
/* Allocate a new LDEVOBJ */
pldev = LDEVOBJ_AllocLDEV(ldevtype);
if (!pldev)
{
ERR("Could not allocate LDEV\n");
goto leave;
}
/* Load the driver */
if (!LDEVOBJ_bEnableDriver(pldev, pfnEnableDriver))
{
ERR("LDEVOBJ_bEnableDriver failed\n");
LDEVOBJ_vFreeLDEV(pldev);
pldev = NULL;
goto leave;
}
/* Insert the LDEV into the global list */
InsertHeadList(&gleLdevListHead, &pldev->leLink);
/* Increase ref count */
pldev->cRefs++;
leave:
/* Unlock loader */
EngReleaseSemaphore(ghsemLDEVList);
TRACE("LDEVOBJ_pLoadInternal returning %p\n", pldev);
return pldev;
}
PLDEVOBJ
NTAPI
LDEVOBJ_pLoadDriver(
_In_z_ LPWSTR pwszDriverName,
_In_ ULONG ldevtype)
{
WCHAR acwBuffer[MAX_PATH];
PLIST_ENTRY pleLink;
PLDEVOBJ pldev;
UNICODE_STRING strDriverName;
SIZE_T cwcLength;
LPWSTR pwsz;
TRACE("LDEVOBJ_pLoadDriver(%ls, %lu)\n", pwszDriverName, ldevtype);
ASSERT(pwszDriverName);
/* Initialize buffer for the the driver name */
RtlInitEmptyUnicodeString(&strDriverName, acwBuffer, sizeof(acwBuffer));
/* Start path with systemroot */
RtlAppendUnicodeToString(&strDriverName, L"\\SystemRoot\\System32\\");
/* Get Length of given string */
cwcLength = wcslen(pwszDriverName);
/* Check if we have a system32 path given */
pwsz = pwszDriverName + cwcLength;
while (pwsz > pwszDriverName)
{
if ((*pwsz == L'\\') && (_wcsnicmp(pwsz, L"\\system32\\", 10) == 0))
{
/* Driver name starts after system32 */
pwsz += 10;
break;
}
pwsz--;
}
/* Append the driver name */
RtlAppendUnicodeToString(&strDriverName, pwsz);
/* MSDN says "The driver must include this suffix in the pwszDriver string."
But in fact it's optional. The function can also load .sys files without
appending the .dll extension. */
if ((cwcLength < 4) ||
((_wcsnicmp(pwszDriverName + cwcLength - 4, L".dll", 4) != 0) &&
(_wcsnicmp(pwszDriverName + cwcLength - 4, L".sys", 4) != 0)) )
{
/* Append the .dll suffix */
RtlAppendUnicodeToString(&strDriverName, L".dll");
}
/* Lock loader */
EngAcquireSemaphore(ghsemLDEVList);
/* Search the List of LDEVS for the driver name */
for (pleLink = gleLdevListHead.Flink;
pleLink != &gleLdevListHead;
pleLink = pleLink->Flink)
{
pldev = CONTAINING_RECORD(pleLink, LDEVOBJ, leLink);
/* Check if the ldev is associated with a file */
if (pldev->pGdiDriverInfo)
{
/* Check for match (case insensitive) */
if (RtlEqualUnicodeString(&pldev->pGdiDriverInfo->DriverName, &strDriverName, TRUE))
{
/* Image found in LDEV list */
break;
}
}
}
/* Did we find one? */
if (pleLink == &gleLdevListHead)
{
/* No, allocate a new LDEVOBJ */
pldev = LDEVOBJ_AllocLDEV(ldevtype);
if (!pldev)
{
ERR("Could not allocate LDEV\n");
goto leave;
}
/* Load the image */
if (!LDEVOBJ_bLoadImage(pldev, &strDriverName))
{
LDEVOBJ_vFreeLDEV(pldev);
pldev = NULL;
ERR("LDEVOBJ_bLoadImage failed\n");
goto leave;
}
/* Load the driver */
if (!LDEVOBJ_bEnableDriver(pldev, pldev->pGdiDriverInfo->EntryPoint))
{
ERR("LDEVOBJ_bEnableDriver failed\n");
/* Unload the image. */
if (LDEVOBJ_bUnloadImage(pldev))
LDEVOBJ_vFreeLDEV(pldev);
else
ERR("Could not unload driver. Leaking memory\n");
pldev = NULL;
goto leave;
}
/* Insert the LDEV into the global list */
InsertHeadList(&gleLdevListHead, &pldev->leLink);
}
/* Increase ref count */
pldev->cRefs++;
leave:
/* Unlock loader */
EngReleaseSemaphore(ghsemLDEVList);
TRACE("LDEVOBJ_pLoadDriver returning %p\n", pldev);
return pldev;
}
static
VOID
LDEVOBJ_vDereference(
_Inout_ PLDEVOBJ pldev)
{
/* Lock loader */
EngAcquireSemaphore(ghsemLDEVList);
/* Decrement reference count */
ASSERT(pldev->cRefs > 0);
pldev->cRefs--;
/* More references left? */
if (pldev->cRefs > 0)
{
EngReleaseSemaphore(ghsemLDEVList);
return;
}
LDEVOBJ_vDisableDriver(pldev);
if (LDEVOBJ_bUnloadImage(pldev))
{
/* Remove ldev from the list */
RemoveEntryList(&pldev->leLink);
/* Free the driver info structure */
LDEVOBJ_vFreeLDEV(pldev);
}
else
{
WARN("Failed to unload driver '%wZ', trying to re-enable it.\n", &pldev->pGdiDriverInfo->DriverName);
LDEVOBJ_bEnableDriver(pldev, pldev->pGdiDriverInfo->EntryPoint);
/* Increment again reference count */
pldev->cRefs++;
}
/* Unlock loader */
EngReleaseSemaphore(ghsemLDEVList);
}
ULONG
LDEVOBJ_ulGetDriverModes(
_In_ LPWSTR pwszDriverName,
_In_ HANDLE hDriver,
_Out_ PDEVMODEW *ppdm)
{
PLDEVOBJ pldev = NULL;
ULONG cbSize = 0;
PDEVMODEW pdm = NULL;
TRACE("LDEVOBJ_ulGetDriverModes('%ls', %p)\n", pwszDriverName, hDriver);
pldev = LDEVOBJ_pLoadDriver(pwszDriverName, LDEV_DEVICE_DISPLAY);
if (!pldev)
goto cleanup;
/* Mirror drivers may omit this function */
if (!pldev->pfn.GetModes)
goto cleanup;
/* Call the driver to get the required size */
cbSize = pldev->pfn.GetModes(hDriver, 0, NULL);
if (!cbSize)
{
ERR("DrvGetModes returned 0\n");
goto cleanup;
}
/* Allocate a buffer for the DEVMODE array */
pdm = ExAllocatePoolWithTag(PagedPool, cbSize, GDITAG_DEVMODE);
if (!pdm)
{
ERR("Could not allocate devmodeinfo\n");
goto cleanup;
}
/* Call the driver again to fill the buffer */
cbSize = pldev->pfn.GetModes(hDriver, cbSize, pdm);
if (!cbSize)
{
/* Could not get modes */
ERR("DrvrGetModes returned 0 on second call\n");
ExFreePoolWithTag(pdm, GDITAG_DEVMODE);
pdm = NULL;
}
cleanup:
if (pldev)
LDEVOBJ_vDereference(pldev);
*ppdm = pdm;
return cbSize;
}
BOOL
LDEVOBJ_bBuildDevmodeList(
_Inout_ PGRAPHICS_DEVICE pGraphicsDevice)
{
PWSTR pwsz;
PDEVMODEINFO pdminfo;
PDEVMODEW pdm, pdmEnd;
ULONG i, cModes = 0;
ULONG cbSize, cbFull;
if (pGraphicsDevice->pdevmodeInfo)
return TRUE;
ASSERT(pGraphicsDevice->pDevModeList == NULL);
pwsz = pGraphicsDevice->pDiplayDrivers;
/* Loop through the driver names
* This is a REG_MULTI_SZ string */
for (; *pwsz; pwsz += wcslen(pwsz) + 1)
{
/* Get the mode list from the driver */
TRACE("Trying driver: %ls\n", pwsz);
cbSize = LDEVOBJ_ulGetDriverModes(pwsz, pGraphicsDevice->DeviceObject, &pdm);
if (!cbSize)
{
WARN("Driver %ls returned no valid mode\n", pwsz);
continue;
}
/* Add space for the header */
cbFull = cbSize + FIELD_OFFSET(DEVMODEINFO, adevmode);
/* Allocate a buffer for the DEVMODE array */
pdminfo = ExAllocatePoolWithTag(PagedPool, cbFull, GDITAG_DEVMODE);
if (!pdminfo)
{
ERR("Could not allocate devmodeinfo\n");
ExFreePoolWithTag(pdm, GDITAG_DEVMODE);
continue;
}
pdminfo->cbdevmode = cbSize;
RtlCopyMemory(pdminfo->adevmode, pdm, cbSize);
ExFreePoolWithTag(pdm, GDITAG_DEVMODE);
/* Attach the mode info to the device */
pdminfo->pdmiNext = pGraphicsDevice->pdevmodeInfo;
pGraphicsDevice->pdevmodeInfo = pdminfo;
/* Loop all DEVMODEs */
pdmEnd = (DEVMODEW*)((PCHAR)pdminfo->adevmode + pdminfo->cbdevmode);
for (pdm = pdminfo->adevmode;
(pdm + 1 <= pdmEnd) && (pdm->dmSize != 0);
pdm = (DEVMODEW*)((PCHAR)pdm + pdm->dmSize + pdm->dmDriverExtra))
{
/* Count this DEVMODE */
cModes++;
/* Some drivers like the VBox driver don't fill the dmDeviceName
with the name of the display driver. So fix that here. */
RtlStringCbCopyW(pdm->dmDeviceName, sizeof(pdm->dmDeviceName), pwsz);
}
}
if (!pGraphicsDevice->pdevmodeInfo || cModes == 0)
{
ERR("No devmodes\n");
return FALSE;
}
/* Allocate an index buffer */
pGraphicsDevice->cDevModes = cModes;
pGraphicsDevice->pDevModeList = ExAllocatePoolWithTag(PagedPool,
cModes * sizeof(DEVMODEENTRY),
GDITAG_GDEVICE);
if (!pGraphicsDevice->pDevModeList)
{
ERR("No devmode list\n");
return FALSE;
}
/* Loop through all DEVMODEINFOs */
for (pdminfo = pGraphicsDevice->pdevmodeInfo, i = 0;
pdminfo;
pdminfo = pdminfo->pdmiNext)
{
/* Calculate End of the DEVMODEs */
pdmEnd = (DEVMODEW*)((PCHAR)pdminfo->adevmode + pdminfo->cbdevmode);
/* Loop through the DEVMODEs */
for (pdm = pdminfo->adevmode;
(pdm + 1 <= pdmEnd) && (pdm->dmSize != 0);
pdm = (PDEVMODEW)((PCHAR)pdm + pdm->dmSize + pdm->dmDriverExtra))
{
TRACE(" %S has mode %lux%lux%lu(%lu Hz)\n",
pdm->dmDeviceName,
pdm->dmPelsWidth,
pdm->dmPelsHeight,
pdm->dmBitsPerPel,
pdm->dmDisplayFrequency);
/* Initialize the entry */
pGraphicsDevice->pDevModeList[i].dwFlags = 0;
pGraphicsDevice->pDevModeList[i].pdm = pdm;
i++;
}
}
return TRUE;
}
/* Search the closest display mode according to some settings.
* Note that we don't care about the DM_* flags in dmFields, but check if value != 0 instead */
static
BOOL
LDEVOBJ_bGetClosestMode(
_Inout_ PGRAPHICS_DEVICE pGraphicsDevice,
_In_ PDEVMODEW RequestedMode,
_Out_ PDEVMODEW *pSelectedMode)
{
DEVMODEW dmDiff;
PDEVMODEW pdmCurrent, pdmBest = NULL;
ULONG i;
/* Use a DEVMODE to keep the differences between best mode found and expected mode.
* Initialize fields to max value so we can find better modes. */
dmDiff.dmPelsWidth = 0xffffffff;
dmDiff.dmPelsHeight = 0xffffffff;
dmDiff.dmBitsPerPel = 0xffffffff;
dmDiff.dmDisplayFrequency = 0xffffffff;
/* Search the closest mode */
#define DM_DIFF(field) (RequestedMode->field > pdmCurrent->field ? (RequestedMode->field - pdmCurrent->field) : (pdmCurrent->field - RequestedMode->field))
for (i = 0; i < pGraphicsDevice->cDevModes; i++)
{
pdmCurrent = pGraphicsDevice->pDevModeList[i].pdm;
/* Skip current mode if it is worse than best mode found */
if (RequestedMode->dmPelsWidth != 0 && DM_DIFF(dmPelsWidth) > dmDiff.dmPelsWidth)
continue;
if (RequestedMode->dmPelsHeight != 0 && DM_DIFF(dmPelsHeight) > dmDiff.dmPelsHeight)
continue;
if (RequestedMode->dmBitsPerPel != 0 && DM_DIFF(dmBitsPerPel) > dmDiff.dmBitsPerPel)
continue;
if (RequestedMode->dmDisplayFrequency != 0 && DM_DIFF(dmDisplayFrequency) > dmDiff.dmDisplayFrequency)
continue;
/* Better (or equivalent) mode found. Update differences */
dmDiff.dmPelsWidth = DM_DIFF(dmPelsWidth);
dmDiff.dmPelsHeight = DM_DIFF(dmPelsHeight);
dmDiff.dmBitsPerPel = DM_DIFF(dmBitsPerPel);
dmDiff.dmDisplayFrequency = DM_DIFF(dmDisplayFrequency);
pdmBest = pdmCurrent;
}
#undef DM_DIFF
if (pdmBest)
{
TRACE("Closest display mode to '%dx%dx%d %d Hz' is '%dx%dx%d %d Hz'\n",
RequestedMode->dmPelsWidth,
RequestedMode->dmPelsHeight,
RequestedMode->dmBitsPerPel,
RequestedMode->dmDisplayFrequency,
pdmBest->dmPelsWidth,
pdmBest->dmPelsHeight,
pdmBest->dmBitsPerPel,
pdmBest->dmDisplayFrequency);
}
*pSelectedMode = pdmBest;
return pdmBest != NULL;
}
BOOL
LDEVOBJ_bProbeAndCaptureDevmode(
_Inout_ PGRAPHICS_DEVICE pGraphicsDevice,
_In_ PDEVMODEW RequestedMode,
_Out_ PDEVMODEW *pSelectedMode,
_In_ BOOL bSearchClosestMode)
{
DEVMODEW dmSearch;
PDEVMODEW pdmCurrent, pdm, pdmSelected = NULL;
ULONG i;
ULONG ulVirtualWidth = 0, ulVirtualHeight = 0;
BOOL bResult = TRUE;
NTSTATUS Status;
if (!LDEVOBJ_bBuildDevmodeList(pGraphicsDevice))
return FALSE;
/* At first, load information from registry */
RtlZeroMemory(&dmSearch, sizeof(dmSearch));
Status = EngpGetDisplayDriverParameters(pGraphicsDevice, &dmSearch);
if (!NT_SUCCESS(Status))
{
ERR("EngpGetDisplayDriverParameters() failed with status 0x%08x\n", Status);
return FALSE;
}
/* Override values with the new ones provided */
_SEH2_TRY
{
bSearchClosestMode |= RequestedMode->dmFields == 0;
/* Copy standard fields (if provided) */
if (RequestedMode->dmFields & DM_BITSPERPEL && RequestedMode->dmBitsPerPel != 0)
dmSearch.dmBitsPerPel = RequestedMode->dmBitsPerPel;
if (RequestedMode->dmFields & DM_PELSWIDTH && RequestedMode->dmPelsWidth != 0)
dmSearch.dmPelsWidth = RequestedMode->dmPelsWidth;
if (RequestedMode->dmFields & DM_PELSHEIGHT && RequestedMode->dmPelsHeight != 0)
dmSearch.dmPelsHeight = RequestedMode->dmPelsHeight;
if (RequestedMode->dmFields & DM_DISPLAYFREQUENCY && RequestedMode->dmDisplayFrequency != 0)
dmSearch.dmDisplayFrequency = RequestedMode->dmDisplayFrequency;
if ((RequestedMode->dmFields & (DM_PANNINGWIDTH | DM_PANNINGHEIGHT)) == (DM_PANNINGWIDTH | DM_PANNINGHEIGHT) &&
RequestedMode->dmPanningWidth != 0 && RequestedMode->dmPanningHeight != 0 &&
RequestedMode->dmPanningWidth < dmSearch.dmPelsWidth &&
RequestedMode->dmPanningHeight < dmSearch.dmPelsHeight)
{
/* Get new panning values */
ulVirtualWidth = RequestedMode->dmPelsWidth;
ulVirtualHeight = RequestedMode->dmPelsHeight;
dmSearch.dmPelsWidth = RequestedMode->dmPanningWidth;
dmSearch.dmPelsHeight = RequestedMode->dmPanningHeight;
}
else if (dmSearch.dmPanningWidth != 0 && dmSearch.dmPanningHeight != 0 &&
dmSearch.dmPanningWidth < dmSearch.dmPelsWidth &&
dmSearch.dmPanningHeight < dmSearch.dmPelsHeight)
{
/* Keep existing panning values */
ulVirtualWidth = dmSearch.dmPelsWidth;
ulVirtualHeight = dmSearch.dmPelsHeight;
dmSearch.dmPelsWidth = dmSearch.dmPanningWidth;
dmSearch.dmPelsHeight = dmSearch.dmPanningHeight;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
bResult = FALSE;
}
_SEH2_END;
if (!bResult)
return FALSE;
if (LDEVOBJ_bGetClosestMode(pGraphicsDevice, &dmSearch, &pdmSelected))
{
if (bSearchClosestMode)
{
/* Ok, found a closest mode. Update search */
dmSearch.dmBitsPerPel = pdmSelected->dmBitsPerPel;
dmSearch.dmPelsWidth = pdmSelected->dmPelsWidth;
dmSearch.dmPelsHeight = pdmSelected->dmPelsHeight;
dmSearch.dmDisplayFrequency = pdmSelected->dmDisplayFrequency;
}
else
{
/* Only update not provided fields */
_SEH2_TRY
{
if (!(RequestedMode->dmFields & DM_BITSPERPEL) || RequestedMode->dmBitsPerPel == 0)
dmSearch.dmBitsPerPel = pdmSelected->dmBitsPerPel;
if (!(RequestedMode->dmFields & DM_PELSWIDTH) || RequestedMode->dmPelsWidth == 0)
dmSearch.dmPelsWidth = pdmSelected->dmPelsWidth;
if (!(RequestedMode->dmFields & DM_PELSHEIGHT) || RequestedMode->dmPelsHeight == 0)
dmSearch.dmPelsHeight = pdmSelected->dmPelsHeight;
if (!(RequestedMode->dmFields & DM_DISPLAYFREQUENCY) || RequestedMode->dmDisplayFrequency == 0)
dmSearch.dmDisplayFrequency = pdmSelected->dmDisplayFrequency;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
bResult = FALSE;
}
_SEH2_END;
if (!bResult)
return FALSE;
}
}
/* Now, search the exact mode to return to caller */
for (i = 0; i < pGraphicsDevice->cDevModes; i++)
{
pdmCurrent = pGraphicsDevice->pDevModeList[i].pdm;
/* For now, we only need those */
if (pdmCurrent->dmBitsPerPel != dmSearch.dmBitsPerPel)
continue;
if (pdmCurrent->dmPelsWidth != dmSearch.dmPelsWidth)
continue;
if (pdmCurrent->dmPelsHeight != dmSearch.dmPelsHeight)
continue;
if (pdmCurrent->dmDisplayFrequency != dmSearch.dmDisplayFrequency)
continue;
pdmSelected = pdmCurrent;
break;
}
if (!pdmSelected)
{
ERR("Requested mode not found (%dx%dx%d %d Hz)\n",
dmSearch.dmPelsWidth,
dmSearch.dmPelsHeight,
dmSearch.dmBitsPerPel,
dmSearch.dmDisplayFrequency);
return FALSE;
}
/* Allocate memory for output */
pdm = ExAllocatePoolZero(PagedPool, pdmSelected->dmSize + pdmSelected->dmDriverExtra, GDITAG_DEVMODE);
if (!pdm)
return FALSE;
/* Copy selected mode */
RtlCopyMemory(pdm, pdmSelected, pdmSelected->dmSize);
RtlCopyMemory((PVOID)((ULONG_PTR)pdm + pdm->dmSize),
(PVOID)((ULONG_PTR)pdmSelected + pdmSelected->dmSize),
pdmSelected->dmDriverExtra);
/* Add back panning */
if (ulVirtualWidth != 0 && ulVirtualHeight != 0 &&
pdm->dmPelsWidth < ulVirtualWidth &&
pdm->dmPelsHeight < ulVirtualHeight)
{
pdm->dmFields |= DM_PANNINGWIDTH | DM_PANNINGHEIGHT;
pdm->dmPanningWidth = pdm->dmPelsWidth;
pdm->dmPanningHeight = pdm->dmPelsHeight;
pdm->dmPelsWidth = ulVirtualWidth;
pdm->dmPelsHeight = ulVirtualHeight;
}
*pSelectedMode = pdm;
return TRUE;
}
/** Exported functions ********************************************************/
HANDLE
APIENTRY
EngLoadImage(
_In_ LPWSTR pwszDriverName)
{
return (HANDLE)LDEVOBJ_pLoadDriver(pwszDriverName, LDEV_IMAGE);
}
VOID
APIENTRY
EngUnloadImage(
_In_ HANDLE hModule)
{
PLDEVOBJ pldev = (PLDEVOBJ)hModule;
/* Make sure the LDEV is in the list */
ASSERT((pldev->leLink.Flink != NULL) && (pldev->leLink.Blink != NULL));
LDEVOBJ_vDereference(pldev);
}
PVOID
APIENTRY
EngFindImageProcAddress(
_In_ HANDLE hModule,
_In_ LPSTR lpProcName)
{
PLDEVOBJ pldev = (PLDEVOBJ)hModule;
ASSERT(gpldevWin32k != NULL);
/* Check if win32k is requested */
if (!pldev)
{
pldev = gpldevWin32k;
}
/* Check if the drivers entry point is requested */
if (_strnicmp(lpProcName, "DrvEnableDriver", 15) == 0)
{
return pldev->pGdiDriverInfo->EntryPoint;
}
/* Try to find the address */
return LDEVOBJ_pvFindImageProcAddress(pldev, lpProcName);
}
/* EOF */