able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/public/oak/inc/ddrawint.h
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1952 lines
85 KiB
C
Raw Blame History

/*++
Copyright (c) Microsoft Corporation. All Rights Reserved.
Module Name:
ddrawint.h
Abstract:
Private entry points, defines and types for Windows NT DirectDraw
driver interface. Corresponds to Windows' 'ddrawi.h' file.
The structure names for NT are different from that of Win95. Use
dx95type.h to aid in porting DirectX code from Win95 to NT.
--*/
#ifndef __DD_INCLUDED__
#define __DD_INCLUDED__
/*
* These GUIDs are used to identify driver info structures, not interfaces,
* so the prefix GUID_ is used instead of IID_.
*/
DEFINE_GUID( GUID_MiscellaneousCallbacks, 0xefd60cc0, 0x49e7, 0x11d0, 0x88, 0x9d, 0x0, 0xaa, 0x0, 0xbb, 0xb7, 0x6a);
DEFINE_GUID( GUID_Miscellaneous2Callbacks, 0x406B2F00, 0x3E5A, 0x11D1, 0xB6, 0x40, 0x00, 0xAA, 0x00, 0xA1, 0xF9, 0x6A);
DEFINE_GUID( GUID_VideoPortCallbacks, 0xefd60cc1, 0x49e7, 0x11d0, 0x88, 0x9d, 0x0, 0xaa, 0x0, 0xbb, 0xb7, 0x6a);
DEFINE_GUID( GUID_ColorControlCallbacks, 0xefd60cc2, 0x49e7, 0x11d0, 0x88, 0x9d, 0x0, 0xaa, 0x0, 0xbb, 0xb7, 0x6a);
DEFINE_GUID( GUID_MotionCompCallbacks, 0xb1122b40, 0x5dA5, 0x11d1, 0x8f, 0xcF, 0x00, 0xc0, 0x4f, 0xc2, 0x9b, 0x4e);
DEFINE_GUID( GUID_VideoPortCaps, 0xefd60cc3, 0x49e7, 0x11d0, 0x88, 0x9d, 0x0, 0xaa, 0x0, 0xbb, 0xb7, 0x6a);
DEFINE_GUID( GUID_D3DCaps, 0x7bf06991, 0x8794, 0x11d0, 0x91, 0x39, 0x08, 0x00, 0x36, 0xd2, 0xef, 0x02);
DEFINE_GUID( GUID_D3DExtendedCaps, 0x7de41f80, 0x9d93, 0x11d0, 0x89, 0xab, 0x00, 0xa0, 0xc9, 0x05, 0x41, 0x29);
DEFINE_GUID( GUID_D3DCallbacks, 0x7bf06990, 0x8794, 0x11d0, 0x91, 0x39, 0x08, 0x00, 0x36, 0xd2, 0xef, 0x02);
DEFINE_GUID( GUID_D3DCallbacks2, 0xba584e1, 0x70b6, 0x11d0, 0x88, 0x9d, 0x0, 0xaa, 0x0, 0xbb, 0xb7, 0x6a);
DEFINE_GUID( GUID_D3DCallbacks3, 0xddf41230, 0xec0a, 0x11d0, 0xa9, 0xb6, 0x00, 0xaa, 0x00, 0xc0, 0x99, 0x3e);
DEFINE_GUID( GUID_NonLocalVidMemCaps, 0x86c4fa80, 0x8d84, 0x11d0, 0x94, 0xe8, 0x00, 0xc0, 0x4f, 0xc3, 0x41, 0x37);
DEFINE_GUID( GUID_KernelCallbacks, 0x80863800, 0x6B06, 0x11D0, 0x9B, 0x06, 0x0, 0xA0, 0xC9, 0x03, 0xA3, 0xB8);
DEFINE_GUID( GUID_KernelCaps, 0xFFAA7540, 0x7AA8, 0x11D0, 0x9B, 0x06, 0x00, 0xA0, 0xC9, 0x03, 0xA3, 0xB8);
DEFINE_GUID( GUID_ZPixelFormats, 0x93869880, 0x36cf, 0x11d1, 0x9b, 0x1b, 0x0, 0xaa, 0x0, 0xbb, 0xb8, 0xae);
DEFINE_GUID( GUID_DDMoreCaps, 0x880baf30, 0xb030, 0x11d0, 0x8e, 0xa7, 0x00, 0x60, 0x97, 0x97, 0xea, 0x5b);
DEFINE_GUID( GUID_D3DParseUnknownCommandCallback, 0x2e04ffa0, 0x98e4, 0x11d1, 0x8c, 0xe1, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8);
DEFINE_GUID( GUID_NTCallbacks, 0x6fe9ecde, 0xdf89, 0x11d1, 0x9d, 0xb0, 0x00, 0x60, 0x08, 0x27, 0x71, 0xba);
DEFINE_GUID( GUID_DDMoreSurfaceCaps, 0x3b8a0466, 0xf269, 0x11d1, 0x88, 0x0b, 0x0, 0xc0, 0x4f, 0xd9, 0x30, 0xc5);
DEFINE_GUID( GUID_GetHeapAlignment, 0x42e02f16, 0x7b41, 0x11d2, 0x8b, 0xff, 0x0, 0xa0, 0xc9, 0x83, 0xea, 0xf6);
DEFINE_GUID( GUID_UpdateNonLocalHeap, 0x42e02f17, 0x7b41, 0x11d2, 0x8b, 0xff, 0x0, 0xa0, 0xc9, 0x83, 0xea, 0xf6);
DEFINE_GUID( GUID_NTPrivateDriverCaps, 0xfad16a23, 0x7b66, 0x11d2, 0x83, 0xd7, 0x0, 0xc0, 0x4f, 0x7c, 0xe5, 0x8c);
DEFINE_GUID( GUID_DDStereoMode, 0xf828169c, 0xa8e8, 0x11d2, 0xa1, 0xf2, 0x0, 0xa0, 0xc9, 0x83, 0xea, 0xf6);
DEFINE_GUID( GUID_VPE2Callbacks, 0x52882147, 0x2d47, 0x469a, 0xa0, 0xd1, 0x3, 0x45, 0x58, 0x90, 0xf6, 0xc8);
#ifndef GUID_DEFS_ONLY
#ifndef _NO_DDRAWINT_NO_COM
#ifndef _NO_COM
#define _NO_COM
#include "ddraw.h"
#include "dvp.h"
#undef _NO_COM
#else
#include "ddraw.h"
#include "dvp.h"
#endif
#else
#include "ddraw.h"
#include "dvp.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define MAKE_HRESULT(sev,fac,code) \
((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
/*
* offset into video meory
*/
typedef ULONG_PTR FLATPTR;
/*
* maximum number of surfaces that can be autoflipped between
*/
#define MAX_AUTOFLIP_BUFFERS 10
/*
* Indicates the surface is D3D buffer, i.e., a linear chunk of
* memory that holds a Direct3D structure. A driver reports this
* cap to indicate that it can create buffers in video memory and
* Direct3D uses this bit to request buffers. However, it is not
* visible to the API.
*/
#define DDSCAPS_EXECUTEBUFFER DDSCAPS_RESERVED2
#define DDSCAPS_COMMANDBUFFER DDSCAPS_RESERVED3
#define DDSCAPS_VERTEXBUFFER DDSCAPS_RESERVED4
/*
* This DDPF flag is used to indicate a DX8+ format capability entry in
* the texture format list. It is not visible to applications.
*/
#define DDPF_D3DFORMAT 0x00200000l
/*
* List of operations supported on formats in DX8+ texture list.
* See the DX8 DDK for a complete description of these flags.
*/
#define D3DFORMAT_OP_TEXTURE 0x00000001L
#define D3DFORMAT_OP_VOLUMETEXTURE 0x00000002L
#define D3DFORMAT_OP_CUBETEXTURE 0x00000004L
#define D3DFORMAT_OP_OFFSCREEN_RENDERTARGET 0x00000008L
#define D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET 0x00000010L
#define D3DFORMAT_OP_ZSTENCIL 0x00000040L
#define D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH 0x00000080L
// This format can be used as a render target if the current display mode
// is the same depth if the alpha channel is ignored. e.g. if the device
// can render to A8R8G8B8 when the display mode is X8R8G8B8, then the
// format op list entry for A8R8G8B8 should have this cap.
#define D3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET 0x00000100L
// This format contains DirectDraw support (including Flip). This flag
// should not to be set on alpha formats.
#define D3DFORMAT_OP_DISPLAYMODE 0x00000400L
// The rasterizer can support some level of Direct3D support in this format
// and implies that the driver can create a Context in this mode (for some
// render target format). When this flag is set, the D3DFORMAT_OP_DISPLAYMODE
// flag must also be set.
#define D3DFORMAT_OP_3DACCELERATION 0x00000800L
/*
* pre-declare pointers to structs containing data for DDHAL driver fns
*/
typedef struct _DD_CREATEPALETTEDATA *PDD_CREATEPALETTEDATA;
typedef struct _DD_CREATESURFACEDATA *PDD_CREATESURFACEDATA;
typedef struct _DD_CANCREATESURFACEDATA *PDD_CANCREATESURFACEDATA;
typedef struct _DD_WAITFORVERTICALBLANKDATA *PDD_WAITFORVERTICALBLANKDATA;
typedef struct _DD_DESTROYDRIVERDATA *PDD_DESTROYDRIVERDATA;
typedef struct _DD_SETMODEDATA *PDD_SETMODEDATA;
typedef struct _DD_DRVSETCOLORKEYDATA *PDD_DRVSETCOLORKEYDATA;
typedef struct _DD_GETSCANLINEDATA *PDD_GETSCANLINEDATA;
typedef struct _DD_MAPMEMORYDATA *PDD_MAPMEMORYDATA;
typedef struct _DD_DESTROYPALETTEDATA *PDD_DESTROYPALETTEDATA;
typedef struct _DD_SETENTRIESDATA *PDD_SETENTRIESDATA;
typedef struct _DD_BLTDATA *PDD_BLTDATA;
typedef struct _DD_LOCKDATA *PDD_LOCKDATA;
typedef struct _DD_UNLOCKDATA *PDD_UNLOCKDATA;
typedef struct _DD_UPDATEOVERLAYDATA *PDD_UPDATEOVERLAYDATA;
typedef struct _DD_SETOVERLAYPOSITIONDATA *PDD_SETOVERLAYPOSITIONDATA;
typedef struct _DD_SETPALETTEDATA *PDD_SETPALETTEDATA;
typedef struct _DD_FLIPDATA *PDD_FLIPDATA;
typedef struct _DD_DESTROYSURFACEDATA *PDD_DESTROYSURFACEDATA;
typedef struct _DD_SETCLIPLISTDATA *PDD_SETCLIPLISTDATA;
typedef struct _DD_ADDATTACHEDSURFACEDATA *PDD_ADDATTACHEDSURFACEDATA;
typedef struct _DD_SETCOLORKEYDATA *PDD_SETCOLORKEYDATA;
typedef struct _DD_GETBLTSTATUSDATA *PDD_GETBLTSTATUSDATA;
typedef struct _DD_GETFLIPSTATUSDATA *PDD_GETFLIPSTATUSDATA;
typedef struct _DD_CANCREATEVPORTDATA *PDD_CANCREATEVPORTDATA;
typedef struct _DD_CREATEVPORTDATA *PDD_CREATEVPORTDATA;
typedef struct _DD_FLIPVPORTDATA *PDD_FLIPVPORTDATA;
typedef struct _DD_GETVPORTCONNECTDATA *PDD_GETVPORTCONNECTDATA;
typedef struct _DD_GETVPORTBANDWIDTHDATA *PDD_GETVPORTBANDWIDTHDATA;
typedef struct _DD_GETVPORTINPUTFORMATDATA *PDD_GETVPORTINPUTFORMATDATA;
typedef struct _DD_GETVPORTOUTPUTFORMATDATA *PDD_GETVPORTOUTPUTFORMATDATA;
typedef struct _DD_GETVPORTAUTOFLIPSURFACEDATA *PDD_GETVPORTAUTOFLIPSURFACEDATA;
typedef struct _DD_GETVPORTFIELDDATA *PDD_GETVPORTFIELDDATA;
typedef struct _DD_GETVPORTLINEDATA *PDD_GETVPORTLINEDATA;
typedef struct _DD_DESTROYVPORTDATA *PDD_DESTROYVPORTDATA;
typedef struct _DD_GETVPORTFLIPSTATUSDATA *PDD_GETVPORTFLIPSTATUSDATA;
typedef struct _DD_UPDATEVPORTDATA *PDD_UPDATEVPORTDATA;
typedef struct _DD_WAITFORVPORTSYNCDATA *PDD_WAITFORVPORTSYNCDATA;
typedef struct _DD_GETVPORTSIGNALDATA *PDD_GETVPORTSIGNALDATA;
typedef struct _DD_VPORTCOLORDATA *PDD_VPORTCOLORDATA;
typedef struct _DD_COLORCONTROLDATA *PDD_COLORCONTROLDATA;
typedef struct _DD_GETAVAILDRIVERMEMORYDATA *PDD_GETAVAILDRIVERMEMORYDATA;
typedef struct _DD_FREEDRIVERMEMORYDATA *PDD_FREEDRIVERMEMORYDATA;
typedef struct _DD_SETEXCLUSIVEMODEDATA *PDD_SETEXCLUSIVEMODEDATA;
typedef struct _DD_FLIPTOGDISURFACEDATA *PDD_FLIPTOGDISURFACEDATA;
typedef struct _DD_GETDRIVERINFODATA *PDD_GETDRIVERINFODATA;
typedef struct _DD_SYNCSURFACEDATA *PDD_SYNCSURFACEDATA;
typedef struct _DD_SYNCVIDEOPORTDATA *PDD_SYNCVIDEOPORTDATA;
typedef struct _DD_GETMOCOMPGUIDSDATA *PDD_GETMOCOMPGUIDSDATA;
typedef struct _DD_GETMOCOMPFORMATSDATA *PDD_GETMOCOMPFORMATSDATA;
typedef struct _DD_CREATEMOCOMPDATA *PDD_CREATEMOCOMPDATA;
typedef struct _DD_GETMOCOMPCOMPBUFFDATA *PDD_GETMOCOMPCOMPBUFFDATA;
typedef struct _DD_GETINTERNALMOCOMPDATA *PDD_GETINTERNALMOCOMPDATA;
typedef struct _DD_BEGINMOCOMPFRAMEDATA *PDD_BEGINMOCOMPFRAMEDATA;
typedef struct _DD_ENDMOCOMPFRAMEDATA *PDD_ENDMOCOMPFRAMEDATA;
typedef struct _DD_RENDERMOCOMPDATA *PDD_RENDERMOCOMPDATA;
typedef struct _DD_QUERYMOCOMPSTATUSDATA *PDD_QUERYMOCOMPSTATUSDATA;
typedef struct _DD_DESTROYMOCOMPDATA *PDD_DESTROYMOCOMPDATA;
// Miscelleneous2 callbacks
typedef struct _DD_CREATESURFACEEXDATA *PDD_CREATESURFACEEXDATA;
typedef struct _DD_GETDRIVERSTATEDATA *PDD_GETDRIVERSTATEDATA;
typedef struct _DD_DESTROYDDLOCALDATA *PDD_DESTROYDDLOCALDATA;
typedef struct _DD_MORESURFACECAPS *PDD_MORESURFACECAPS;
typedef struct _DD_STEREOMODE *PDD_STEREOMODE;
typedef struct _DD_UPDATENONLOCALHEAPDATA *PDD_UPDATENONLOCALHEAPDATA;
/*
* The following structure is defined in dmemmgr.h
*/
struct _DD_GETHEAPALIGNMENTDATA;
typedef struct _DD_GETHEAPALIGNMENTDATA *PDD_GETHEAPALIGNMENTDATA;
/*
* value in the fpVidMem; indicates dwBlockSize is valid (surface object)
*/
#define DDHAL_PLEASEALLOC_BLOCKSIZE 0x00000002l
#define DDHAL_PLEASEALLOC_USERMEM 0x00000004l
/*
* video memory data structures (passed in DD_HALINFO)
*/
typedef struct _VIDEOMEMORY
{
DWORD dwFlags; // flags
FLATPTR fpStart; // start of memory chunk
union
{
FLATPTR fpEnd; // end of memory chunk
DWORD dwWidth; // width of chunk (rectanglar memory)
};
DDSCAPS ddsCaps; // what this memory CANNOT be used for
DDSCAPS ddsCapsAlt; // what this memory CANNOT be used for if it must
union
{
struct _VMEMHEAP *lpHeap; // heap pointer, used by DDRAW
DWORD dwHeight; // height of chunk (rectanguler memory)
};
} VIDEOMEMORY;
typedef VIDEOMEMORY *LPVIDEOMEMORY;
/*
* flags for vidmem struct
*/
#define VIDMEM_ISLINEAR 0x00000001l // heap is linear
#define VIDMEM_ISRECTANGULAR 0x00000002l // heap is rectangular
#define VIDMEM_ISHEAP 0x00000004l // heap is preallocated by driver
#define VIDMEM_ISNONLOCAL 0x00000008l // heap populated with non-local video memory
#define VIDMEM_ISWC 0x00000010l // heap populated with write combining memory
#define VIDMEM_HEAPDISABLED 0x00000020l // heap disabled
typedef struct _VIDEOMEMORYINFO
{
FLATPTR fpPrimary; // offset to primary surface
DWORD dwFlags; // flags
DWORD dwDisplayWidth; // current display width
DWORD dwDisplayHeight; // current display height
LONG lDisplayPitch; // current display pitch
DDPIXELFORMAT ddpfDisplay; // pixel format of display
DWORD dwOffscreenAlign; // byte alignment for offscreen surfaces
DWORD dwOverlayAlign; // byte alignment for overlays
DWORD dwTextureAlign; // byte alignment for textures
DWORD dwZBufferAlign; // byte alignment for z buffers
DWORD dwAlphaAlign; // byte alignment for alpha
PVOID pvPrimary; // kernel-mode pointer to primary surface
} VIDEOMEMORYINFO;
typedef VIDEOMEMORYINFO *LPVIDEOMEMORYINFO;
/*
* These structures contain the entry points in the display driver that
* DDRAW will call. Entries that the display driver does not care about
* should be NULL. Passed to DDRAW in DD_HALINFO.
*/
typedef struct _DD_DIRECTDRAW_GLOBAL *PDD_DIRECTDRAW_GLOBAL;
typedef struct _DD_SURFACE_GLOBAL *PDD_SURFACE_GLOBAL;
typedef struct _DD_PALETTE_GLOBAL *PDD_PALETTE_GLOBAL;
typedef struct _DD_CLIPPER_GLOBAL *PDD_CLIPPER_GLOBAL;
typedef struct _DD_DIRECTDRAW_LOCAL *PDD_DIRECTDRAW_LOCAL;
typedef struct _DD_SURFACE_LOCAL *PDD_SURFACE_LOCAL;
typedef struct _DD_SURFACE_MORE *PDD_SURFACE_MORE;
typedef struct _DD_SURFACE_INT *PDD_SURFACE_INT;
typedef struct _DD_VIDEOPORT_LOCAL *PDD_VIDEOPORT_LOCAL;
typedef struct _DD_PALETTE_LOCAL *PDD_PALETTE_LOCAL;
typedef struct _DD_CLIPPER_LOCAL *PDD_CLIPPER_LOCAL;
typedef struct _DD_MOTIONCOMP_LOCAL *PDD_MOTIONCOMP_LOCAL;
/*
* DIRECTDRAW object callbacks
*/
typedef DWORD (APIENTRY *PDD_SETCOLORKEY)(PDD_DRVSETCOLORKEYDATA );
typedef DWORD (APIENTRY *PDD_CANCREATESURFACE)(PDD_CANCREATESURFACEDATA );
typedef DWORD (APIENTRY *PDD_WAITFORVERTICALBLANK)(PDD_WAITFORVERTICALBLANKDATA );
typedef DWORD (APIENTRY *PDD_CREATESURFACE)(PDD_CREATESURFACEDATA);
typedef DWORD (APIENTRY *PDD_DESTROYDRIVER)(PDD_DESTROYDRIVERDATA);
typedef DWORD (APIENTRY *PDD_SETMODE)(PDD_SETMODEDATA);
typedef DWORD (APIENTRY *PDD_CREATEPALETTE)(PDD_CREATEPALETTEDATA);
typedef DWORD (APIENTRY *PDD_GETSCANLINE)(PDD_GETSCANLINEDATA);
typedef DWORD (APIENTRY *PDD_MAPMEMORY)(PDD_MAPMEMORYDATA);
typedef DWORD (APIENTRY *PDD_GETDRIVERINFO)(PDD_GETDRIVERINFODATA);
typedef struct DD_CALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_DESTROYDRIVER DestroyDriver;
PDD_CREATESURFACE CreateSurface;
PDD_SETCOLORKEY SetColorKey;
PDD_SETMODE SetMode;
PDD_WAITFORVERTICALBLANK WaitForVerticalBlank;
PDD_CANCREATESURFACE CanCreateSurface;
PDD_CREATEPALETTE CreatePalette;
PDD_GETSCANLINE GetScanLine;
PDD_MAPMEMORY MapMemory;
} DD_CALLBACKS;
typedef DD_CALLBACKS *PDD_CALLBACKS;
#define DDHAL_CB32_DESTROYDRIVER 0x00000001l
#define DDHAL_CB32_CREATESURFACE 0x00000002l
#define DDHAL_CB32_SETCOLORKEY 0x00000004l
#define DDHAL_CB32_SETMODE 0x00000008l
#define DDHAL_CB32_WAITFORVERTICALBLANK 0x00000010l
#define DDHAL_CB32_CANCREATESURFACE 0x00000020l
#define DDHAL_CB32_CREATEPALETTE 0x00000040l
#define DDHAL_CB32_GETSCANLINE 0x00000080l
#define DDHAL_CB32_MAPMEMORY 0x80000000l
// This structure can be queried from the driver from NT5 onward
// using GetDriverInfo with GUID_MiscellaneousCallbacks
typedef DWORD (APIENTRY *PDD_GETAVAILDRIVERMEMORY)(PDD_GETAVAILDRIVERMEMORYDATA);
typedef struct _DD_MISCELLANEOUSCALLBACKS {
DWORD dwSize;
DWORD dwFlags;
PDD_GETAVAILDRIVERMEMORY GetAvailDriverMemory;
} DD_MISCELLANEOUSCALLBACKS, *PDD_MISCELLANEOUSCALLBACKS;
#define DDHAL_MISCCB32_GETAVAILDRIVERMEMORY 0x00000001l
// DDHAL_DDMISCELLANEOUS2CALLBACKS:
// This structure can be queried from the driver from DX7 onward
// using GetDriverInfo with GUID_Miscellaneous2Callbacks
typedef DWORD (APIENTRY *PDD_ALPHABLT)(PDD_BLTDATA);
typedef DWORD (APIENTRY *PDD_CREATESURFACEEX)(PDD_CREATESURFACEEXDATA);
typedef DWORD (APIENTRY *PDD_GETDRIVERSTATE)(PDD_GETDRIVERSTATEDATA);
typedef DWORD (APIENTRY *PDD_DESTROYDDLOCAL)(PDD_DESTROYDDLOCALDATA);
typedef struct _DD_MISCELLANEOUS2CALLBACKS {
DWORD dwSize;
DWORD dwFlags;
PDD_ALPHABLT AlphaBlt;
PDD_CREATESURFACEEX CreateSurfaceEx;
PDD_GETDRIVERSTATE GetDriverState;
PDD_DESTROYDDLOCAL DestroyDDLocal;
} DD_MISCELLANEOUS2CALLBACKS, *PDD_MISCELLANEOUS2CALLBACKS;
#define DDHAL_MISC2CB32_ALPHABLT 0x00000001l
#define DDHAL_MISC2CB32_CREATESURFACEEX 0x00000002l
#define DDHAL_MISC2CB32_GETDRIVERSTATE 0x00000004l
#define DDHAL_MISC2CB32_DESTROYDDLOCAL 0x00000008l
// This is used in the CreateSurfaceEx callback to indicate that the
// SwapHandle emulation is being done
#define DDHAL_CREATESURFACEEX_SWAPHANDLES 0x00000001l
// This structure can be queried from the driver from NT5 onward
// using GetDriverInfo with GUID_NTCallbacks
typedef DWORD (APIENTRY *PDD_FREEDRIVERMEMORY)(PDD_FREEDRIVERMEMORYDATA);
typedef DWORD (APIENTRY *PDD_SETEXCLUSIVEMODE)(PDD_SETEXCLUSIVEMODEDATA);
typedef DWORD (APIENTRY *PDD_FLIPTOGDISURFACE)(PDD_FLIPTOGDISURFACEDATA);
typedef struct _DD_NTCALLBACKS {
DWORD dwSize;
DWORD dwFlags;
PDD_FREEDRIVERMEMORY FreeDriverMemory;
PDD_SETEXCLUSIVEMODE SetExclusiveMode;
PDD_FLIPTOGDISURFACE FlipToGDISurface;
} DD_NTCALLBACKS, *PDD_NTCALLBACKS;
#define DDHAL_NTCB32_FREEDRIVERMEMORY 0x00000001l
#define DDHAL_NTCB32_SETEXCLUSIVEMODE 0x00000002l
#define DDHAL_NTCB32_FLIPTOGDISURFACE 0x00000004l
/*
* DIRECTDRAWPALETTE object callbacks
*/
typedef DWORD (APIENTRY *PDD_PALCB_DESTROYPALETTE)(PDD_DESTROYPALETTEDATA );
typedef DWORD (APIENTRY *PDD_PALCB_SETENTRIES)(PDD_SETENTRIESDATA );
typedef struct DD_PALETTECALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_PALCB_DESTROYPALETTE DestroyPalette;
PDD_PALCB_SETENTRIES SetEntries;
} DD_PALETTECALLBACKS;
typedef DD_PALETTECALLBACKS *PDD_PALETTECALLBACKS;
#define DDHAL_PALCB32_DESTROYPALETTE 0x00000001l
#define DDHAL_PALCB32_SETENTRIES 0x00000002l
/*
* DIRECTDRAWSURFACE object callbacks
*/
typedef DWORD (APIENTRY *PDD_SURFCB_LOCK)(PDD_LOCKDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_UNLOCK)(PDD_UNLOCKDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_BLT)(PDD_BLTDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_UPDATEOVERLAY)(PDD_UPDATEOVERLAYDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_SETOVERLAYPOSITION)(PDD_SETOVERLAYPOSITIONDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_SETPALETTE)(PDD_SETPALETTEDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_FLIP)(PDD_FLIPDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_DESTROYSURFACE)(PDD_DESTROYSURFACEDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_SETCLIPLIST)(PDD_SETCLIPLISTDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_ADDATTACHEDSURFACE)(PDD_ADDATTACHEDSURFACEDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_SETCOLORKEY)(PDD_SETCOLORKEYDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_GETBLTSTATUS)(PDD_GETBLTSTATUSDATA);
typedef DWORD (APIENTRY *PDD_SURFCB_GETFLIPSTATUS)(PDD_GETFLIPSTATUSDATA);
typedef struct DD_SURFACECALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_SURFCB_DESTROYSURFACE DestroySurface;
PDD_SURFCB_FLIP Flip;
PDD_SURFCB_SETCLIPLIST SetClipList;
PDD_SURFCB_LOCK Lock;
PDD_SURFCB_UNLOCK Unlock;
PDD_SURFCB_BLT Blt;
PDD_SURFCB_SETCOLORKEY SetColorKey;
PDD_SURFCB_ADDATTACHEDSURFACE AddAttachedSurface;
PDD_SURFCB_GETBLTSTATUS GetBltStatus;
PDD_SURFCB_GETFLIPSTATUS GetFlipStatus;
PDD_SURFCB_UPDATEOVERLAY UpdateOverlay;
PDD_SURFCB_SETOVERLAYPOSITION SetOverlayPosition;
LPVOID reserved4;
PDD_SURFCB_SETPALETTE SetPalette;
} DD_SURFACECALLBACKS;
typedef DD_SURFACECALLBACKS *PDD_SURFACECALLBACKS;
#define DDHAL_SURFCB32_DESTROYSURFACE 0x00000001l
#define DDHAL_SURFCB32_FLIP 0x00000002l
#define DDHAL_SURFCB32_SETCLIPLIST 0x00000004l
#define DDHAL_SURFCB32_LOCK 0x00000008l
#define DDHAL_SURFCB32_UNLOCK 0x00000010l
#define DDHAL_SURFCB32_BLT 0x00000020l
#define DDHAL_SURFCB32_SETCOLORKEY 0x00000040l
#define DDHAL_SURFCB32_ADDATTACHEDSURFACE 0x00000080l
#define DDHAL_SURFCB32_GETBLTSTATUS 0x00000100l
#define DDHAL_SURFCB32_GETFLIPSTATUS 0x00000200l
#define DDHAL_SURFCB32_UPDATEOVERLAY 0x00000400l
#define DDHAL_SURFCB32_SETOVERLAYPOSITION 0x00000800l
#define DDHAL_SURFCB32_RESERVED4 0x00001000l
#define DDHAL_SURFCB32_SETPALETTE 0x00002000l
/*
* DIRECTVIDEOPORT object callbacks
*/
typedef DWORD (APIENTRY *PDD_VPORTCB_CANCREATEVIDEOPORT)(PDD_CANCREATEVPORTDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_CREATEVIDEOPORT)(PDD_CREATEVPORTDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_FLIP)(PDD_FLIPVPORTDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETBANDWIDTH)(PDD_GETVPORTBANDWIDTHDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETINPUTFORMATS)(PDD_GETVPORTINPUTFORMATDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETOUTPUTFORMATS)(PDD_GETVPORTOUTPUTFORMATDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETAUTOFLIPSURF)(PDD_GETVPORTAUTOFLIPSURFACEDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETFIELD)(PDD_GETVPORTFIELDDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETLINE)(PDD_GETVPORTLINEDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETVPORTCONNECT)(PDD_GETVPORTCONNECTDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_DESTROYVPORT)(PDD_DESTROYVPORTDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETFLIPSTATUS)(PDD_GETVPORTFLIPSTATUSDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_UPDATE)(PDD_UPDATEVPORTDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_WAITFORSYNC)(PDD_WAITFORVPORTSYNCDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_GETSIGNALSTATUS)(PDD_GETVPORTSIGNALDATA);
typedef DWORD (APIENTRY *PDD_VPORTCB_COLORCONTROL)(PDD_VPORTCOLORDATA);
typedef struct DD_VIDEOPORTCALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_VPORTCB_CANCREATEVIDEOPORT CanCreateVideoPort;
PDD_VPORTCB_CREATEVIDEOPORT CreateVideoPort;
PDD_VPORTCB_FLIP FlipVideoPort;
PDD_VPORTCB_GETBANDWIDTH GetVideoPortBandwidth;
PDD_VPORTCB_GETINPUTFORMATS GetVideoPortInputFormats;
PDD_VPORTCB_GETOUTPUTFORMATS GetVideoPortOutputFormats;
LPVOID lpReserved1;
PDD_VPORTCB_GETFIELD GetVideoPortField;
PDD_VPORTCB_GETLINE GetVideoPortLine;
PDD_VPORTCB_GETVPORTCONNECT GetVideoPortConnectInfo;
PDD_VPORTCB_DESTROYVPORT DestroyVideoPort;
PDD_VPORTCB_GETFLIPSTATUS GetVideoPortFlipStatus;
PDD_VPORTCB_UPDATE UpdateVideoPort;
PDD_VPORTCB_WAITFORSYNC WaitForVideoPortSync;
PDD_VPORTCB_GETSIGNALSTATUS GetVideoSignalStatus;
PDD_VPORTCB_COLORCONTROL ColorControl;
} DD_VIDEOPORTCALLBACKS;
typedef DD_VIDEOPORTCALLBACKS *PDD_VIDEOPORTCALLBACKS;
#define DDHAL_VPORT32_CANCREATEVIDEOPORT 0x00000001l
#define DDHAL_VPORT32_CREATEVIDEOPORT 0x00000002l
#define DDHAL_VPORT32_FLIP 0x00000004l
#define DDHAL_VPORT32_GETBANDWIDTH 0x00000008l
#define DDHAL_VPORT32_GETINPUTFORMATS 0x00000010l
#define DDHAL_VPORT32_GETOUTPUTFORMATS 0x00000020l
#define DDHAL_VPORT32_GETAUTOFLIPSURF 0x00000040l
#define DDHAL_VPORT32_GETFIELD 0x00000080l
#define DDHAL_VPORT32_GETLINE 0x00000100l
#define DDHAL_VPORT32_GETCONNECT 0x00000200l
#define DDHAL_VPORT32_DESTROY 0x00000400l
#define DDHAL_VPORT32_GETFLIPSTATUS 0x00000800l
#define DDHAL_VPORT32_UPDATE 0x00001000l
#define DDHAL_VPORT32_WAITFORSYNC 0x00002000l
#define DDHAL_VPORT32_GETSIGNALSTATUS 0x00004000l
#define DDHAL_VPORT32_COLORCONTROL 0x00008000l
/*
* DIRECTDRAWCOLORCONTROL object callbacks
*/
typedef DWORD (APIENTRY *PDD_COLORCB_COLORCONTROL)(PDD_COLORCONTROLDATA);
typedef struct _DD_COLORCONTROLCALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_COLORCB_COLORCONTROL ColorControl;
} DD_COLORCONTROLCALLBACKS;
typedef DD_COLORCONTROLCALLBACKS *PDD_COLORCONTROLCALLBACKS;
#define DDHAL_COLOR_COLORCONTROL 0x00000001l
/*
* DIRECTDRAWSURFACEKERNEL object callbacks
* This structure can be queried from the driver from DX5 onward
* using GetDriverInfo with GUID_KernelCallbacks
*/
typedef DWORD (APIENTRY *PDD_KERNELCB_SYNCSURFACE)(PDD_SYNCSURFACEDATA);
typedef DWORD (APIENTRY *PDD_KERNELCB_SYNCVIDEOPORT)(PDD_SYNCVIDEOPORTDATA);
typedef struct DD_KERNELCALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_KERNELCB_SYNCSURFACE SyncSurfaceData;
PDD_KERNELCB_SYNCVIDEOPORT SyncVideoPortData;
} DD_KERNELCALLBACKS, *PDD_KERNELCALLBACKS;
#define DDHAL_KERNEL_SYNCSURFACEDATA 0x00000001l
#define DDHAL_KERNEL_SYNCVIDEOPORTDATA 0x00000002l
/*
* DIRECTDRAWVIDEO object callbacks
*/
typedef DWORD (APIENTRY *PDD_MOCOMPCB_GETGUIDS)( PDD_GETMOCOMPGUIDSDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_GETFORMATS)( PDD_GETMOCOMPFORMATSDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_CREATE)( PDD_CREATEMOCOMPDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_GETCOMPBUFFINFO)( PDD_GETMOCOMPCOMPBUFFDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_GETINTERNALINFO)( PDD_GETINTERNALMOCOMPDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_BEGINFRAME)( PDD_BEGINMOCOMPFRAMEDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_ENDFRAME)( PDD_ENDMOCOMPFRAMEDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_RENDER)( PDD_RENDERMOCOMPDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_QUERYSTATUS)( PDD_QUERYMOCOMPSTATUSDATA);
typedef DWORD (APIENTRY *PDD_MOCOMPCB_DESTROY)( PDD_DESTROYMOCOMPDATA);
typedef struct DD_MOTIONCOMPCALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_MOCOMPCB_GETGUIDS GetMoCompGuids;
PDD_MOCOMPCB_GETFORMATS GetMoCompFormats;
PDD_MOCOMPCB_CREATE CreateMoComp;
PDD_MOCOMPCB_GETCOMPBUFFINFO GetMoCompBuffInfo;
PDD_MOCOMPCB_GETINTERNALINFO GetInternalMoCompInfo;
PDD_MOCOMPCB_BEGINFRAME BeginMoCompFrame;
PDD_MOCOMPCB_ENDFRAME EndMoCompFrame;
PDD_MOCOMPCB_RENDER RenderMoComp;
PDD_MOCOMPCB_QUERYSTATUS QueryMoCompStatus;
PDD_MOCOMPCB_DESTROY DestroyMoComp;
} DD_MOTIONCOMPCALLBACKS;
typedef DD_MOTIONCOMPCALLBACKS *PDD_MOTIONCOMPCALLBACKS;
#define DDHAL_MOCOMP32_GETGUIDS 0x00000001
#define DDHAL_MOCOMP32_GETFORMATS 0x00000002
#define DDHAL_MOCOMP32_CREATE 0x00000004
#define DDHAL_MOCOMP32_GETCOMPBUFFINFO 0x00000008
#define DDHAL_MOCOMP32_GETINTERNALINFO 0x00000010
#define DDHAL_MOCOMP32_BEGINFRAME 0x00000020
#define DDHAL_MOCOMP32_ENDFRAME 0x00000040
#define DDHAL_MOCOMP32_RENDER 0x00000080
#define DDHAL_MOCOMP32_QUERYSTATUS 0x00000100
#define DDHAL_MOCOMP32_DESTROY 0x00000200
/*
* CALLBACK RETURN VALUES
*
* these are values returned by the driver from the above callback routines
*/
/*
* indicates that the display driver didn't do anything with the call
*/
#define DDHAL_DRIVER_NOTHANDLED 0x00000000l
/*
* indicates that the display driver handled the call; HRESULT value is valid
*/
#define DDHAL_DRIVER_HANDLED 0x00000001l
/*
* indicates that the display driver couldn't handle the call because it
* ran out of color key hardware resources
*/
#define DDHAL_DRIVER_NOCKEYHW 0x00000002l
/*
* Capabilities structure for non-local video memory
*/
typedef struct _DD_NONLOCALVIDMEMCAPS
{
DWORD dwSize;
DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts
DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts
DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts
DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts
DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts
} DD_NONLOCALVIDMEMCAPS;
typedef struct _DD_NONLOCALVIDMEMCAPS *PDD_NONLOCALVIDMEMCAPS;
/*
* DDRAW internal version of DIRECTDRAWPALETTE object; it has data after the vtable
*/
typedef struct _DD_PALETTE_GLOBAL
{
ULONG_PTR dwReserved1; // reserved for use by display driver
} DD_PALETTE_GLOBAL;
typedef struct _DD_PALETTE_LOCAL
{
ULONG dwReserved0; // reserved for future expansion
ULONG_PTR dwReserved1; // reserved for use by display driver
} DD_PALETTE_LOCAL;
/*
* DDRAW internal version of DIRECTDRAWCLIPPER object; it has data after the vtable
*/
typedef struct _DD_CLIPPER_GLOBAL
{
ULONG_PTR dwReserved1; // reserved for use by display driver
} DD_CLIPPER_GLOBAL;
typedef struct _DD_CLIPPER_LOCAL
{
ULONG_PTR dwReserved1; // reserved for use by display driver
} DD_CLIPPER_LOCAL;
typedef struct _DD_ATTACHLIST *PDD_ATTACHLIST;
typedef struct _DD_ATTACHLIST
{
PDD_ATTACHLIST lpLink; // link to next attached surface
PDD_SURFACE_LOCAL lpAttached; // attached surface local object
} DD_ATTACHLIST;
/*
* DDRAW surface interface struct
*/
typedef struct _DD_SURFACE_INT
{
PDD_SURFACE_LOCAL lpLcl; // pointer to interface data
} DD_SURFACE_INT;
/*
* DDRAW internal version of DIRECTDRAWSURFACE struct
*
* the GBL structure is global data for all duplicate objects
*/
typedef struct _DD_SURFACE_GLOBAL
{
union
{
DWORD dwBlockSizeY; // block size that display driver requested (return)
LONG lSlicePitch; // slice pitch for volume textures
};
union
{
LPVIDEOMEMORY lpVidMemHeap; // heap vidmem was alloc'ed from
DWORD dwBlockSizeX; // block size that display driver requested (return)
DWORD dwUserMemSize; // user-mode memory size that display driver requested (return)
};
FLATPTR fpVidMem; // pointer to video memory
union
{
LONG lPitch; // pitch of surface
DWORD dwLinearSize; // linear size of non-rectangular surface
};
LONG yHint; // y-coordinate of surface
LONG xHint; // x-coordinate of surface
DWORD wHeight; // height of surface
DWORD wWidth; // width of surface
ULONG_PTR dwReserved1; // reserved for use by display driver
DDPIXELFORMAT ddpfSurface; // pixel format of surface
FLATPTR fpHeapOffset; // raw offset in source heap
HANDLE hCreatorProcess;// opaque identifier for creating process
} DD_SURFACE_GLOBAL;
/*
* a structure holding additional LCL surface information (to maintain some
* compatibility with Win95).
*/
typedef struct _DD_SURFACE_MORE
{
DWORD dwMipMapCount; // number of mip-map levels
PDD_VIDEOPORT_LOCAL lpVideoPort; // video port currently writing data to this surface
DWORD dwOverlayFlags; // current overlay flags
DDSCAPSEX ddsCapsEx; // more surface capabilities
DWORD dwSurfaceHandle; // cookie for use with CreateSurfaceEx DDI
} DD_SURFACE_MORE, *PDD_SURFACE_MORE;
/*
* the LCL structure is local data for each individual surface object
*/
typedef struct _DD_SURFACE_LOCAL
{
PDD_SURFACE_GLOBAL lpGbl; // pointer to surface shared data
DWORD dwFlags; // flags
DDSCAPS ddsCaps; // capabilities of surface
ULONG_PTR dwReserved1; // reserved for use by display driver
union
{
DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use
DDCOLORKEY ddckCKSrcBlt; // color key for source blt and texture use
};
union
{
DDCOLORKEY ddckCKDestOverlay;// color key for destination overlay use
DDCOLORKEY ddckCKDestBlt; // color key for destination blt
};
PDD_SURFACE_MORE lpSurfMore; // pointer to additional local data
PDD_ATTACHLIST lpAttachList; // link to surfaces we attached to
PDD_ATTACHLIST lpAttachListFrom; // link to surfaces that attached to us
RECT rcOverlaySrc; // Overlay source rectangle relative to surface
} DD_SURFACE_LOCAL;
#define DDRAWISURF_HASCKEYSRCBLT 0x00000800L // surface has CKSrcBlt
#define DDRAWISURF_HASPIXELFORMAT 0x00002000L // surface structure has pixel format data
#define DDRAWISURF_HASOVERLAYDATA 0x00004000L // surface structure has overlay data
#define DDRAWISURF_FRONTBUFFER 0x04000000L // surface was originally a front buffer
#define DDRAWISURF_BACKBUFFER 0x08000000L // surface was originally backbuffer
#define DDRAWISURF_INVALID 0x10000000L // surface has been invalidated by mode set
#define DDRAWISURF_DRIVERMANAGED 0x40000000L // surface is a driver managed texture (D3D)
/*
* More driver capabilities (in addition to those described in DDCORECAPS).
* This struct contains the caps bits added to the DDCAPS structure in DX6.
*/
typedef struct _DD_MORECAPS
{
DWORD dwSize; // size of DDMORECAPS structure
DWORD dwAlphaCaps; // driver-specific alpha caps for overlays & Vmem->Vmem blts
DWORD dwSVBAlphaCaps; // driver-specific alpha capabilities for System->Vmem blts
DWORD dwVSBAlphaCaps; // driver-specific alpha capabilities for Vmem->System blts
DWORD dwSSBAlphaCaps; // driver-specific alpha capabilities for System->System blts
DWORD dwFilterCaps; // driver-specific filter caps for overlays & Vmem->Vmem blts
DWORD dwSVBFilterCaps; // driver-specific filter capabilities for System->Vmem blts
DWORD dwVSBFilterCaps; // driver-specific filter capabilities for Vmem->System blts
DWORD dwSSBFilterCaps; // driver-specific filter capabilities for System->System blts
} DD_MORECAPS;
typedef DD_MORECAPS *PDD_MORECAPS;
/*
* rop stuff
*/
#define ROP_HAS_SOURCE 0x00000001l
#define ROP_HAS_PATTERN 0x00000002l
#define ROP_HAS_SOURCEPATTERN ROP_HAS_SOURCE | ROP_HAS_PATTERN
/*
* This structure mirrors the first entries of the DDCAPS but is of a fixed
* size and will not grow as DDCAPS grows. This is the structure your driver
* returns in DDCOREINFO. Additional caps will be requested via a GetDriverInfo
* call.
*/
typedef struct _DDNTCORECAPS
{
DWORD dwSize; // size of the DDDRIVERCAPS structure
DWORD dwCaps; // driver specific capabilities
DWORD dwCaps2; // more driver specific capabilites
DWORD dwCKeyCaps; // color key capabilities of the surface
DWORD dwFXCaps; // driver specific stretching and effects capabilites
DWORD dwFXAlphaCaps; // alpha driver specific capabilities
DWORD dwPalCaps; // palette capabilities
DWORD dwSVCaps; // stereo vision capabilities
DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8
DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8
DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8
DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8
DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8
DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
DWORD dwZBufferBitDepths; // DDBD_8,16,24,32
DWORD dwVidMemTotal; // total amount of video memory
DWORD dwVidMemFree; // amount of free video memory
DWORD dwMaxVisibleOverlays; // maximum number of visible overlays
DWORD dwCurrVisibleOverlays; // current number of visible overlays
DWORD dwNumFourCCCodes; // number of four cc codes
DWORD dwAlignBoundarySrc; // source rectangle alignment
DWORD dwAlignSizeSrc; // source rectangle byte size
DWORD dwAlignBoundaryDest; // dest rectangle alignment
DWORD dwAlignSizeDest; // dest rectangle byte size
DWORD dwAlignStrideAlign; // stride alignment
DWORD dwRops[DD_ROP_SPACE]; // ROPS supported
DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities
DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
DWORD dwReserved1; // reserved
DWORD dwReserved2; // reserved
DWORD dwReserved3; // reserved
DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts
DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts
DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts
DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts
DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts
DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts
DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts
DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts
DWORD dwSSBCaps; // driver specific capabilities for System->System blts
DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts
DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts
DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts
DWORD dwMaxVideoPorts; // maximum number of usable video ports
DWORD dwCurrVideoPorts; // current number of video ports used
DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts
} DDNTCORECAPS, *PDDNTCORECAPS;
/*
* structure for D3D buffer callbacks
*/
typedef struct _DD_D3DBUFCALLBACKS
{
DWORD dwSize;
DWORD dwFlags;
PDD_CANCREATESURFACE CanCreateD3DBuffer;
PDD_CREATESURFACE CreateD3DBuffer;
PDD_SURFCB_DESTROYSURFACE DestroyD3DBuffer;
PDD_SURFCB_LOCK LockD3DBuffer;
PDD_SURFCB_UNLOCK UnlockD3DBuffer;
} DD_D3DBUFCALLBACKS, *PDD_D3DBUFCALLBACKS;
#define DDHAL_EXEBUFCB32_CANCREATEEXEBUF 0x00000001l
#define DDHAL_EXEBUFCB32_CREATEEXEBUF 0x00000002l
#define DDHAL_EXEBUFCB32_DESTROYEXEBUF 0x00000004l
#define DDHAL_EXEBUFCB32_LOCKEXEBUF 0x00000008l
#define DDHAL_EXEBUFCB32_UNLOCKEXEBUF 0x00000010l
/*
* NT friendly names
*/
#define DDHAL_D3DBUFCB32_CANCREATED3DBUF DDHAL_EXEBUFCB32_CANCREATEEXEBUF
#define DDHAL_D3DBUFCB32_CREATED3DBUF DDHAL_EXEBUFCB32_CREATEEXEBUF
#define DDHAL_D3DBUFCB32_DESTROYD3DBUF DDHAL_EXEBUFCB32_DESTROYEXEBUF
#define DDHAL_D3DBUFCB32_LOCKD3DBUF DDHAL_EXEBUFCB32_LOCKEXEBUF
#define DDHAL_D3DBUFCB32_UNLOCKD3DBUF DDHAL_EXEBUFCB32_UNLOCKEXEBUF
/*
* structure for display driver to call DDHAL_Create with
* the _V4 version was used by NT4 drivers
*/
typedef struct _DD_HALINFO_V4
{
DWORD dwSize;
VIDEOMEMORYINFO vmiData; // video memory info
DDNTCORECAPS ddCaps; // hw specific caps
PDD_GETDRIVERINFO GetDriverInfo; // callback for querying driver data
DWORD dwFlags; // create flags
} DD_HALINFO_V4, *PDD_HALINFO_V4;
typedef struct _DD_HALINFO
{
DWORD dwSize;
VIDEOMEMORYINFO vmiData; // video memory info
DDNTCORECAPS ddCaps; // hw specific caps
PDD_GETDRIVERINFO GetDriverInfo; // callback for querying driver data
DWORD dwFlags; // create flags
LPVOID lpD3DGlobalDriverData; // D3D global Data
LPVOID lpD3DHALCallbacks; // D3D callbacks
PDD_D3DBUFCALLBACKS lpD3DBufCallbacks; // Buffer callbacks
} DD_HALINFO, *PDD_HALINFO;
#define DDHALINFO_GETDRIVERINFOSET 0x00000004l // indicates that GetDriverInfo is set
#define DDHALINFO_GETDRIVERINFO2 0x00000008l // indicates driver support GetDriverInfo2 variant
// of GetDriverInfo. New for DX 8.0
/*
* DDRAW version of DirectDraw object;
*
*/
typedef struct _DD_DIRECTDRAW_GLOBAL
{
VOID* dhpdev; // driver's private PDEV pointer
ULONG_PTR dwReserved1; // reserved for use by display driver
ULONG_PTR dwReserved2; // reserved for use by display driver
LPDDVIDEOPORTCAPS lpDDVideoPortCaps;// Info returned by the HAL (an array if more than one video port)
} DD_DIRECTDRAW_GLOBAL;
typedef struct _DD_DIRECTDRAW_LOCAL
{
PDD_DIRECTDRAW_GLOBAL lpGbl; // pointer to data
} DD_DIRECTDRAW_LOCAL;
typedef struct _DD_VIDEOPORT_LOCAL
{
PDD_DIRECTDRAW_LOCAL lpDD; // pointer to DIRECTDRAW_LCL
DDVIDEOPORTDESC ddvpDesc; // description used at create time
DDVIDEOPORTINFO ddvpInfo; // most recent video port info
PDD_SURFACE_INT lpSurface; // surface receiving the data
PDD_SURFACE_INT lpVBISurface; // surface receiving the VBI data
DWORD dwNumAutoflip; // Number of current autoflip surfaces
DWORD dwNumVBIAutoflip; // Number of VBI surfaces currently being autoflipped
ULONG_PTR dwReserved1; // Reserved for display driver
ULONG_PTR dwReserved2; // Reserved for display driver
ULONG_PTR dwReserved3; // Reserved for display driver
} DD_VIDEOPORT_LOCAL;
#define DDRAWIVPORT_ON 0x00000001 // Video port is pumping data
#define DDRAWIVPORT_SOFTWARE_AUTOFLIP 0x00000002 // Video port cannot use hardware autoflip
#define DDRAWIVPORT_COLORKEYANDINTERP 0x00000004 // Overlay cannot bob and colorkey at same time
typedef struct _DD_MOTIONCOMP_LOCAL
{
PDD_DIRECTDRAW_LOCAL lpDD; // pointer to DIRECTDRAW_LCL
GUID guid;
DWORD dwUncompWidth;
DWORD dwUncompHeight;
DDPIXELFORMAT ddUncompPixelFormat;
DWORD dwDriverReserved1;
DWORD dwDriverReserved2;
DWORD dwDriverReserved3;
LPVOID lpDriverReserved1;
LPVOID lpDriverReserved2;
LPVOID lpDriverReserved3;
} DD_MOTIONCOMP_LOCAL;
/*
* More driver surface capabilities (in addition to those described in DDCORECAPS).
* This struct contains the caps bits added to the DDCAPS.ddsCaps structure in DX6.
*/
typedef struct _DD_MORESURFACECAPS
{
DWORD dwSize; // size of DDMORESURFACECAPS structure
DDSCAPSEX ddsCapsMore;
/*
* The DDMORESURFACECAPS struct is of variable size. The following list may be
* filled in by DX6-aware drivers (see DDVERSIONINFO) to restrict their
* video memory heaps (those which are exposed to DirectDraw) to
* certain sets of DDSCAPS_ bits. Thse entries are exactly analogous to
* the ddsCaps and ddsCapsAlt members of the VIDMEM structures listed in
* the VIDMEMINFO.pvmList member of DDHALINFO.vmiData. There should be
* exactly DDHALINFO.vmiData.dwNumHeaps copies of tagExtendedHeapRestrictions
* in this struct. The size of this struct is thus:
* DDMORESURFACECAPS.dwSize = sizeof(DDMORESURFACECAPS) +
* (DDHALINFO.vmiData.dwNumHeaps-1) * sizeof(DDSCAPSEX)*2;
* Note the -1 accounts for the fact that DDMORESURFACECAPS is declared to have 1
* tagExtendedHeapRestrictions member.
*/
struct tagNTExtendedHeapRestrictions
{
DDSCAPSEX ddsCapsEx;
DDSCAPSEX ddsCapsExAlt;
} ddsExtendedHeapRestrictions[1];
} DD_MORESURFACECAPS;
// for DX7, we check each mode in the driver if it supports
// Stereo, driver returns DD_OK if mode is ok for stereo
typedef struct _DD_STEREOMODE
{
DWORD dwSize; // size of DDSTEREOMODECAPS structure
DWORD dwHeight;
DWORD dwWidth;
DWORD dwBpp;
DWORD dwRefreshRate;
BOOL bSupported;
} DD_STEREOMODE;
typedef struct _DD_UPDATENONLOCALHEAPDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
DWORD dwHeap; // heap index
FLATPTR fpGARTLin; // linear GART address of start of heap
FLATPTR fpGARTDev; // high physical GART address of start of heap
ULONG_PTR ulPolicyMaxBytes; // maximum amount of AGP memory to use
HRESULT ddRVal; // return value
VOID* UpdateNonLocalHeap; // Unused: Win95 compatibility
} DD_UPDATENONLOCALHEAPDATA;
/*
* Private caps that the driver passes to change DirectDraw behavior.
* These caps are not exposed to the application
*/
typedef struct DD_NTPRIVATEDRIVERCAPS
{
DWORD dwSize;
DWORD dwPrivateCaps;
} DD_NTPRIVATEDRIVERCAPS;
// Driver wants DD_CREATESURFACEDATA.lplpSList to contain a list of
// surfaces to create rather than always a single surface.
#define DDHAL_PRIVATECAP_ATOMICSURFACECREATION 0x00000001l
// Driver wants to be notified when creating a primary surface.
#define DDHAL_PRIVATECAP_NOTIFYPRIMARYCREATION 0x00000002l
#define DDHAL_PRIVATECAP_RESERVED1 0x00000004l
/////////////////////////////////////////////////////////////////////////////
// NT Note:
//
// The following structures must match, field for field, the corresponding
// structures as declared in 'ddrawi.h.' We cannot simply use the same
// structures because the sub-structures such as DD_DIRECTDRAW_GLOBAL are
// different, and have to be properly typed for the drivers.
//
/////////////////////////////////////////////////////////////////////////////
/****************************************************************************
*
* DDHAL structures for Surface Object callbacks
*
***************************************************************************/
/*
* This special flag is seen only by drivers. The DD runtime sets this
* bit in DDHAL_BLTDATA.dwFlags if the dwAFlags and ddrgbaScaleFactors
* members at the end of the DDHAL_BLTDATA structure are valid.
* The flag is always set if the DDHAL_BLTDATA structure is passed to
* the driver via the AlphaBlt HAL callback; otherwise, the flag is zero.
*/
#define DDBLT_AFLAGS 0x80000000L
/*
* This flag will be set in DDHAL_BLTDATA.dwAFlags if the call was originated
* by the AlphaBlt API method. If the call was originated by the Blt API,
* this flag will not be set.
* Drivers which have a unified Blt/AlphaBlt DDI can use this flag to distinguish
* between the two API calls.
*/
#define DDABLT_SRCOVERDEST 0x00000001L
/*
* structure for passing information to DDHAL Blt fn
*/
typedef struct _DD_BLTDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDDestSurface;// dest surface
RECTL rDest; // dest rect
PDD_SURFACE_LOCAL lpDDSrcSurface; // src surface
RECTL rSrc; // src rect
DWORD dwFlags; // blt flags
DWORD dwROPFlags; // ROP flags (valid for ROPS only)
DDBLTFX bltFX; // blt FX
HRESULT ddRVal; // return value
VOID* Blt; // Unused: Win95 compatibility
BOOL IsClipped; // clipped blt?
RECTL rOrigDest; // unclipped dest rect
// (only valid if IsClipped)
RECTL rOrigSrc; // unclipped src rect
// (only valid if IsClipped)
DWORD dwRectCnt; // count of dest rects
// (only valid if IsClipped)
LPRECT prDestRects; // array of dest rects
// (only valid if IsClipped)
DWORD dwAFlags; // DDABLT_ flags (for AlphaBlt DDI)
DDARGB ddargbScaleFactors; // ARGB scaling factors (AlphaBlt)
} DD_BLTDATA;
/*
* structure for passing information to DDHAL Lock fn
*/
typedef struct _DD_LOCKDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
DWORD bHasRect; // rArea is valid
RECTL rArea; // area being locked
LPVOID lpSurfData; // pointer to screen memory (return value)
HRESULT ddRVal; // return value
VOID* Lock; // Unused: Win95 compatibility
DWORD dwFlags; // DDLOCK flags
FLATPTR fpProcess; // process start address
} DD_LOCKDATA;
/*
* structure for passing information to DDHAL Unlock fn
*/
typedef struct _DD_UNLOCKDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
HRESULT ddRVal; // return value
VOID* Unlock; // Unused: Win95 compatibility
} DD_UNLOCKDATA;
/*
* structure for passing information to DDHAL UpdateOverlay fn
*/
typedef struct _DD_UPDATEOVERLAYDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDDestSurface;// dest surface
RECTL rDest; // dest rect
PDD_SURFACE_LOCAL lpDDSrcSurface; // src surface
RECTL rSrc; // src rect
DWORD dwFlags; // flags
DDOVERLAYFX overlayFX; // overlay FX
HRESULT ddRVal; // return value
VOID* UpdateOverlay; // Unused: Win95 compatibility
} DD_UPDATEOVERLAYDATA;
/*
* structure for passing information to DDHAL UpdateOverlay fn
*/
typedef struct _DD_SETOVERLAYPOSITIONDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSrcSurface; // src surface
PDD_SURFACE_LOCAL lpDDDestSurface;// dest surface
LONG lXPos; // x position
LONG lYPos; // y position
HRESULT ddRVal; // return value
VOID* SetOverlayPosition; // Unused: Win95 compatibility
} DD_SETOVERLAYPOSITIONDATA;
/*
* structure for passing information to DDHAL SetPalette fn
*/
typedef struct _DD_SETPALETTEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
PDD_PALETTE_GLOBAL lpDDPalette; // palette to set to surface
HRESULT ddRVal; // return value
VOID* SetPalette; // Unused: Win95 compatibility
BOOL Attach; // attach this palette?
} DD_SETPALETTEDATA;
/*
* structure for passing information to DDHAL Flip fn
*/
typedef struct _DD_FLIPDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpSurfCurr; // current surface
PDD_SURFACE_LOCAL lpSurfTarg; // target surface (to flip to)
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
VOID* Flip; // Unused: Win95 compatibility
PDD_SURFACE_LOCAL lpSurfCurrLeft; // left target surface (to flip to)
PDD_SURFACE_LOCAL lpSurfTargLeft; // left target surface (to flip to)
} DD_FLIPDATA;
/*
* structure for passing information to DDHAL DestroySurface fn
*/
typedef struct _DD_DESTROYSURFACEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
HRESULT ddRVal; // return value
VOID* DestroySurface;// Unused: Win95 compatibility
} DD_DESTROYSURFACEDATA;
/*
* structure for passing information to DDHAL SetClipList fn
*/
typedef struct _DD_SETCLIPLISTDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
HRESULT ddRVal; // return value
VOID* SetClipList; // Unused: Win95 compatibility
} DD_SETCLIPLISTDATA;
/*
* structure for passing information to DDHAL AddAttachedSurface fn
*/
typedef struct _DD_ADDATTACHEDSURFACEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
PDD_SURFACE_LOCAL lpSurfAttached; // surface to attach
HRESULT ddRVal; // return value
VOID* AddAttachedSurface; // Unused: Win95 compatibility
} DD_ADDATTACHEDSURFACEDATA;
/*
* structure for passing information to DDHAL SetColorKey fn
*/
typedef struct _DD_SETCOLORKEYDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
DWORD dwFlags; // flags
DDCOLORKEY ckNew; // new color key
HRESULT ddRVal; // return value
VOID* SetColorKey; // Unused: Win95 compatibility
} DD_SETCOLORKEYDATA;
/*
* structure for passing information to DDHAL GetBltStatus fn
*/
typedef struct _DD_GETBLTSTATUSDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
VOID* GetBltStatus; // Unused: Win95 compatibility
} DD_GETBLTSTATUSDATA;
/*
* structure for passing information to DDHAL GetFlipStatus fn
*/
typedef struct _DD_GETFLIPSTATUSDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
VOID* GetFlipStatus; // Unused: Win95 compatibility
} DD_GETFLIPSTATUSDATA;
/****************************************************************************
*
* DDHAL structures for Palette Object callbacks
*
***************************************************************************/
/*
* structure for passing information to DDHAL DestroyPalette fn
*/
typedef struct _DD_DESTROYPALETTEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_PALETTE_GLOBAL lpDDPalette; // palette struct
HRESULT ddRVal; // return value
VOID* DestroyPalette; // Unused: Win95 compatibility
} DD_DESTROYPALETTEDATA;
/*
* structure for passing information to DDHAL SetEntries fn
*/
typedef struct _DD_SETENTRIESDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_PALETTE_GLOBAL lpDDPalette; // palette struct
DWORD dwBase; // base palette index
DWORD dwNumEntries; // number of palette entries
LPPALETTEENTRY lpEntries; // color table
HRESULT ddRVal; // return value
VOID* SetEntries; // Unused: Win95 compatibility
} DD_SETENTRIESDATA;
/****************************************************************************
*
* DDHAL structures for Driver Object callbacks
*
***************************************************************************/
typedef DDSURFACEDESC* PDD_SURFACEDESC;
/*
* structure for passing information to DDHAL CreateSurface fn
*/
typedef struct _DD_CREATESURFACEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACEDESC lpDDSurfaceDesc;// description of surface being created
PDD_SURFACE_LOCAL *lplpSList; // list of created surface objects
DWORD dwSCnt; // number of surfaces in SList
HRESULT ddRVal; // return value
VOID* CreateSurface; // Unused: Win95 compatibility
} DD_CREATESURFACEDATA;
/*
* structure for passing information to DDHAL CanCreateSurface fn
*/
typedef struct _DD_CANCREATESURFACEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACEDESC lpDDSurfaceDesc; // description of surface being created
DWORD bIsDifferentPixelFormat;// pixel format differs from primary surface
HRESULT ddRVal; // return value
VOID* CanCreateSurface; // Unused: Win95 compatibility
} DD_CANCREATESURFACEDATA;
/*
* structure for passing information to DDHAL CreatePalette fn
*/
typedef struct _DD_CREATEPALETTEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_PALETTE_GLOBAL lpDDPalette; // ddraw palette struct
LPPALETTEENTRY lpColorTable; // colors to go in palette
HRESULT ddRVal; // return value
VOID* CreatePalette; // Unused: Win95 compatibility
BOOL is_excl; // process has exclusive mode
} DD_CREATEPALETTEDATA;
/*
* Return if the vertical blank is in progress
*/
#define DDWAITVB_I_TESTVB 0x80000006l
/*
* structure for passing information to DDHAL WaitForVerticalBlank fn
*/
typedef struct _DD_WAITFORVERTICALBLANKDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
DWORD dwFlags; // flags
DWORD bIsInVB; // is in vertical blank
DWORD hEvent; // event
HRESULT ddRVal; // return value
VOID* WaitForVerticalBlank; // Unused: Win95 compatibility
} DD_WAITFORVERTICALBLANKDATA;
/*
* structure for passing information to DDHAL driver SetColorKey fn
*/
typedef struct _DD_DRVSETCOLORKEYDATA
{
PDD_SURFACE_LOCAL lpDDSurface; // surface struct
DWORD dwFlags; // flags
DDCOLORKEY ckNew; // new color key
HRESULT ddRVal; // return value
VOID* SetColorKey; // Unused: Win95 compatibility
} DD_DRVSETCOLORKEYDATA;
/*
* structure for passing information to DDHAL GetScanLine fn
*/
typedef struct _DD_GETSCANLINEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
DWORD dwScanLine; // returned scan line
HRESULT ddRVal; // return value
VOID* GetScanLine; // Unused: Win95 compatibility
} DD_GETSCANLINEDATA;
/*
* structure for passing information to DDHAL MapMemory fn
*/
typedef struct _DD_MAPMEMORYDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
BOOL bMap; // TRUE if map; FALSe if un-map
HANDLE hProcess; // process handle
FLATPTR fpProcess; // returned address in process' address space
HRESULT ddRVal; // return value
} DD_MAPMEMORYDATA;
/****************************************************************************
*
* DDHAL structures for VideoPort callbacks
*
***************************************************************************/
/*
* structure for passing information to DDHAL CanCreateVideoPort fn
*/
typedef struct _DD_CANCREATEVPORTDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
LPDDVIDEOPORTDESC lpDDVideoPortDesc;
HRESULT ddRVal; // return value
VOID* CanCreateVideoPort; // Unused: Win95 compatibility
} DD_CANCREATEVPORTDATA;
/*
* structure for passing information to DDHAL CreateVideoPort fn
*/
typedef struct _DD_CREATEVPORTDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
LPDDVIDEOPORTDESC lpDDVideoPortDesc;
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port created
HRESULT ddRVal; // return value
VOID* CreateVideoPort; // Unused: Win95 compatibility
} DD_CREATEVPORTDATA;
/*
* structure for passing information to DDHAL FlipVideoPort fn
*/
typedef struct _DD_FLIPVPORTDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
PDD_SURFACE_LOCAL lpSurfCurr; // current surface
PDD_SURFACE_LOCAL lpSurfTarg; // target surface
HRESULT ddRVal; // return value
VOID* FlipVideoPort; // Unused: Win95 compatibility
} DD_FLIPVPORTDATA;
/*
* structure for passing information to DDHAL GetVideoPortBandwidth fn
*/
typedef struct _DD_GETVPORTBANDWIDTHDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
LPDDPIXELFORMAT lpddpfFormat; // Format for bandwidth
DWORD dwWidth;
DWORD dwHeight;
DWORD dwFlags; // Prescale factor for bandwidth
LPDDVIDEOPORTBANDWIDTH lpBandwidth; // Returned bandwidth parameters
HRESULT ddRVal; // return value
VOID* GetVideoPortBandwidth; // Unused: Win95 compatibility
} DD_GETVPORTBANDWIDTHDATA;
/*
* structure for passing information to DDHAL GetVideoPortInputFormats fn
*/
typedef struct _DD_GETVPORTINPUTFORMATDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
DWORD dwFlags; // VBI, regular, or both
LPDDPIXELFORMAT lpddpfFormat; // Array of formats
DWORD dwNumFormats; // # of formats in array
HRESULT ddRVal; // return value
VOID* GetVideoPortInputFormats; // Unused: Win95 compatibility
} DD_GETVPORTINPUTFORMATDATA;
/*
* structure for passing information to DDHAL GetVideoPortOutputFormats fn
*/
typedef struct _DD_GETVPORTOUTPUTFORMATDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
DWORD dwFlags; // VBI, regular, or both
LPDDPIXELFORMAT lpddpfInputFormat; // Input format
LPDDPIXELFORMAT lpddpfOutputFormats; // Array of output formats
DWORD dwNumFormats; // # of formats in array
HRESULT ddRVal; // return value
VOID* GetVideoPortInputFormats; // Unused: Win95 compatibility
} DD_GETVPORTOUTPUTFORMATDATA;
/*
* structure for passing information to DDHAL GetVideoPortField fn
*/
typedef struct _DD_GETVPORTFIELDDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
BOOL bField; // TRUE if even
HRESULT ddRVal; // return value
VOID* GetVideoPortField; // Unused: Win95 compatibility
} DD_GETVPORTFIELDDATA;
/*
* structure for passing information to DDHAL GetVideoPortLine fn
*/
typedef struct _DD_GETVPORTLINEDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
DWORD dwLine; // Current line counter
HRESULT ddRVal; // return value
VOID* GetVideoPortLine; // Unused: Win95 compatibility
} DD_GETVPORTLINEDATA;
/*
* structure for passing information to DDHAL GetVideoPortConnectInfo fn
*/
typedef struct _DD_GETVPORTCONNECTDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
DWORD dwPortId; // ID of desired video port
LPDDVIDEOPORTCONNECT lpConnect; // Array of DDVIDEOPORTCONNECT structures
DWORD dwNumEntries; // # of structures in array
HRESULT ddRVal; // return value
VOID* GetVideoPortConnectInfo; // Unused: Win95 compatibility
} DD_GETVPORTCONNECTDATA;
/*
* structure for passing information to DDHAL DestroyVideoPort fn
*/
typedef struct _DD_DESTROYVPORTDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
HRESULT ddRVal; // return value
VOID* DestroyVideoPort; // Unused: Win95 compatibility
} DD_DESTROYVPORTDATA;
/*
* structure for passing information to DDHAL GetVideoPortFlipStatus fn
*/
typedef struct _DD_GETVPORTFLIPSTATUSDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
FLATPTR fpSurface; // surface struct
HRESULT ddRVal; // return value
VOID* GetVideoPortFlipStatus; // Unused: Win95 compatibility
} DD_GETVPORTFLIPSTATUSDATA;
typedef DDVIDEOPORTINFO* PDD_VIDEOPORTINFO;
/*
* structure for passing information to DDHAL UpdateVideoPort fn
*/
typedef struct _DD_UPDATEVPORTDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
PDD_SURFACE_INT *lplpDDSurface; // surface struct
PDD_SURFACE_INT *lplpDDVBISurface; // VBI surface structure
PDD_VIDEOPORTINFO lpVideoInfo; // Video information
DWORD dwFlags; // DDRAWI_VPORTSTART, DDRAWI_VPORTSTOP, DDRAWI_VPORTUPDATE
DWORD dwNumAutoflip; // # of autoflip surfaces. If > 1, lpDDSurface is an array.
DWORD dwNumVBIAutoflip; // # of autoflip surfaces. If > 1, lpDDVBISurface is an array.
HRESULT ddRVal; // return value
VOID* UpdateVideoPort; // Unused: Win95 compatibility
} DD_UPDATEVPORTDATA;
#define DDRAWI_VPORTSTART 0x0001
#define DDRAWI_VPORTSTOP 0x0002
#define DDRAWI_VPORTUPDATE 0x0003
/*
* structure for passing information to DDHAL WaitForVideoPortSync fn
*/
typedef struct _DD_WAITFORVPORTSYNCDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
DWORD dwFlags; // DDVPEVENT_XXXX
DWORD dwLine;
DWORD dwTimeOut; // Max time to wait before returning
HRESULT ddRVal; // return value
VOID* UpdateVideoPort; // Unused: Win95 compatibility
} DD_WAITFORVPORTSYNCDATA;
/*
* structure for passing information to DDHAL GetVideoSignalStatus fn
*/
typedef struct _DD_GETVPORTSIGNALDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
DWORD dwStatus; // Video signal status
HRESULT ddRVal; // return value
VOID* GetVideoSignalStatus; // Unused: Win95 compatibility
} DD_GETVPORTSIGNALDATA;
/*
* structure for passing information to DDHAL GetVideoSignalStatus fn
*/
typedef struct _DD_VPORTCOLORDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort; // Video port object
DWORD dwFlags; // Video signal status
LPDDCOLORCONTROL lpColorData;
HRESULT ddRVal; // return value
VOID* ColorControl; // Unused: Win95 compatibility
} DD_VPORTCOLORDATA;
#define DDRAWI_VPORTGETCOLOR 0x0001
#define DDRAWI_VPORTSETCOLOR 0x0002
/****************************************************************************
*
* DDHAL structures for Color Control callbacks
*
***************************************************************************/
/*
* structure for passing information to DDHAL ColorControl fn
*/
typedef struct _DD_COLORCONTROLDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface
LPDDCOLORCONTROL lpColorData; // color control information
DWORD dwFlags; // DDRAWI_GETCOLOR/DDRAWI_SETCOLOR
HRESULT ddRVal; // return value
VOID* ColorControl; // Unused: Win95 compatibility
} DD_COLORCONTROLDATA;
#define DDRAWI_GETCOLOR 0x0001
#define DDRAWI_SETCOLOR 0x0002
/****************************************************************************
*
* DDHAL structure for GetDriverData callback
*
***************************************************************************/
typedef struct _DD_GETDRIVERINFODATA {
// Input fields filled in by DirectDraw
VOID* dhpdev; // Driver context
DWORD dwSize; // Size of this structure
DWORD dwFlags; // Flags
GUID guidInfo; // GUID that DirectX is querying for
DWORD dwExpectedSize; // Size of callbacks structure expected by DirectDraw.
PVOID lpvData; // Buffer that will receive the requested data
// Output fields filled in by driver
DWORD dwActualSize; // Size of callbacks structure expected by driver
HRESULT ddRVal; // Return value from driver
} DD_GETDRIVERINFODATA;
/****************************************************************************
*
* DDHAL structure for misc. driver callbacks
*
***************************************************************************/
/*
* structure for passing information to DDHAL GetAvailDriverMemory fn
*/
typedef struct _DD_GETAVAILDRIVERMEMORYDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
DDSCAPS DDSCaps; // caps for type of surface memory
DWORD dwTotal; // total memory for this kind of surface
DWORD dwFree; // free memory for this kind of surface
HRESULT ddRVal; // return value
VOID* GetAvailDriverMemory; // Unused: Win95 compatibility
} DD_GETAVAILDRIVERMEMORYDATA;
/****************************************************************************
*
* DDHAL structures for NT callbacks
*
***************************************************************************/
/*
* structure for passing information to DDHAL FreeDriverMemory fn
*/
typedef struct _DD_FREEDRIVERMEMORYDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // surface object trying to be created
HRESULT ddRVal; // return value
VOID* FreeDriverMemory;// Unused: Win95 compatibility
} DD_FREEDRIVERMEMORYDATA;
/*
* structure for passing information to DDHAL SetExclusiveMode fn
*/
typedef struct _DD_SETEXCLUSIVEMODEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
DWORD dwEnterExcl; // TRUE if entering exclusive mode, FALSE is leaving
DWORD dwReserved; // reserved for future use
HRESULT ddRVal; // return value
VOID* SetExclusiveMode; // Unused: Win95 compatibility
} DD_SETEXCLUSIVEMODEDATA;
/*
* structure for passing information to DDHAL FlipToGDISurface fn
*/
typedef struct _DD_FLIPTOGDISURFACEDATA
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
DWORD dwToGDI; // TRUE if flipping to the GDI surface, FALSE if flipping away
DWORD dwReserved; // reserved for future use
HRESULT ddRVal; // return value
VOID* FlipToGDISurface; // Unused: Win95 compatibility
} DD_FLIPTOGDISURFACEDATA;
/****************************************************************************
*
* DDHAL structure for kernel callbacks
*
***************************************************************************/
/*
* structure for passing information to DDHAL SyncSurfaceData fn
*/
typedef struct _DD_SYNCSURFACEDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_SURFACE_LOCAL lpDDSurface; // Surface to sync with
DWORD dwSurfaceOffset; // Offset in frame buffer of surface
ULONG_PTR fpLockPtr; // Surface lock ptr
LONG lPitch; // Surface pitch
DWORD dwOverlayOffset; // Added to dwSurfaceOffset for origin, clipping, etc.
ULONG dwDriverReserved1; // Reserved for the HAL
ULONG dwDriverReserved2; // Reserved for the HAL
ULONG dwDriverReserved3; // Reserved for the HAL
ULONG dwDriverReserved4; // Reserved for the HAL
HRESULT ddRVal;
} DD_SYNCSURFACEDATA;
/*
* structure for passing information to DDHAL SyncVideoPortData fn
*/
typedef struct _DD_SYNCVIDEOPORTDATA
{
PDD_DIRECTDRAW_LOCAL lpDD; // driver struct
PDD_VIDEOPORT_LOCAL lpVideoPort;// Video port object
DWORD dwOriginOffset; // Start address relative to surface
DWORD dwHeight; // Height of total video region (per field)
DWORD dwVBIHeight; // Height of VBI region (per field)
ULONG dwDriverReserved1; // Reserved for the HAL
ULONG dwDriverReserved2; // Reserved for the HAL
ULONG dwDriverReserved3; // Reserved for the HAL
HRESULT ddRVal;
} DD_SYNCVIDEOPORTDATA;
/****************************************************************************
*
* DDHAL structure for motion comp callbacks
*
***************************************************************************/
/*
* structure for passing information to DDHAL GetMoCompGuids
*/
typedef struct _DD_GETMOCOMPGUIDSDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
DWORD dwNumGuids;
GUID* lpGuids;
HRESULT ddRVal;
} DD_GETMOCOMPGUIDSDATA;
/*
* structure for passing information to DDHAL GetMoCompFormats
*/
typedef struct _DD_GETMOCOMPFORMATSDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
GUID* lpGuid;
DWORD dwNumFormats;
LPDDPIXELFORMAT lpFormats;
HRESULT ddRVal;
} DD_GETMOCOMPFORMATSDATA;
/*
* structure for passing information to DDHAL CreateMoComp
*/
typedef struct _DD_CREATEMOCOMPDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
PDD_MOTIONCOMP_LOCAL lpMoComp;
GUID* lpGuid;
DWORD dwUncompWidth;
DWORD dwUncompHeight;
DDPIXELFORMAT ddUncompPixelFormat;
LPVOID lpData;
DWORD dwDataSize;
HRESULT ddRVal;
} DD_CREATEMOCOMPDATA;
/*
* structure for passing information to DDHAL GetMoCompBuffInfo
*/
typedef struct _DDCOMPBUFFERINFO
{
DWORD dwSize; // [in] size of the struct
DWORD dwNumCompBuffers; // [out] number of buffers required for compressed data
DWORD dwWidthToCreate; // [out] Width of surface to create
DWORD dwHeightToCreate; // [out] Height of surface to create
DWORD dwBytesToAllocate; // [out] Total number of bytes used by each surface
DDSCAPS2 ddCompCaps; // [out] caps to create surfaces to store compressed data
DDPIXELFORMAT ddPixelFormat; // [out] format to create surfaces to store compressed data
} DDCOMPBUFFERINFO, *LPDDCOMPBUFFERINFO;
typedef struct _DD_GETMOCOMPCOMPBUFFDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
GUID* lpGuid;
DWORD dwWidth; // [in] width of uncompressed data
DWORD dwHeight; // [in] height of uncompressed data
DDPIXELFORMAT ddPixelFormat; // [in] pixel-format of uncompressed data
DWORD dwNumTypesCompBuffs;// [in/out] number of memory types required for comp buffers
LPDDCOMPBUFFERINFO lpCompBuffInfo; // [in] driver supplied info regarding comp buffers (allocated by client)
HRESULT ddRVal; // [out]
} DD_GETMOCOMPCOMPBUFFDATA;
/*
* structure for passing information to DDHAL GetMoCompBuffInfo
*/
typedef struct _DD_GETINTERNALMOCOMPDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
GUID* lpGuid;
DWORD dwWidth; // [in] width of uncompressed data
DWORD dwHeight; // [in] height of uncompressed data
DDPIXELFORMAT ddPixelFormat; // [in] pixel-format of uncompressed data
DWORD dwScratchMemAlloc; // [out] amount of scratch memory will the hal allocate for its private use
HRESULT ddRVal; // [out]
} DD_GETINTERNALMOCOMPDATA;
/*
* structure for passing information to DDHAL BeginMoCompFrame
*/
typedef struct _DD_BEGINMOCOMPFRAMEDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
PDD_MOTIONCOMP_LOCAL lpMoComp;
PDD_SURFACE_LOCAL lpDestSurface; // [in] destination buffer in which to decoding this frame
DWORD dwInputDataSize; // [in] size of other misc input data to begin frame
LPVOID lpInputData; // [in] pointer to misc input data
DWORD dwOutputDataSize; // [in] size of other misc output data to begin frame
LPVOID lpOutputData; // [in] pointer to output misc data (allocated by client)
HRESULT ddRVal; // [out]
} DD_BEGINMOCOMPFRAMEDATA;
/*
* structure for passing information to DDHAL EndMoCompFrame
*/
typedef struct _DD_ENDMOCOMPFRAMEDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
PDD_MOTIONCOMP_LOCAL lpMoComp;
LPVOID lpInputData;
DWORD dwInputDataSize;
HRESULT ddRVal;
} DD_ENDMOCOMPFRAMEDATA;
/*
* structure for passing information to DDHAL RenderMoComp
*/
typedef struct _DDMOCOMPBUFFERINFO
{
DWORD dwSize; // [in] size of the struct
PDD_SURFACE_LOCAL lpCompSurface; // [in] pointer to buffer containing compressed data
DWORD dwDataOffset; // [in] offset of relevant data from the beginning of buffer
DWORD dwDataSize; // [in] size of relevant data
LPVOID lpPrivate; // Reserved by DirectDraw
} DDMOCOMPBUFFERINFO, *LPDDMOCOMPBUFFERINFO;
typedef struct _DD_RENDERMOCOMPDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
PDD_MOTIONCOMP_LOCAL lpMoComp;
DWORD dwNumBuffers; // [in] Number of entries in the lpMacroBlockInfo array
LPDDMOCOMPBUFFERINFO lpBufferInfo; // [in] Surfaces containing macro block info
DWORD dwFunction; // [in] Function
LPVOID lpInputData;
DWORD dwInputDataSize;
LPVOID lpOutputData;
DWORD dwOutputDataSize;
HRESULT ddRVal; // [out]
} DD_RENDERMOCOMPDATA;
/*
* structure for passing information to DDHAL QueryMoCompStatus
*/
typedef struct _DD_QUERYMOCOMPSTATUSDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
PDD_MOTIONCOMP_LOCAL lpMoComp;
PDD_SURFACE_LOCAL lpSurface; // [in] Surface being queried
DWORD dwFlags; // [in] DDMCQUERY_XXX flags
HRESULT ddRVal; // [out]
} DD_QUERYMOCOMPSTATUSDATA;
#define DDMCQUERY_READ 0x00000001
/*
* structure for passing information to DDHAL DestroyVideo
*/
typedef struct _DD_DESTROYMOCOMPDATA
{
PDD_DIRECTDRAW_LOCAL lpDD;
PDD_MOTIONCOMP_LOCAL lpMoComp;
HRESULT ddRVal;
} DD_DESTROYMOCOMPDATA;
/****************************************************************************
*
* DDHAL structures for Miscellaneous2 callbacks
*
***************************************************************************/
// This DDI is called by the kernel only.
typedef struct _DD_CREATESURFACEEXDATA
{
DWORD dwFlags;
PDD_DIRECTDRAW_LOCAL lpDDLcl; // driver struct
PDD_SURFACE_LOCAL lpDDSLcl; // created surface
// objects
HRESULT ddRVal; // return value
} DD_CREATESURFACEEXDATA;
// This DDI is used by both ddraw and d3d to obtain information from
// the driver.
typedef struct _DD_GETDRIVERSTATEDATA
{
DWORD dwFlags; // Flags to indicate the data
// required
union
{
PDD_DIRECTDRAW_GLOBAL lpDD; // driver struct
DWORD_PTR dwhContext; // d3d context
};
LPDWORD lpdwStates; // ptr to the state data
// to be filled in by the
// driver
DWORD dwLength;
HRESULT ddRVal; // return value
} DD_GETDRIVERSTATEDATA;
typedef struct _DD_DESTROYDDLOCALDATA
{
DWORD dwFlags;
PDD_DIRECTDRAW_LOCAL pDDLcl;
HRESULT ddRVal;
} DD_DESTROYDDLOCALDATA;
#ifdef __cplusplus
};
#endif
#endif // GUID_DEFS_ONLY
#endif
Reference in a new issue View git blame Copy permalink