Changeset 3394 in vbox for trunk/src/VBox/Additions/WINNT

Timestamp:

Jul 3, 2007 4:24:33 PM (18 years ago)

Author:

vboxsync

Message:

ddraw updates

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Display

Files:

• dd.c (modified) (8 diffs)
• dd.h (modified) (1 diff)
• driver.h (modified) (2 diffs)
• enable.c (modified) (3 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Display/dd.c

@@ -19 +19 @@
 #include "driver.h"
 #include "dd.h"
+#undef CO_E_NOTINITIALIZED
+#include <winerror.h>
+
 
 #if 0
 static DWORD APIENTRY DdCreateSurface(PDD_CREATESURFACEDATA  lpCreateSurface);
 #endif
+
 
 /**
@@ -77 +81 @@
         pHalInfo->vmiData.dwDisplayHeight           = pDev->cyScreen;
         pHalInfo->vmiData.lDisplayPitch             = pDev->lDeltaScreen;
+
         pHalInfo->vmiData.ddpfDisplay.dwSize        = sizeof(DDPIXELFORMAT);
         pHalInfo->vmiData.ddpfDisplay.dwFlags       = DDPF_RGB;
@@ -107 +112 @@
 
     pHalInfo->ddCaps.dwCaps         = 0;
-    pHalInfo->ddCaps.dwCaps2        = DDCAPS2_CERTIFIED;
+    pHalInfo->ddCaps.dwCaps2        = 0;
+
+    /* Declare we can handle textures wider than the primary */
+    pHalInfo->ddCaps.dwCaps2 |= DDCAPS2_WIDESURFACES;
 
     pHalInfo->ddCaps.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
 
-#if 0
     /* DX5 and up */
     pHalInfo->GetDriverInfo = DdGetDriverInfo;
     pHalInfo->dwFlags |= DDHALINFO_GETDRIVERINFOSET;
-#endif
-
+
+#if 0
     /* No 3D capabilities */
-#if 0
     if (pHalInfo->lpD3DGlobalDriverData)
     {
@@ -125 +131 @@
     }
 #endif
-    
     return TRUE;
 }
@@ -161 +166 @@
     /* Fill in the HAL Callback pointers */
     pCallBacks->dwSize                = sizeof(DD_CALLBACKS);
-    pCallBacks->dwFlags               = 0;
-
-    /*
-    pCallBacks->dwFlags               = DDHAL_CB32_CREATESURFACE;
+    pCallBacks->dwFlags               = DDHAL_CB32_CREATESURFACE | DDHAL_CB32_CANCREATESURFACE;
     pCallBacks->CreateSurface         = DdCreateSurface;
     pCallBacks->CanCreateSurface      = DdCanCreateSurface;
+
+    /*
     pCallBacks->WaitForVerticalBlank  = DdWaitForVerticalBlank;
     pCallBacks->GetScanLine           = DdGetScanLine;
     pCallBacks->MapMemory             = DdMapMemory;
-    DDHAL_CB32_CANCREATESURFACE | DDHAL_CB32_WAITFORVERTICALBLANK | DDHAL_CB32_MAPMEMORY | DDHAL_CB32_GETSCANLINE 
+    DDHAL_CB32_WAITFORVERTICALBLANK | DDHAL_CB32_MAPMEMORY | DDHAL_CB32_GETSCANLINE 
     */
     /* Note: pCallBacks->SetMode & pCallBacks->DestroyDriver are unused in Windows 2000 and up */
@@ -176 +180 @@
     /* Fill in the Surface Callback pointers */
     pSurfaceCallBacks->dwSize           = sizeof(DD_SURFACECALLBACKS);
-    pSurfaceCallBacks->dwFlags          = 0;
+    pSurfaceCallBacks->dwFlags          = DDHAL_SURFCB32_DESTROYSURFACE | DDHAL_SURFCB32_LOCK; // DDHAL_SURFCB32_UNLOCK;
+    pSurfaceCallBacks->DestroySurface   = DdDestroySurface;
+//    pSurfaceCallBacks->Lock             = DdLock;
+    pSurfaceCallBacks->Unlock           = DdUnlock;
 
     /*
-    pSurfaceCallBacks->dwFlags          = DDHAL_SURFCB32_DESTROYSURFACE | DDHAL_SURFCB32_LOCK;
-    pSurfaceCallBacks->DestroySurface   = DdDestroySurface;
-    pSurfaceCallBacks->Lock             = DdLock;
     pSurfaceCallBacks->Flip             = DdFlip;
     pSurfaceCallBacks->GetBltStatus     = DdGetBltStatus;
@@ -215 +219 @@
 }
 
-
-#if 0
+/**
+ * DdGetDriverInfo
+ * 
+ * The DdGetDriverInfo function queries the driver for additional DirectDraw and Direct3D functionality that the driver supports.
+ * 
+ * Parameters
+ * lpGetDriverInfo
+ *     Points to a DD_GETDRIVERINFODATA structure that contains the information required to perform the query.
+ * 
+ * Return Value
+ * 
+ * DdGetDriverInfo must return DDHAL_DRIVER_HANDLED. 
+ *
+ */
+DWORD CALLBACK DdGetDriverInfo(DD_GETDRIVERINFODATA *lpData)
+{
+    PPDEV pDev = (PPDEV)lpData->dhpdev;
+    DWORD dwSize;
+
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, lpData->dhpdev));
+
+    /* Default to 'not supported' */
+    lpData->ddRVal = DDERR_CURRENTLYNOTAVAIL;
+
+    /* Fill in supported stuff */
+    if (IsEqualIID(&lpData->guidInfo, &GUID_D3DCallbacks3))
+    {
+        DISPDBG((0, " -> GUID_D3DCallbacks3\n"));
+    }
+    else 
+    if (IsEqualIID(&lpData->guidInfo, &GUID_D3DExtendedCaps))
+    {
+        DISPDBG((0, " -> GUID_D3DExtendedCaps\n"));
+    }
+    else 
+    if (IsEqualIID(&lpData->guidInfo, &GUID_ZPixelFormats))
+    {
+        DISPDBG((0, " -> GUID_ZPixelFormats\n"));
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_D3DParseUnknownCommandCallback))
+    {
+        DISPDBG((0, " -> GUID_D3DParseUnknownCommandCallback\n"));
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_Miscellaneous2Callbacks))
+    {
+        DISPDBG((0, " -> GUID_Miscellaneous2Callbacks\n"));
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_UpdateNonLocalHeap))
+    {
+        DISPDBG((0, " -> GUID_UpdateNonLocalHeap\n"));
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_GetHeapAlignment))
+    {
+        DISPDBG((0, " -> GUID_GetHeapAlignment\n"));
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_NTPrivateDriverCaps))
+    {
+        DD_NTPRIVATEDRIVERCAPS DDPrivateDriverCaps;
+
+        DISPDBG((0, " -> GUID_NTPrivateDriverCaps\n"));
+
+        memset(&DDPrivateDriverCaps, 0, sizeof(DDPrivateDriverCaps));
+        DDPrivateDriverCaps.dwSize=sizeof(DDPrivateDriverCaps);
+
+        DDPrivateDriverCaps.dwPrivateCaps = 0; /* DDHAL_PRIVATECAP_NOTIFYPRIMARYCREATION -> call CreateSurface for the primary surface */
+
+        lpData->dwActualSize =sizeof(DDPrivateDriverCaps);
+
+        dwSize = min(sizeof(DDPrivateDriverCaps),lpData->dwExpectedSize);
+        memcpy(lpData->lpvData, &DDPrivateDriverCaps, dwSize);
+        lpData->ddRVal = DD_OK;
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_DDMoreSurfaceCaps))
+    {
+        DD_MORESURFACECAPS DDMoreSurfaceCaps;
+        DDSCAPSEX   ddsCapsEx, ddsCapsExAlt;
+
+        DISPDBG((0, " -> GUID_DDMoreSurfaceCaps\n"));
+
+        // fill in everything until expectedsize...
+        memset(&DDMoreSurfaceCaps, 0, sizeof(DDMoreSurfaceCaps));
+
+        // Caps for heaps 2..n
+        memset(&ddsCapsEx, 0, sizeof(ddsCapsEx));
+        memset(&ddsCapsExAlt, 0, sizeof(ddsCapsEx));
+
+        DDMoreSurfaceCaps.dwSize=lpData->dwExpectedSize;
+
+        lpData->dwActualSize = lpData->dwExpectedSize;
+
+        dwSize = min(sizeof(DDMoreSurfaceCaps),lpData->dwExpectedSize);
+        memcpy(lpData->lpvData, &DDMoreSurfaceCaps, dwSize);
+
+        // now fill in other heaps...
+        while (dwSize < lpData->dwExpectedSize)
+        {
+            memcpy( (PBYTE)lpData->lpvData+dwSize,
+                    &ddsCapsEx,
+                    sizeof(DDSCAPSEX));
+            dwSize += sizeof(DDSCAPSEX);
+            memcpy( (PBYTE)lpData->lpvData+dwSize,
+                    &ddsCapsExAlt,
+                    sizeof(DDSCAPSEX));
+            dwSize += sizeof(DDSCAPSEX);
+        }
+
+        lpData->ddRVal = DD_OK;
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_DDStereoMode))
+    {
+        DISPDBG((0, " -> GUID_DDStereoMode\n"));
+    }
+    else 
+    if (IsEqualIID(&(lpData->guidInfo), &GUID_NonLocalVidMemCaps))
+    {
+        DISPDBG((0, " -> GUID_NonLocalVidMemCaps\n"));
+    } 
+    else 
+    if (IsEqualIID(&lpData->guidInfo, &GUID_NTCallbacks))
+    {
+        DD_NTCALLBACKS NtCallbacks;
+
+        DISPDBG((0, " -> GUID_NTCallbacks\n"));
+        memset(&NtCallbacks, 0, sizeof(NtCallbacks));
+
+        dwSize = min(lpData->dwExpectedSize, sizeof(DD_NTCALLBACKS));
+
+        NtCallbacks.dwSize           = dwSize;
+        NtCallbacks.dwFlags          =   DDHAL_NTCB32_FREEDRIVERMEMORY
+                                       | DDHAL_NTCB32_SETEXCLUSIVEMODE
+                                       | DDHAL_NTCB32_FLIPTOGDISURFACE
+                                       ;
+        NtCallbacks.FreeDriverMemory = DdFreeDriverMemory;
+        NtCallbacks.SetExclusiveMode = DdSetExclusiveMode;
+        NtCallbacks.FlipToGDISurface = DdFlipToGDISurface;
+
+        memcpy(lpData->lpvData, &NtCallbacks, dwSize);
+
+        lpData->ddRVal = DD_OK;
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_KernelCaps))
+    {
+        DISPDBG((0, " -> GUID_KernelCaps\n"));
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_KernelCallbacks))
+    {
+        DISPDBG((0, " -> GUID_KernelCallbacks\n"));
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_MotionCompCallbacks))
+    {
+        DISPDBG((0, " -> GUID_MotionCompCallbacks\n"));
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_VideoPortCallbacks))
+    {
+        DISPDBG((0, " -> GUID_VideoPortCallbacks\n"));
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_ColorControlCallbacks))
+    {
+        DISPDBG((0, " -> GUID_ColorControlCallbacks\n"));
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_VideoPortCaps))
+    {
+        DISPDBG((0, " -> GUID_VideoPortCaps\n"));
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_D3DCallbacks2))
+    {
+        DISPDBG((0, " -> GUID_D3DCallbacks2\n"));
+    }
+    else
+    if (IsEqualIID(&lpData->guidInfo, &GUID_D3DCallbacks3))
+    {
+        DISPDBG((0, " -> GUID_D3DCallbacks3\n"));
+    }
+
+    /* Always return this */
+    return DDHAL_DRIVER_HANDLED;
+}
+
 /**
  * DdCreateSurface
@@ -232 +426 @@
  * 
  */
-static DWORD APIENTRY DdCreateSurface(PDD_CREATESURFACEDATA  lpCreateSurface)
-{
-    lpCreateSurface->lpDD->fpVidMem = DDHAL_PLEASEALLOC_USERMEM;
+DWORD APIENTRY DdCreateSurface(PDD_CREATESURFACEDATA  lpCreateSurface)
+{
+    PPDEV pDev = (PPDEV)lpCreateSurface->lpDD->dhpdev;
+    DD_SURFACE_LOCAL*   lpSurfaceLocal;
+    DD_SURFACE_GLOBAL*  lpSurfaceGlobal;
+    LPDDSURFACEDESC     lpSurfaceDesc;
+    LONG                lPitch, lBpp;
+
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    lpSurfaceLocal                  = lpCreateSurface->lplpSList[0];
+    lpSurfaceGlobal                 = lpSurfaceLocal->lpGbl;    
+    lpSurfaceDesc                   = lpCreateSurface->lpDDSurfaceDesc;
+
+    lpSurfaceGlobal->dwReserved1    = 0;
+
+    if (lpSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED4)
+    {
+        lBpp = 4;
+        lPitch = lpSurfaceGlobal->wWidth/2;
+        lPitch = (lPitch + 31) & ~31;
+    }
+    else 
+    if (lpSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
+    {
+        lBpp = 8;
+        lPitch = lpSurfaceGlobal->wWidth;
+        lPitch = (lPitch + 31) & ~31;
+    }
+    else
+    {
+        lBpp   = lpSurfaceDesc->ddpfPixelFormat.dwRGBBitCount;
+        lPitch = lpSurfaceGlobal->wWidth*(lBpp/8);
+    }
+    DISPDBG((0, "New surface (%d,%d)\n", lpSurfaceGlobal->wWidth, lpSurfaceGlobal->wHeight));
+    DISPDBG((0, "BPP %d lPitch=%d\n", lBpp, lPitch));
+
+    lpSurfaceGlobal->dwBlockSizeX   = lPitch * lpSurfaceGlobal->wHeight;
+    lpSurfaceGlobal->dwBlockSizeY   = 1;
+    lpSurfaceGlobal->lPitch         = lPitch;
+
+    //
+    // Modify surface descriptions as appropriate and let Direct
+    // Draw perform the allocation if the surface was not the primary
+    //
+    if (lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
+    {
+        DISPDBG((0, "-> primary surface\n"));
+        lpSurfaceGlobal->fpVidMem       = 0;
+    }
+    else
+    {
+        DISPDBG((0, "-> secondary surface\n"));
+        lpSurfaceGlobal->dwUserMemSize  = lPitch * (DWORD)(lpSurfaceGlobal->wHeight);
+        lpSurfaceGlobal->fpVidMem       = DDHAL_PLEASEALLOC_BLOCKSIZE;
+    }
+    
+    lpSurfaceDesc->lPitch   = lpSurfaceGlobal->lPitch;
+    lpSurfaceDesc->dwFlags |= DDSD_PITCH;
+
 
     return DDHAL_DRIVER_NOTHANDLED;
 }
-#endif
+
+/**
+ * DdCanCreateSurface
+ * 
+ * The DdCanCreateSurface callback function indicates whether the driver can create a surface of the specified surface description.
+ * 
+ * 
+ * Parameters
+ * lpCanCreateSurface
+ *     Points to the DD_CANCREATESURFACEDATA structure containing the information required for the driver to determine whether a surface can be created.
+ * 
+ * Return Value
+ * 
+ * DdCanCreateSurface returns one of the following callback codes:
+ * 
+ * DDHAL_DRIVER_HANDLED
+ * DDHAL_DRIVER_NOTHANDLED
+ *
+ */
+DWORD APIENTRY DdCanCreateSurface(PDD_CANCREATESURFACEDATA lpCanCreateSurface)
+{
+    PPDEV pDev = (PPDEV)lpCanCreateSurface->lpDD->dhpdev;
+
+    PDD_SURFACEDESC lpDDS = lpCanCreateSurface->lpDDSurfaceDesc;
+
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    if (lpDDS->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
+    {
+        DISPDBG((0, "No Z-Bufer support\n"));
+        lpCanCreateSurface->ddRVal = DDERR_INVALIDPIXELFORMAT;
+        return DDHAL_DRIVER_HANDLED;
+    }
+    if (lpDDS->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
+    {
+        DISPDBG((0, "No texture support\n"));
+        lpCanCreateSurface->ddRVal = DDERR_INVALIDPIXELFORMAT;
+        return DDHAL_DRIVER_HANDLED;
+    }
+
+    if (lpCanCreateSurface->bIsDifferentPixelFormat && (lpDDS->ddpfPixelFormat.dwFlags & DDPF_FOURCC))
+    {
+        DISPDBG((0, "FOURCC not supported\n"));
+        lpCanCreateSurface->ddRVal = DDERR_INVALIDPIXELFORMAT;
+        return DDHAL_DRIVER_HANDLED;
+    }
+
+    lpCanCreateSurface->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+/**
+ * DdLock
+ * 
+ * The DdLock callback function locks a specified area of surface memory and provides a valid pointer to a block of memory associated with a surface.
+ * 
+ * Parameters
+ * lpLock
+ *     Points to a DD_LOCKDATA structure that contains the information required to perform the lockdown.
+ * 
+ * Return Value
+ * 
+ * DdLock returns one of the following callback codes:
+ * 
+ * DDHAL_DRIVER_HANDLED
+ * DDHAL_DRIVER_NOTHANDLED
+ *
+ */
+DWORD APIENTRY DdLock(PDD_LOCKDATA lpLock)
+{
+    PPDEV pDev = (PPDEV)lpLock->lpDD->dhpdev;
+
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    // Because we correctly set 'fpVidMem' to be the offset into our frame
+    // buffer when we created the surface, DirectDraw will automatically take
+    // care of adding in the user-mode frame buffer address if we return
+    // DDHAL_DRIVER_NOTHANDLED:
+    return DDHAL_DRIVER_NOTHANDLED;
+}
+
+/**
+ * DdUnlock
+ * 
+ * The DdUnLock callback function releases the lock held on the specified surface.
+ * 
+ * Parameters
+ * lpUnlock
+ *     Points to a DD_UNLOCKDATA structure that contains the information required to perform the lock release. * 
+ * 
+ * Return Value
+ * 
+ * DdLock returns one of the following callback codes:
+ * 
+ * DDHAL_DRIVER_HANDLED
+ * DDHAL_DRIVER_NOTHANDLED
+ *
+ */
+DWORD APIENTRY DdUnlock(PDD_UNLOCKDATA lpUnlock)
+{
+    PPDEV pDev = (PPDEV)lpUnlock->lpDD->dhpdev;
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    return DDHAL_DRIVER_NOTHANDLED;
+}
+
+/**
+ * DdDestroySurface
+ * 
+ * The DdDestroySurface callback function destroys a DirectDraw surface.
+ * 
+ * Parameters
+ * lpDestroySurface
+ *     Points to a DD_DESTROYSURFACEDATA structure that contains the information needed to destroy a surface.
+ * 
+ * Return Value
+ * 
+ * DdDestroySurface returns one of the following callback codes:
+ * 
+ * DDHAL_DRIVER_HANDLED
+ * DDHAL_DRIVER_NOTHANDLED
+ *
+ */
+DWORD APIENTRY DdDestroySurface(PDD_DESTROYSURFACEDATA lpDestroySurface)
+{
+    PPDEV pDev = (PPDEV)lpDestroySurface->lpDD->dhpdev;
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    lpDestroySurface->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// DdSetExclusiveMode
+//
+// This function is called by DirectDraw when we switch from the GDI surface,
+// to DirectDraw exclusive mode, e.g. to run a game in fullcreen mode.
+// You only need to implement this function when you are using the
+// 'HeapVidMemAllocAligned' function and allocate memory for Device Bitmaps
+// and DirectDraw surfaces from the same heap.
+//
+// We use this call to disable GDI DeviceBitMaps when we are running in
+// DirectDraw exclusive mode. Otherwise a DD app gets confused if both GDI and
+// DirectDraw allocate memory from the same heap.
+//
+// See also DdFlipToGDISurface.
+//
+//-----------------------------------------------------------------------------
+
+
+DWORD APIENTRY DdSetExclusiveMode(PDD_SETEXCLUSIVEMODEDATA lpSetExclusiveMode)
+{
+    PPDEV pDev = (PPDEV)lpSetExclusiveMode->lpDD->dhpdev;
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    // remember setting of exclusive mode in ppdev,
+    // so GDI can stop to promote DeviceBitmaps into
+    // video memory
+
+    pDev->bDdExclusiveMode = lpSetExclusiveMode->dwEnterExcl;
+
+    lpSetExclusiveMode->ddRVal = DD_OK;
+
+    return DDHAL_DRIVER_HANDLED;
+}
+
+//-----------------------------------------------------------------------------
+//
+// DWORD DdFlipToGDISurface
+//
+// This function is called by DirectDraw when it flips to the surface on which
+// GDI can write to.
+//
+//-----------------------------------------------------------------------------
+
+DWORD APIENTRY DdFlipToGDISurface(PDD_FLIPTOGDISURFACEDATA lpFlipToGDISurface)
+{
+    PPDEV pDev = (PPDEV)lpFlipToGDISurface->lpDD->dhpdev;
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    pDev->dwNewDDSurfaceOffset = 0xffffffff;
+
+    lpFlipToGDISurface->ddRVal = DD_OK;
+
+    //
+    //  we return NOTHANDLED, then the ddraw runtime takes
+    //  care that we flip back to the primary...
+    //
+    return DDHAL_DRIVER_NOTHANDLED;
+}
+//-----------------------------------------------------------------------------
+//
+// DWORD DdFreeDriverMemory
+//
+// This function called by DirectDraw when it's running low on memory in
+// our heap.  You only need to implement this function if you use the
+// DirectDraw 'HeapVidMemAllocAligned' function in your driver, and you
+// can boot those allocations out of memory to make room for DirectDraw.
+//
+// We implement this function in the P2 driver because we have DirectDraw
+// entirely manage our off-screen heap, and we use HeapVidMemAllocAligned
+// to put GDI device-bitmaps in off-screen memory.  DirectDraw applications
+// have a higher priority for getting stuff into video memory, though, and
+// so this function is used to boot those GDI surfaces out of memory in
+// order to make room for DirectDraw.
+//
+//-----------------------------------------------------------------------------
+
+DWORD APIENTRY DdFreeDriverMemory(PDD_FREEDRIVERMEMORYDATA lpFreeDriverMemory)
+{
+    PPDEV pDev = (PPDEV)lpFreeDriverMemory->lpDD->dhpdev;
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    lpFreeDriverMemory->ddRVal = DDERR_OUTOFMEMORY;
+    return (DDHAL_DRIVER_HANDLED);
+}
+

trunk/src/VBox/Additions/WINNT/Graphics/Display/dd.h

@@ -28 +28 @@
 BOOL APIENTRY DrvEnableDirectDraw(DHPDEV dhpdev, DD_CALLBACKS *pCallBacks, DD_SURFACECALLBACKS *pSurfaceCallBacks, DD_PALETTECALLBACKS *pPaletteCallBacks);
 VOID APIENTRY DrvDisableDirectDraw(DHPDEV dhpdev);
-
+DWORD CALLBACK DdGetDriverInfo(DD_GETDRIVERINFODATA *lpData);
+DWORD APIENTRY DdCreateSurface(PDD_CREATESURFACEDATA  lpCreateSurface);
+DWORD APIENTRY DdCanCreateSurface(PDD_CANCREATESURFACEDATA lpCanCreateSurface);
+DWORD APIENTRY DdDestroySurface(PDD_DESTROYSURFACEDATA lpDestroySurface);
+DWORD APIENTRY DdLock(PDD_LOCKDATA lpLock);
+DWORD APIENTRY DdUnlock(PDD_UNLOCKDATA lpUnlock);
+DWORD APIENTRY DdFreeDriverMemory(PDD_FREEDRIVERMEMORYDATA lpFreeDriverMemory);
+DWORD APIENTRY DdSetExclusiveMode(PDD_SETEXCLUSIVEMODEDATA lpSetExclusiveMode);
+DWORD APIENTRY DdFlipToGDISurface(PDD_FLIPTOGDISURFACEDATA lpFlipToGDISurface);
+HBITMAP DrvDeriveSurface(DD_DIRECTDRAW_GLOBAL*  pDirectDraw, DD_SURFACE_LOCAL* pSurface);
 
 #endif /* __VBOX_DD_H__*/

trunk/src/VBox/Additions/WINNT/Graphics/Display/driver.h

@@ -20 +20 @@
 #include "ntddvdeo.h"
 #include "debug.h"
-#include "dd.h"
 
 #include "../Miniport/vboxioctl.h"
@@ -99 +98 @@
     VBOXDISPLAYINFO *pInfo;
     ULONG iDevice;
+#ifdef VBOX_WITH_DDRAW
+    BOOL             bDdExclusiveMode;
+    DWORD            dwNewDDSurfaceOffset;
+#endif
 };
 

trunk/src/VBox/Additions/WINNT/Graphics/Display/enable.c

@@ -14 +14 @@
 
 #include "driver.h"
+#include "dd.h"
 
 // The driver function table with all function index/address pairs
@@ -147 +148 @@
     {   INDEX_DrvEnableDirectDraw,      (PFN) DrvEnableDirectDraw   },  // 60 0x3c
     {   INDEX_DrvDisableDirectDraw,     (PFN) DrvDisableDirectDraw  },  // 61 0x3d
+    {   INDEX_DrvDeriveSurface,         (PFN) DrvDeriveSurface      },  // 85
 #endif
     {   INDEX_DrvNotify,                (PFN) DrvNotify             },  // 87 0x57
@@ -852 +854 @@
     }
 }
+
+#ifdef VBOX_WITH_DDRAW
+//--------------------------Public Routine-------------------------------------
+//
+// HBITMAP DrvDeriveSurface
+//
+// This function derives and creates a GDI surface from the specified
+// DirectDraw surface.
+//
+// Parameters
+//  pDirectDraw-----Points to a DD_DIRECTDRAW_GLOBAL structure that describes
+//                  the DirectDraw object. 
+//  pSurface--------Points to a DD_SURFACE_LOCAL structure that describes the
+//                  DirectDraw surface around which to wrap a GDI surface.
+//
+// Return Value
+//  DrvDeriveSurface returns a handle to the created GDI surface upon success.
+//  It returns NULL if the call fails or if the driver cannot accelerate GDI
+//  drawing to the specified DirectDraw surface.
+//
+// Comments
+//  DrvDeriveSurface allows the driver to create a GDI surface around a
+//  DirectDraw video memory or AGP surface object in order to allow accelerated
+//  GDI drawing to the surface. If the driver does not hook this call, all GDI
+//  drawing to DirectDraw surfaces is done in software using the DIB engine.
+//
+//  GDI calls DrvDeriveSurface with RGB surfaces only.
+//
+//  The driver should call DrvCreateDeviceBitmap to create a GDI surface of the
+//  same size and format as that of the DirectDraw surface. Space for the
+//  actual pixels need not be allocated since it already exists.
+//
+//-----------------------------------------------------------------------------
+HBITMAP DrvDeriveSurface(DD_DIRECTDRAW_GLOBAL*  pDirectDraw, DD_SURFACE_LOCAL* pSurface)
+{
+    PPDEV               pDev = (PPDEV)pDirectDraw->dhpdev;
+    HBITMAP             hbmDevice;
+    DD_SURFACE_GLOBAL*  pSurfaceGlobal;
+    SIZEL               sizl;
+
+    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+    pSurfaceGlobal = pSurface->lpGbl;
+
+    //
+    // GDI should never call us for a non-RGB surface, but let's assert just
+    // to make sure they're doing their job properly.
+    //
+    AssertMsg(!(pSurfaceGlobal->ddpfSurface.dwFlags & DDPF_FOURCC), ("GDI called us with a non-RGB surface!"));
+
+
+    // The GDI driver does not accelerate surfaces in AGP memory,
+    // thus we fail the call
+
+    if (pSurface->ddsCaps.dwCaps & DDSCAPS_NONLOCALVIDMEM)
+    {
+        DISPDBG((0, "DrvDeriveSurface return NULL, surface in AGP memory"));
+        return 0;
+    }
+
+    // The GDI driver does not accelerate managed surface,
+    // thus we fail the call
+    if (pSurface->lpSurfMore->ddsCapsEx.dwCaps2 & DDSCAPS2_TEXTUREMANAGE)
+    {
+        DISPDBG((0, "DrvDeriveSurface return NULL, surface is managed"));
+        return 0;
+    }
+
+    //
+    // The rest of our driver expects GDI calls to come in with the same
+    // format as the primary surface.  So we'd better not wrap a device
+    // bitmap around an RGB format that the rest of our driver doesn't
+    // understand.  Also, we must check to see that it is not a surface
+    // whose pitch does not match the primary surface.
+    //
+    // NOTE: Most surfaces created by this driver are allocated as 2D surfaces
+    // whose lPitch's are equal to the screen pitch.  However, overlay surfaces
+    // are allocated such that there lPitch's are usually different then the
+    // screen pitch.  The hardware can not accelerate drawing operations to
+    // these surfaces and thus we fail to derive these surfaces.
+    //
+    if ( (pSurfaceGlobal->ddpfSurface.dwRGBBitCount == pDev->ulBitCount) )
+    {
+        SIZEL sizel;
+        DWORD ulBitmapType, flHooks;        
+
+        sizl.cx = pSurfaceGlobal->wWidth;
+        sizl.cy = pSurfaceGlobal->wHeight;
+
+        if (pDev->ulBitCount == 8)
+        {
+            if (!bInit256ColorPalette(pDev)) {
+                DISPDBG((0, "DISP DrvEnableSurface failed to init the 8bpp palette\n"));
+                return(FALSE);
+            }
+            ulBitmapType = BMF_8BPP;
+            flHooks = HOOKS_BMF8BPP;
+        }
+        else if (pDev->ulBitCount == 16)
+        {
+            ulBitmapType = BMF_16BPP;
+            flHooks = HOOKS_BMF16BPP;
+        }
+        else if (pDev->ulBitCount == 24)
+        {
+            ulBitmapType = BMF_24BPP;
+            flHooks = HOOKS_BMF24BPP;
+        }
+        else
+        {
+            ulBitmapType = BMF_32BPP;
+            flHooks = HOOKS_BMF32BPP;
+        }
+
+        hbmDevice = EngCreateBitmap(sizl,
+                                    pDev->lDeltaScreen,
+                                    ulBitmapType,
+                                    (pDev->lDeltaScreen > 0) ? BMF_TOPDOWN : 0,
+                                    (PVOID) (pDev->pjScreen));
+        if (hbmDevice)
+        {
+            VOID* pvScan0 = pDev->pjScreen + pSurfaceGlobal->fpVidMem;
+
+            //
+            // Note that HOOK_SYNCHRONIZE must always be hooked when we
+            // give GDI a pointer to the bitmap bits. We don't need to
+            // do it here since HOOK_SYNCHRONIZE is always set in our
+            // pdev->flHooks
+            //
+            ULONG   flags = MS_NOTSYSTEMMEMORY;
+
+            if ( EngModifySurface((HSURF)hbmDevice,
+                                  pDev->hdevEng,
+                                  pDev->flHooks,
+                                  flags,
+                                  (DHSURF)hbmDevice,
+                                  pvScan0,
+                                  pSurfaceGlobal->lPitch,
+                                  NULL) )
+            {
+                SURFOBJ*    surfobj = EngLockSurface((HSURF) hbmDevice);
+                AssertMsg(surfobj->iType == STYPE_BITMAP, ("expected STYPE_BITMAP"));
+                surfobj->iType = STYPE_DEVBITMAP;
+                EngUnlockSurface(surfobj);
+
+                DISPDBG((0, "DrvDeriveSurface return succeed"));
+                return(hbmDevice);
+            }
+
+            DISPDBG((0, "DrvDeriveSurface: EngModifySurface failed"));
+            EngDeleteSurface((HSURF)hbmDevice);
+        }
+    }
+
+    DISPDBG((0, "DrvDeriveSurface return NULL"));
+    DISPDBG((0, "pSurfaceGlobal->ddpfSurface.dwRGBBitCount = %d, lPitch =%ld", pSurfaceGlobal->ddpfSurface.dwRGBBitCount,pSurfaceGlobal->lPitch));
+      
+    return(0);
+}
+#endif /* VBOX_WITH_DDRAW */