[ros-diffs] [reactos] 05/06: [WIN32SS] Implement panning driver

[Hervé Poussineau]

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=4e0f2fc01c8fd44432ccd…

commit 4e0f2fc01c8fd44432ccd3553ad3f9ec6e4e7bef
Author:     Hervé Poussineau <hpoussin(a)reactos.org>
AuthorDate: Sun May 8 22:23:32 2022 +0200
Commit:     hpoussin <32227662+hpoussin(a)users.noreply.github.com>
CommitDate: Sat May 14 21:29:12 2022 +0200

    [WIN32SS] Implement panning driver
    
    This can be configured in registry with DefaultSettings.XPanning and
    DefaultSettings.YPanning, which describe the real screen resolution.
    
    DefaultSettings.XResolution and DefaultSettings.YResolution describe
    the resolution of the virtual screen.
---
 win32ss/CMakeLists.txt    |   1 +
 win32ss/gdi/eng/pandisp.c | 501 ++++++++++++++++++++++++++++++++++++++++++++++
 win32ss/gdi/eng/pdevobj.c |  22 +-
 3 files changed, 523 insertions(+), 1 deletion(-)

diff --git a/win32ss/CMakeLists.txt b/win32ss/CMakeLists.txt
index 0a7dd1492de..16026d6275e 100644
--- a/win32ss/CMakeLists.txt
+++ b/win32ss/CMakeLists.txt
@@ -78,6 +78,7 @@ list(APPEND SOURCE
     gdi/eng/engmisc.c
     gdi/eng/mouse.c
     gdi/eng/multidisp.c
+    gdi/eng/pandisp.c
     gdi/eng/paint.c
     gdi/eng/pathobj.c
     gdi/eng/pdevobj.c
diff --git a/win32ss/gdi/eng/pandisp.c b/win32ss/gdi/eng/pandisp.c
new file mode 100644
index 00000000000..9f1a4f8c916
--- /dev/null
+++ b/win32ss/gdi/eng/pandisp.c
@@ -0,0 +1,501 @@
+/*
+ * PROJECT:     ReactOS Win32k subsystem
+ * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
+ * PURPOSE:     Pan-Display driver
+ * COPYRIGHT:   Copyright 2022 Hervé Poussineau <hpoussin(a)reactos.org>
+ */
+
+/* INCLUDES *******************************************************************/
+
+#include <win32k.h>
+#define NDEBUG
+#include <debug.h>
+
+#define TAG_PAN 'DnaP'
+#define GETPFN(name) ((PFN_Drv##name)(pandev->apfn[INDEX_Drv##name]))
+
+static DHPDEV gPan; /* FIXME: remove once PanSynchronize() is called periodically */
+
+typedef struct _PANDEV
+{
+    ULONG iBitmapFormat;
+    HDEV hdev;
+    SIZEL szlDesktop; /* Size of the whole desktop */
+    RECTL rclViewport; /* Viewport area */
+    HSURF hsurf; /* Global surface */
+    HSURF hsurfShadow; /* Our shadow surface, used for drawing */
+    SURFOBJ *psoShadow;
+
+    /* Underlying PDEVOBJ */
+    ULONG flUnderlyingGraphicsCaps;
+    SIZEL szlScreen;
+    DHPDEV dhpdevScreen;
+    BOOL enabledScreen; /* underlying surface enabled */
+    SURFOBJ *surfObjScreen;
+    PFN apfn[INDEX_LAST]; /* Functions of underlying PDEVOBJ */
+} PANDEV, *PPANDEV;
+
+BOOL
+APIENTRY
+PanSynchronize(
+    _In_ DHPDEV dhpdev,
+    _In_ PRECTL prcl)
+{
+    PPANDEV pandev = (PPANDEV)dhpdev;
+    RECTL rclDest;
+    POINTL ptlSrc;
+
+    /* FIXME: for now, copy the whole shadow buffer. We might try to optimize that */
+
+    ptlSrc.x = pandev->rclViewport.left;
+    ptlSrc.y = pandev->rclViewport.top;
+
+    rclDest.top = rclDest.left = 0;
+    rclDest.bottom = pandev->szlScreen.cy;
+    rclDest.right = pandev->szlScreen.cx;
+
+    return EngCopyBits(pandev->surfObjScreen, pandev->psoShadow, NULL, NULL,
&rclDest, &ptlSrc);
+}
+
+DHPDEV
+APIENTRY
+PanEnablePDEV(
+    _In_ PDEVMODEW pdm,
+    _In_ LPWSTR pwszLogAddress,
+    _In_ ULONG cPat,
+    _In_reads_opt_(cPat) HSURF *phsurfPatterns,
+    _In_ ULONG cjCaps,
+    _Out_writes_bytes_(cjCaps) PULONG pdevcaps,
+    _In_ ULONG cjDevInfo,
+    _Out_writes_bytes_(cjDevInfo) PDEVINFO pdi,
+    _In_ HDEV hdev,
+    _In_ LPWSTR pwszDeviceName,
+    _In_ HANDLE hDriver)
+{
+    PPANDEV pandev;
+    PPDEVOBJ ppdev = (PPDEVOBJ)hdev;
+    DEVMODEW underlyingDevmode;
+    PGDIINFO pGdiInfo = (PGDIINFO)pdevcaps;
+
+    DPRINT("PanEnablePDEV(ppdev %p %dx%dx%d -> %dx%dx%d %d Hz)\n",
+           ppdev,
+           pdm->dmPelsWidth, pdm->dmPelsHeight, pdm->dmBitsPerPel,
+           pdm->dmPanningWidth, pdm->dmPanningHeight, pdm->dmBitsPerPel,
pdm->dmDisplayFrequency);
+
+    ASSERT(pdm->dmPanningWidth <= pdm->dmPelsWidth &&
pdm->dmPanningHeight <= pdm->dmPelsHeight);
+
+    /* Allocate PANDEV */
+    pandev = EngAllocMem(FL_ZERO_MEMORY, sizeof(PANDEV), TAG_PAN);
+    if (!pandev)
+    {
+        DPRINT1("Failed to allocate memory\n");
+        return NULL;
+    }
+
+    /* Copy device pointers to our structure (do not copy ppdev->apfn,
+     * as it contains our local pointers!) */
+    RtlCopyMemory(pandev->apfn, ppdev->pldev->apfn, sizeof(pandev->apfn));
+
+    /* Enable underlying PDEV */
+    underlyingDevmode = *pdm;
+    underlyingDevmode.dmPelsWidth = pdm->dmPanningWidth;
+    underlyingDevmode.dmPelsHeight = pdm->dmPanningHeight;
+    pandev->dhpdevScreen = GETPFN(EnablePDEV)(&underlyingDevmode,
+                                              pwszLogAddress,
+                                              cPat,
+                                              phsurfPatterns,
+                                              cjCaps,
+                                              pdevcaps,
+                                              cjDevInfo,
+                                              pdi,
+                                              hdev,
+                                              pwszDeviceName,
+                                              hDriver);
+    if (!pandev->dhpdevScreen)
+    {
+        DPRINT1("Failed to enable underlying PDEV\n");
+        EngFreeMem(pandev);
+        return NULL;
+    }
+
+    pandev->iBitmapFormat = pdi->iDitherFormat;
+    pandev->szlDesktop.cx = pdm->dmPelsWidth;
+    pandev->szlDesktop.cy = pdm->dmPelsHeight;
+    pandev->szlScreen.cx = pdm->dmPanningWidth;
+    pandev->szlScreen.cy = pdm->dmPanningHeight;
+    pandev->flUnderlyingGraphicsCaps = pdi->flGraphicsCaps;
+
+    /* Upgrade some capabilities */
+    pGdiInfo->ulHorzRes = pdm->dmPelsWidth;
+    pGdiInfo->ulVertRes = pdm->dmPelsHeight;
+    pdi->flGraphicsCaps |= GCAPS_PANNING;
+    pdi->flGraphicsCaps2 = GCAPS2_SYNCFLUSH | GCAPS2_SYNCTIMER;
+
+    gPan = (DHPDEV)pandev;
+    return (DHPDEV)pandev;
+}
+
+VOID
+APIENTRY
+PanCompletePDEV(
+    _In_ DHPDEV dhpdev,
+    _In_ HDEV hdev)
+{
+    PPANDEV pandev = (PPANDEV)dhpdev;
+
+    DPRINT("PanCompletePDEV(%p %p)\n", dhpdev, hdev);
+
+    pandev->hdev = hdev;
+    GETPFN(CompletePDEV)(pandev->dhpdevScreen, hdev);
+}
+
+VOID
+APIENTRY
+PanDisablePDEV(
+    _In_ DHPDEV dhpdev)
+{
+    PPANDEV pandev = (PPANDEV)dhpdev;
+
+    DPRINT("PanDisablePDEV(%p)\n", dhpdev);
+
+    GETPFN(DisablePDEV)(pandev->dhpdevScreen);
+    EngFreeMem(pandev);
+}
+
+VOID
+APIENTRY
+PanDisableSurface(
+    _In_ DHPDEV dhpdev)
+{
+    PPANDEV pandev = (PPANDEV)dhpdev;
+
+    DPRINT("PanDisableSurface(%p)\n", dhpdev);
+
+    /* Note that we must handle a not fully initialized pandev, as this
+     * function is also called from PanEnableSurface in case of error. */
+
+    if (pandev->psoShadow)
+    {
+        EngUnlockSurface(pandev->psoShadow);
+        pandev->psoShadow = NULL;
+    }
+    if (pandev->hsurfShadow)
+    {
+        EngDeleteSurface(pandev->hsurfShadow);
+        pandev->hsurfShadow = NULL;
+    }
+    if (pandev->hsurf)
+    {
+        EngDeleteSurface(pandev->hsurf);
+        pandev->hsurf = NULL;
+    }
+    if (pandev->surfObjScreen)
+    {
+        EngUnlockSurface(pandev->surfObjScreen);
+        pandev->surfObjScreen = NULL;
+    }
+    if (pandev->enabledScreen)
+    {
+        GETPFN(DisableSurface)(pandev->dhpdevScreen);
+        pandev->enabledScreen = FALSE;
+    }
+}
+
+HSURF
+APIENTRY
+PanEnableSurface(
+    _In_ DHPDEV dhpdev)
+{
+    PPANDEV pandev = (PPANDEV)dhpdev;
+    HSURF surfScreen;
+
+    /* Move viewport to center of screen */
+    pandev->rclViewport.left = (pandev->szlDesktop.cx - pandev->szlScreen.cx) /
2;
+    pandev->rclViewport.top = (pandev->szlDesktop.cy - pandev->szlScreen.cy) /
2;
+    pandev->rclViewport.right = pandev->rclViewport.left +
pandev->szlScreen.cx;
+    pandev->rclViewport.bottom  = pandev->rclViewport.top +
pandev->szlScreen.cy;
+
+    /* Enable underlying device */
+    surfScreen = GETPFN(EnableSurface)(pandev->dhpdevScreen);
+    if (!surfScreen)
+    {
+        DPRINT1("Failed to enable underlying surface\n");
+        goto failure;
+    }
+    pandev->enabledScreen = TRUE;
+
+    pandev->surfObjScreen = EngLockSurface(surfScreen);
+    if (!pandev->surfObjScreen)
+    {
+        DPRINT1("Failed to lock underlying surface\n");
+        goto failure;
+    }
+
+    /* Create device surface */
+    pandev->hsurf = EngCreateDeviceSurface(NULL, pandev->szlDesktop,
pandev->iBitmapFormat);
+    if (!pandev->hsurf)
+    {
+        DPRINT1("EngCreateDeviceSurface() failed\n");
+        goto failure;
+    }
+
+    if (!EngAssociateSurface(pandev->hsurf, pandev->hdev, HOOK_ALPHABLEND |
+                                                          HOOK_BITBLT |
+                                                          HOOK_COPYBITS |
+                                                          HOOK_GRADIENTFILL |
+                                                          HOOK_STROKEPATH |
+                                                          HOOK_SYNCHRONIZE |
+                                                          HOOK_TEXTOUT))
+    {
+        DPRINT1("EngAssociateSurface() failed\n");
+        goto failure;
+    }
+
+    /* Create shadow surface */
+    pandev->hsurfShadow = (HSURF)EngCreateBitmap(pandev->szlDesktop,
pandev->szlDesktop.cx, pandev->iBitmapFormat, BMF_TOPDOWN, NULL);
+    if (!pandev->hsurfShadow)
+    {
+        DPRINT1("EngCreateBitmap() failed\n");
+        goto failure;
+    }
+
+    pandev->psoShadow = EngLockSurface(pandev->hsurfShadow);
+    if (!pandev->psoShadow)
+    {
+        DPRINT1("EngLockSurface() failed\n");
+        goto failure;
+    }
+
+    return pandev->hsurf;
+
+failure:
+    PanDisableSurface(dhpdev);
+    return NULL;
+}
+
+BOOL
+APIENTRY
+PanBitBlt(
+    _Inout_ SURFOBJ *psoTrg,
+    _In_opt_ SURFOBJ *psoSrc,
+    _In_opt_ SURFOBJ *psoMask,
+    _In_ CLIPOBJ *pco,
+    _In_opt_ XLATEOBJ *pxlo,
+    _In_ PRECTL prclTrg,
+    _In_opt_ PPOINTL pptlSrc,
+    _In_opt_ PPOINTL pptlMask,
+    _In_opt_ BRUSHOBJ *pbo,
+    _In_opt_ PPOINTL pptlBrush,
+    _In_ ROP4 rop4)
+{
+    PPANDEV pandev;
+    BOOL res;
+
+    if (psoTrg->iType == STYPE_DEVICE)
+    {
+        pandev = (PPANDEV)psoTrg->dhpdev;
+        psoTrg = pandev->psoShadow;
+    }
+    if (psoSrc && psoSrc->iType == STYPE_DEVICE)
+    {
+        pandev = (PPANDEV)psoSrc->dhpdev;
+        psoSrc = pandev->psoShadow;
+    }
+
+    res = EngBitBlt(psoTrg, psoSrc, psoMask, pco, pxlo, prclTrg, pptlSrc, pptlMask, pbo,
pptlBrush, rop4);
+
+    /* FIXME: PanSynchronize must be called periodically, as we have the GCAPS2_SYNCTIMER
flag.
+     * That's not the case, so call PanSynchronize() manually */
+    if (res)
+        PanSynchronize(gPan, NULL);
+
+    return res;
+}
+
+BOOL
+APIENTRY
+PanCopyBits(
+    _Inout_ SURFOBJ *psoDest,
+    _In_opt_ SURFOBJ *psoSrc,
+    _In_ CLIPOBJ *pco,
+    _In_opt_ XLATEOBJ *pxlo,
+    _In_ PRECTL prclDest,
+    _In_opt_ PPOINTL pptlSrc)
+{
+    /* Easy. Just call the more general function PanBitBlt */
+    return PanBitBlt(psoDest, psoSrc, NULL, pco, pxlo, prclDest, pptlSrc, NULL, NULL,
NULL, ROP4_SRCCOPY);
+}
+
+BOOL
+APIENTRY
+PanStrokePath(
+     _Inout_ SURFOBJ *pso,
+     _In_ PATHOBJ *ppo,
+     _In_ CLIPOBJ *pco,
+     _In_opt_ XFORMOBJ *pxo,
+     _In_ BRUSHOBJ *pbo,
+     _In_ PPOINTL pptlBrushOrg,
+     _In_ PLINEATTRS plineattrs,
+     _In_ MIX mix)
+{
+    UNIMPLEMENTED;
+    ASSERT(FALSE);
+    return FALSE;
+}
+
+BOOL
+APIENTRY
+PanTextOut(
+    _Inout_ SURFOBJ *pso,
+    _In_ STROBJ *pstro,
+    _In_ FONTOBJ *pfo,
+    _In_ CLIPOBJ *pco,
+    _In_opt_ PRECTL prclExtra,
+    _In_opt_ PRECTL prclOpaque,
+    _In_ BRUSHOBJ *pboFore,
+    _In_ BRUSHOBJ *pboOpaque,
+    _In_ PPOINTL pptlOrg,
+    _In_ MIX mix)
+{
+    UNIMPLEMENTED;
+    ASSERT(FALSE);
+    return FALSE;
+}
+
+VOID
+APIENTRY
+PanMovePointer(
+    _Inout_ SURFOBJ *pso,
+    _In_ LONG x,
+    _In_ LONG y,
+    _In_ PRECTL prcl)
+{
+    PPANDEV pandev = (PPANDEV)pso->dhpdev;
+    PFN_DrvMovePointer pfnMovePointer;
+    BOOL bChanged = FALSE;
+
+    DPRINT("PanMovePointer(%d, %d)\n", x, y);
+
+    /* FIXME: MouseSafetyOnDrawStart/MouseSafetyOnDrawEnd like to call us to hide/show
the cursor,
+     * without real reason (see 5b0f6dcceeae3cf21f2535e2c523c0bf2749ea6b). Ignore those
calls */
+    if (x < 0 || y >= 0) return;
+
+    /* We don't set DrvSetPointerShape, so we must not be called
+     * with x < 0 (hide cursor) or y >= 0 (we have GCAPS_PANNING) */
+    ASSERT(x >= 0 && y < 0);
+
+    /* Call underlying MovePointer function */
+    if (pandev->flUnderlyingGraphicsCaps & GCAPS_PANNING)
+    {
+        pfnMovePointer = GETPFN(MovePointer);
+        if (pfnMovePointer)
+            pfnMovePointer(pandev->surfObjScreen, x, y, prcl);
+    }
+
+    y += pso->sizlBitmap.cy;
+
+    if (x < pandev->rclViewport.left)
+    {
+        pandev->rclViewport.left = x;
+        pandev->rclViewport.right = x + pandev->szlScreen.cx;
+        bChanged = TRUE;
+    }
+    else if (x >= pandev->rclViewport.right)
+    {
+        pandev->rclViewport.right = x + 1;
+        pandev->rclViewport.left = x - pandev->szlScreen.cx;
+        bChanged = TRUE;
+    }
+    if (y < pandev->rclViewport.top)
+    {
+        pandev->rclViewport.top = y;
+        pandev->rclViewport.bottom = y + pandev->szlScreen.cy;
+        bChanged = TRUE;
+    }
+    else if (y >= pandev->rclViewport.bottom)
+    {
+        pandev->rclViewport.bottom = y + 1;
+        pandev->rclViewport.top = y - pandev->szlScreen.cy;
+        bChanged = TRUE;
+    }
+
+    if (bChanged)
+        PanSynchronize(pso->dhpdev, NULL);
+}
+
+BOOL
+APIENTRY
+PanAlphaBlend(
+    _Inout_ SURFOBJ *psoDest,
+    _In_ SURFOBJ *psoSrc,
+    _In_ CLIPOBJ *pco,
+    _In_opt_ XLATEOBJ *pxlo,
+    _In_ PRECTL prclDest,
+    _In_ PRECTL prclSrc,
+    _In_ BLENDOBJ *pBlendObj)
+{
+    PPANDEV pandev = (PPANDEV)psoDest->dhpdev;
+    BOOL res;
+
+    res = EngAlphaBlend(pandev->psoShadow, psoSrc, pco, pxlo, prclDest, prclSrc,
pBlendObj);
+
+    /* FIXME: PanSynchronize must be called periodically, as we have the GCAPS2_SYNCTIMER
flag.
+     * That's not the case, so call PanSynchronize() manually */
+    if (res)
+        PanSynchronize(gPan, NULL);
+
+    return res;
+}
+
+BOOL
+APIENTRY
+PanGradientFill(
+    _Inout_ SURFOBJ *pso,
+    _In_ CLIPOBJ *pco,
+    _In_opt_ XLATEOBJ *pxlo,
+    _In_ PTRIVERTEX pVertex,
+    _In_ ULONG nVertex,
+    _In_ PVOID pMesh,
+    _In_ ULONG nMesh,
+    _In_ PRECTL prclExtents,
+    _In_ PPOINTL pptlDitherOrg,
+    _In_ ULONG ulMode)
+{
+    PPANDEV pandev = (PPANDEV)pso->dhpdev;
+    BOOL res;
+
+    res = EngGradientFill(pandev->psoShadow, pco, pxlo, pVertex, nVertex, pMesh,
nMesh, prclExtents, pptlDitherOrg, ulMode);
+
+    /* FIXME: PanSynchronize must be called periodically, as we have the GCAPS2_SYNCTIMER
flag.
+     * That's not the case, so call PanSynchronize() manually */
+    if (res)
+        PanSynchronize(gPan, NULL);
+
+    return res;
+}
+
+DRVFN gPanDispDrvFn[] =
+{
+    /* required */
+    { INDEX_DrvEnablePDEV,     (PFN) PanEnablePDEV     },
+    { INDEX_DrvCompletePDEV,   (PFN) PanCompletePDEV   },
+    { INDEX_DrvDisablePDEV,    (PFN) PanDisablePDEV    },
+    { INDEX_DrvEnableSurface,  (PFN) PanEnableSurface  },
+    { INDEX_DrvDisableSurface, (PFN) PanDisableSurface },
+
+    /* required for device-managed surfaces */
+    { INDEX_DrvCopyBits,       (PFN) PanCopyBits       },
+    { INDEX_DrvStrokePath,     (PFN) PanStrokePath     },
+    { INDEX_DrvTextOut,        (PFN) PanTextOut        },
+
+    /* optional, but required for panning functionality */
+    { INDEX_DrvSynchronize,    (PFN) PanSynchronize    },
+    { INDEX_DrvMovePointer,    (PFN) PanMovePointer    },
+
+    /* optional */
+    { INDEX_DrvBitBlt,         (PFN) PanBitBlt         },
+    { INDEX_DrvAlphaBlend,     (PFN) PanAlphaBlend     },
+    { INDEX_DrvGradientFill,   (PFN) PanGradientFill   },
+};
+
+ULONG gPanDispDrvCount = RTL_NUMBER_OF(gPanDispDrvFn);
diff --git a/win32ss/gdi/eng/pdevobj.c b/win32ss/gdi/eng/pdevobj.c
index c16fd43bf4b..293dae4b967 100644
--- a/win32ss/gdi/eng/pdevobj.c
+++ b/win32ss/gdi/eng/pdevobj.c
@@ -21,6 +21,9 @@ MultiEnableDriver(
     _In_ ULONG cj,
     _Inout_bytecount_(cj) PDRVENABLEDATA pded);
 
+extern DRVFN gPanDispDrvFn[];
+extern ULONG gPanDispDrvCount;
+
 CODE_SEG("INIT")
 NTSTATUS
 NTAPI
@@ -503,7 +506,24 @@ PDEVOBJ_Create(
     ppdev->dwAccelerationLevel = dwAccelerationLevel;
 
     /* Copy the function table */
-    ppdev->pfn = ppdev->pldev->pfn;
+    if (pdm->dmFields & (DM_PANNINGWIDTH | DM_PANNINGHEIGHT))
+    {
+        ULONG i;
+
+        /* Initialize missing fields */
+        if (!(pdm->dmFields & DM_PANNINGWIDTH))
+            pdm->dmPanningWidth = pdm->dmPelsWidth;
+        if (!(pdm->dmFields & DM_PANNINGHEIGHT))
+            pdm->dmPanningHeight = pdm->dmPelsHeight;
+
+        /* Replace vtable by panning vtable */
+        for (i = 0; i < gPanDispDrvCount; i++)
+            ppdev->apfn[gPanDispDrvFn[i].iFunc] = gPanDispDrvFn[i].pfn;
+    }
+    else
+    {
+        ppdev->pfn = ppdev->pldev->pfn;
+    }
 
     /* Call the driver to enable the PDEV */
     if (!PDEVOBJ_bEnablePDEV(ppdev, pdm, NULL))