windows mobile DDraw.h for FPC , but need help [Archive]

LYH1

30-12-2008, 02:45 PM

Direct Draw Header I use for above code, I dont know if somethings wrong or not

// This ddraw unit is for windows mobile 5 or above
unit ddraw;
interface
uses windows;

//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
{================================================= =========================;
*
* File: ddraw.h
* Content: DirectDraw include file
*
************************************************** ************************ }
const
IID_IDirectDraw: TGUID = '{9C59509A-39BD-11D1-8C4A-00C04FD930C5}';
IID_IDirectDrawSurface: TGUID = '{0b0e83e4-f37f-11d2-8b15-00c04F689292}';
IID_IDirectDrawPalette: TGUID = '{6C14DB84-A733-11CE-A521-0020AF0BE560}';
IID_IDirectDrawClipper: TGUID = '{6C14DB85-A733-11CE-A521-0020AF0BE560}';
IID_IDirectDrawColorControl: TGUID = '{4B9F0EE0-0D7E-11D0-9B06-00A0C903A3B8}';
IID_IDirectDrawGammaControl: TGUID = '{69C11C3E-B46B-11D1-AD7A-00C04FC29B4E}';

type
IDirectDraw = interface;
IDirectDrawSurface = interface;
IDirectDrawPalette = interface;
IDirectDrawClipper = interface;
IDirectDrawColorControl = interface;
IDirectDrawGammaControl = interface;

//
// DirectDraw Structures
//

//
// DDCOLORKEY
//

PDDCOLORKEY = ^TDDCOLORKEY;
TDDCOLORKEY = record
dwColorSpaceLowValue : DWORD;{ low boundary of color space that is to }
{ be treated as Color Key, inclusive }
dwColorSpaceHighValue : DWORD; { high boundary of color space that is }
{ to be treated as Color Key, inclusive }
end;
DDCOLORKEY = TDDCOLORKEY;
LPDDCOLORKEY = PDDCOLORKEY;
//
// DDARGB
// Generic pixel format with 8-bit RGB and alpha components
//

PDDARGB = ^TDDARGB;
TDDARGB = record
blue : BYTE;
green : BYTE;
red : BYTE;
alpha : BYTE;
end;
DDARGB = TDDARGB;
LPDDARGB = PDDARGB;

//
// DDBLTFX
//
PDDBLTFX = ^TDDBLTFX;
TDDBLTFX = record
dwSize : DWORD;{ size of structure }
dwROP : DWORD;{ Win32 raster operations }
dwFillColor : DWORD; { color in RGB or Palettized (Brush value for Win32 ROPs) }
ddckDestColorkey : TDDCOLORKEY; { DestColorkey override }
ddckSrcColorkey : TDDCOLORKEY;{ SrcColorkey override }
end;
DDBLTFX = TDDBltFX;
LPDDBLTFX = PDDBltFX;

//
// DDALPHABLTFX
//
PDDALPHABLTFX = ^TDDALPHABLTFX;
TDDALPHABLTFX = record
dwSize : DWORD;{ size of structure }
ddargbScaleFactors : TDDARGB;{ Constant scaling factors }
dwFillColor : DWORD;{ color in ARGB or Palettized }
end;
DDALPHABLTFX = TDDALPHABLTFX;
LPDDALPHABLTFX = PDDALPHABLTFX;

//
// DDSCAPS
// Caps bits defined below.
//
PDDSCaps = ^TDDSCaps;
TDDSCaps = record
dwCaps: DWORD; // capabilities of surface wanted
end;

DDSCAPS = TDDSCaps;
LPDDSCAPS = PDDSCaps;

//
// DDCAPS
//
const
DD_ROP_SPACE = 256 div 32; { space required to store ROP array }

type
PDDCAPS = ^TDDCAPS;
TDDCAPS = record
dwSize : DWORD; { size of the DDCAPS structure }
{ Surface capabilities }
dwVidMemTotal : DWORD;{ total amount of video memory }
dwVidMemFree : DWORD; { amount of free video memory }
dwVidMemStride : DWORD;{ video memory stride (0 if linear) }
ddsCaps : TDDSCAPS;{ surface caps }
dwNumFourCCCodes : DWORD; { number of four cc codes }
{ palette capabilities }
dwPalCaps : DWORD;{ Palette capabilities }

{ Hardware blitting capabilities }
dwBltCaps : DWORD; { driver specific capabilities }
dwCKeyCaps : DWORD;{ color key blitting capabilities }
dwAlphaCaps : DWORD;{ alpha blitting capabilities }
dwRops : array[0..(DD_ROP_SPACE)-1] of DWORD;{ ROPS supported }

{ general overlay capabilities. }
dwOverlayCaps : DWORD;{ Overlay capabilities }
dwMaxVisibleOverlays : DWORD;{ maximum number of visible overlays }
dwCurrVisibleOverlays : DWORD;{ current number of visible overlays }

dwAlignBoundarySrc : DWORD; { source rectangle alignment }
dwAlignSizeSrc : DWORD;{ source rectangle byte size }
dwAlignBoundaryDest : DWORD;{ dest rectangle alignment }
dwAlignSizeDest : DWORD; { dest rectangle byte size }

dwMinOverlayStretch : DWORD;{ minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 }
dwMaxOverlayStretch : DWORD;{ maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 }

{ Miscalenous capabilies }
dwMiscCaps : DWORD;
end;
DDCAPS = TDDCAPS;
LPDDCAPS = PDDCAPS;

//
// DDPIXELFORMAT
//
type
PDDPixelFormat = ^TDDPixelFormat;
TDDPixelFormat = record
dwSize: DWORD; // size of structure
dwFlags: DWORD; // pixel format flags
dwFourCC: DWORD; // (FOURCC code)
case Integer of
0: (
dwRGBBitCount: DWORD; // how many bits per pixel
dwYUVBitCount: DWORD; // how many bits per pixel
dwAlphaBitDepth: DWORD; // how many bits for alpha channels
);
1: (
dwRBitMask : DWORD; // mask for red bit
dwYBitMask : DWORD ; // mask for Y bits
);
2: (
dwGBitMask : DWORD; // mask for green bits
dwUBitMask : DWORD; // mask for U bits
);
3: (
dwBBitMask : DWORD; // mask for blue bits
dwVBitMask : DWORD; // mask for V bits
);
4: (
dwRGBAlphaBitMask : DWORD; // mask for alpha channel
);
end;
DDPIXELFORMAT = TDDPixelFormat;
LPDDPIXELFORMAT = PDDPixelFormat;

const
DDPF_ALPHAPIXELS = $00000001;
DDPF_ALPHA = $00000002;
DDPF_FOURCC = $00000004;
DDPF_PALETTEINDEXED = $00000020;
DDPF_RGB = $00000040;
DDPF_ALPHAPREMULT = $00008000;
DDPF_VALID = DDPF_ALPHAPIXELS or DDPF_ALPHA or
DDPF_FOURCC or DDPF_PALETTEINDEXED or
DDPF_RGB or DDPF_ALPHAPREMULT;

{DDSURFACEDESC}
type
PDDSurfaceDesc = ^TDDSurfaceDesc;
TDDSurfaceDesc = record
dwSize : DWORD; // size of the DDSURFACEDESC structure
dwFlags : DWORD; // determines what fields are valid
dwHeight : DWORD; // height of surface to be created
dwWidth : DWORD; // width of input surface
lPitch : LONGint; // bytes to next line down (return value only)
lXPitch : LONGint; // bytes to next pixel right (return value only)
dwBackBufferCount : DWORD; // number of back buffers requested
dwRefreshRate : DWORD; // refresh rate (used when display mode is described)
lpSurface : pointer; // pointer to the associated surface memory
ddckCKDestOverlay : DDCOLORKEY; // color key for destination overlay use
ddckCKDestBlt : DDCOLORKEY; // color key for destination blt use
ddckCKSrcOverlay : DDCOLORKEY; // color key for source overlay use
ddckCKSrcBlt : DDCOLORKEY; // color key for source blt use
ddpfPixelFormat : DDPIXELFORMAT; // pixel format description of the surface
ddsCaps : TDDSCAPS; // direct draw surface capabilities
dwSurfaceSize : DWORD; // Surface size, in bytes
end;
DDSURFACEDESC = TDDSurfaceDesc;
LPDDSURFACEDESC = PDDSurfaceDesc;

{
* DDSURFACEDESC dwFlags values.
}

const
DDSD_CAPS = $00000001;
DDSD_HEIGHT = $00000002;
DDSD_WIDTH = $00000004;
DDSD_PITCH = $00000008;
DDSD_XPITCH = $00000010;
DDSD_BACKBUFFERCOUNT = $00000020;
DDSD_LPSURFACE = $00000800;
DDSD_PIXELFORMAT = $00001000;
DDSD_CKDESTOVERLAY = $00002000;
DDSD_CKDESTBLT = $00004000;
DDSD_CKSRCOVERLAY = $00008000;
DDSD_CKSRCBLT = $00010000;
DDSD_REFRESHRATE = $00040000;
DDSD_SURFACESIZE = $00080000;
DDSD_VALID = DDSD_CAPS or DDSD_HEIGHT or
DDSD_WIDTH or DDSD_PITCH or
DDSD_XPITCH or DDSD_BACKBUFFERCOUNT or
DDSD_LPSURFACE or DDSD_PIXELFORMAT or
DDSD_CKDESTOVERLAY or DDSD_CKDESTBLT or
DDSD_CKSRCOVERLAY or DDSD_CKSRCBLT or
DDSD_REFRESHRATE or DDSD_SURFACESIZE;
DDSD_ENUM_VALID = DDSD_CAPS or DDSD_HEIGHT or DDSD_WIDTH or DDSD_PIXELFORMAT;

//
//DDOVERLAYFX
//
type
PDDOVERLAYFX = ^TDDOVERLAYFX;
TDDOVERLAYFX = record
dwSize : DWORD;{ size of structure }

dwAlphaConstBitDepth : DWORD;{ Bit depth used to specify alpha constant. }
dwAlphaConst : DWORD; { Constant to use as alpha channel. }

dckDestColorkey : TDDCOLORKEY;{ DestColorkey override }
dckSrcColorkey : TDDCOLORKEY;{ DestColorkey override }
end;
DDOVERLAYFX = TDDOVERLAYFX;
LPDDOVERLAYFX = PDDOVERLAYFX;
//
// DDGAMMARAMP
//

PDDGAMMARAMP = ^TDDGAMMARAMP;
TDDGAMMARAMP = record
red : array[0..255] of WORD;
green : array[0..255] of WORD;
blue : array[0..255] of WORD;
end;
DDGAMMARAMP = TDDGAMMARAMP;
LPDDGAMMARAMP = PDDGAMMARAMP;

//
// This is the structure within which DirectDraw returns data about the current graphics driver and chipset
//

const
MAX_DDDEVICEID_STRING = 512;

type
PDDDEVICEIDENTIFIER = ^TDDDEVICEIDENTIFIER;
TDDDEVICEIDENTIFIER = record

// * These elements are for presentation to the user only. They should not be used to identify particular
// * drivers, since this is unreliable and many different strings may be associated with the same
// * device, and the same driver from different vendors.
szDriver : array[0..(MAX_DDDEVICEID_STRING)-1] of wchar;
szDescription : array[0..(MAX_DDDEVICEID_STRING)-1] of wchar;
{
* This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons
* on the whole 64 bits. Caution should be exercised if you use this element to identify problematic
* drivers. It is recommended that guidDeviceIdentifier is used for this purpose.
*
* This version has the form:
* wProduct = HIWORD(liDriverVersion.HighPart)
* wVersion = LOWORD(liDriverVersion.HighPart)
* wSubVersion = HIWORD(liDriverVersion.LowPart)
* wBuild = LOWORD(liDriverVersion.LowPart)
}
liDriverVersion : LARGE_INTEGER;
{
* These elements can be used to identify particular chipsets. Use with extreme caution.
* dwVendorId Identifies the manufacturer. May be zero if unknown.
* dwDeviceId Identifies the type of chipset. May be zero if unknown.
* dwSubSysId Identifies the subsystem, typically this means the particular board. May be zero if unknown.
* dwRevision Identifies the revision level of the chipset. May be zero if unknown.
}
dwVendorId : DWORD;
dwDeviceId : DWORD;
dwSubSysId : DWORD;
dwRevision : DWORD;
{
* This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the
* driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to
* reprofile the graphics subsystem.
* This element can also be used to identify particular problematic drivers.
}
guidDeviceIdentifier : TGUID;
end;
DDDEVICEIDENTIFIER = TDDDEVICEIDENTIFIER;
LPDDDEVICEIDENTIFIER = PDDDEVICEIDENTIFIER;

//
// DDCOLORCONTROL
//
type
PDDColorControl = ^TDDColorControl;
TDDColorControl = record
dwSize: DWORD;
dwFlags: DWORD;
lBrightness: Longint;
lContrast: Longint;
lHue: Longint;
lSaturation: Longint;
lSharpness: Longint;
lGamma: Longint;
lColorEnable: Longint;
end;

DDCOLORCONTROL = TDDColorControl;
LPDDCOLORCONTROL = PDDCOLORCONTROL;

//
// DDCOLORCONTROL dwFlags values.
//
const
DDCOLOR_BRIGHTNESS = $00000001;
DDCOLOR_CONTRAST = $00000002;
DDCOLOR_HUE = $00000004;
DDCOLOR_SATURATION = $00000008;
DDCOLOR_SHARPNESS = $00000010;
DDCOLOR_GAMMA = $00000020;
DDCOLOR_COLORENABLE = $00000040;
DDCOLOR_VALID = DDCOLOR_BRIGHTNESS or DDCOLOR_CONTRAST or DDCOLOR_HUE or DDCOLOR_SATURATION or DDCOLOR_SHARPNESS or DDCOLOR_GAMMA or DDCOLOR_COLORENABLE;
//
// API's
//

type TDDENUMCALLBACKEX = function(lpGUID: PGUID; lpDriverDescription: LPWSTR;
lpDriverName: LPWSTR; lpContext: Pointer; Monitor: HMonitor): BOOL; stdcall;

function DirectDrawEnumerateEx(lpCallback:TDDENUMCALLBACKEX ; lpContext:Pointer; dwFlags:DWORD):HRESULT;stdcall; external 'DDraw.dll';
function DirectDrawCreate(lpGUID: PGUID; out lplpDD: IDirectDraw; pUnkOuter: IUnknown): HResult; stdcall; external 'DDraw.dll';
function DirectDrawCreateClipper(dwFlags: DWORD; out lplpDDClipper: IDirectDrawClipper; pUnkOuter: IUnknown): HResult; stdcall;external 'DDraw.dll';

//
// DirectDrawEnumerateEx Flags
//

// * This flag causes enumeration of any GDI display devices which are part of
// * the Windows Desktop

const
DDENUM_ATTACHEDSECONDARYDEVICES = $00000001;

// * This flag causes enumeration of any GDI display devices which are not
// * part of the Windows Desktop

DDENUM_DETACHEDSECONDARYDEVICES = $00000002;
DDENUM_VALID = DDENUM_ATTACHEDSECONDARYDEVICES or DDENUM_DETACHEDSECONDARYDEVICES;

// Enumeration function pointer types
type TDDEnumModesCallback = function(const lpDDSurfaceDesc: TDDSurfaceDesc; lpContext: Pointer): HResult; stdcall;
type LPDDENUMMODESCALLBACK = TDDEnumModesCallback;

type TDDEnumSurfacesCallback = function(lpDDSurface: IDirectDrawSurface; const lpDDSurfaceDesc: TDDSurfaceDesc; lpContext: Pointer): HResult; stdcall;
type LPDDENUMSURFACESCALLBACK = TDDEnumSurfacesCallback;

//
// IDirectDraw
//
type
IDirectDraw = interface(IUnknown)
['{9C59509A-39BD-11D1-8C4A-00C04FD930C5}']
// IDirectDraw methods
function CreateClipper(dwFlags: DWORD; out lplpDDClipper: IDirectDrawClipper;
pUnkOuter: IUnknown): HResult; stdcall;
function CreatePalette(dwFlags: DWORD; lpColorTable: PPaletteEntry;
out lplpDDPalette: IDirectDrawPalette; pUnkOuter: IUnknown): HResult; stdcall;
function CreateSurface(const lpDDSurfaceDesc: TDDSurfaceDesc;
out lplpDDSurface: IDirectDrawSurface; pUnkOuter: IUnknown): HResult; stdcall;
function EnumDisplayModes(dwFlags: DWORD;
const lpDDSurfaceDesc: TDDSurfaceDesc; lpContext: Pointer;
lpEnumModesCallback: TDDEnumModesCallback): HResult; stdcall;
function EnumSurfaces(dwFlags: DWORD; const lpDDSD: TDDSurfaceDesc;
lpContext: Pointer; lpEnumCallback: TDDEnumSurfacesCallback): HResult; stdcall;
function FlipToGDISurface: HResult; stdcall;
function GetCaps(var lpDDDriverCaps: TDDCaps; var lpDDHELCaps: TDDCaps): HResult; stdcall;
function GetDisplayMode(var lpDDSurfaceDesc: TDDSurfaceDesc): HResult; stdcall;
function GetFourCCCodes(var lpNumCodes, lpCodes: DWORD): HResult; stdcall;
function GetGDISurface(out lplpGDIDDSSurface: IDirectDrawSurface): HResult; stdcall;
function GetMonitorFrequency(var lpdwFrequency: DWORD): HResult; stdcall;
function GetScanLine(var lpdwScanLine: DWORD): HResult; stdcall;
function GetVerticalBlankStatus(var lpbIsInVB: BOOL): HResult; stdcall;
function RestoreDisplayMode: HResult; stdcall;
function SetCooperativeLevel(hWnd: HWND; dwFlags: DWORD): HResult; stdcall;
function SetDisplayMode(dwWidth, dwHeight, dwBpp: DWORD): HResult; stdcall;
function WaitForVerticalBlank(dwFlags: DWORD; hEvent: THandle): HResult; stdcall;
function GetAvailableVidMem(var lpDDSCaps: TDDSCaps;
var lpdwTotal, lpdwFree: DWORD): HResult; stdcall;
function GetSurfaceFromDC(hdc: HDC; lpDDS: IDirectDrawSurface): HResult; stdcall;
function RestoreAllSurfaces: HResult; stdcall;
function TestCooperativeLevel: HResult; stdcall;
function GetDeviceIdentifier(var lpdddi: TDDDeviceIdentifier; dwFlags: DWORD): HResult; stdcall;
end;

{ IDirectDrawPalette Interface }

IDirectDrawPalette = interface(IUnknown)
['{6C14DB84-A733-11CE-A521-0020AF0BE560}']
// IDirectDrawPalette methods
function GetCaps(varlpdwCaps: DWORD): HResult; stdcall;
function GetEntries(dwFlags: DWORD; dwBase: DWORD; dwNumEntries: DWORD;
lpEntries: PPaletteEntry): HResult; stdcall;
function SetEntries(dwFlags: DWORD; dwStartingEntry: DWORD;
dwCount: DWORD; lpEntries: PPaletteEntry): HResult; stdcall;
end;

{IDirectDrawClipper}

IDirectDrawClipper = interface(IUnknown)
['{6C14DB85-A733-11CE-A521-0020AF0BE560}']
// IDirectDrawClipper methods
function GetClipList(const lpRect: TRect; lpClipList: PRgnData;
var lpdwSize: DWORD): HResult; stdcall;
function GetHWnd(var lphWnd: HWND): HResult; stdcall;
function IsClipListChanged(var lpbChanged: BOOL): HResult; stdcall;
function SetClipList(lpClipList: PRgnData; dwFlags: DWORD): HResult; stdcall;
function SetHWnd(dwFlags: DWORD; hWnd: HWND): HResult; stdcall;
end;

{IDirectDrawSurface}
IDirectDrawSurface = interface(IUnknown)
['{0b0e83e4-f37f-11d2-8b15-00c04F689292}']
// IDirectDrawSurface methods
function AddOverlayDirtyRect(const lpRect: TRect): HResult; stdcall;
function Blt(const lpDestRect: TRect; lpDDSrcSurface: IDirectDrawSurface;
const lpSrcRect: TRect; dwFlags: DWORD; const lpDDBltFx: TDDBltFX): HResult; stdcall;
function EnumAttachedSurfaces(lpContext: Pointer;
lpEnumSurfacesCallback: TDDEnumSurfacesCallback): HResult; stdcall;
function EnumOverlayZOrders(dwFlags: DWORD; lpContext: Pointer;
lpfnCallback: TDDEnumSurfacesCallback): HResult; stdcall;
function Flip(lpDDSurfaceTargetOverride: IDirectDrawSurface;
dwFlags: DWORD): HResult; stdcall;
function GetBltStatus(dwFlags: DWORD): HResult; stdcall;
function GetCaps(var lpDDSCaps: TDDSCaps): HResult; stdcall;
function GetClipper(out lplpDDClipper: IDirectDrawClipper): HResult; stdcall;
function GetColorKey(dwFlags: DWORD; var lpDDColorKey: TDDColorKey): HResult; stdcall;
function GetDC(var lphDC: HDC): HResult; stdcall;
function GetFlipStatus(dwFlags: DWORD): HResult; stdcall;
function GetOverlayPosition(var lplX, lplY: Longint): HResult; stdcall;
function GetPalette(out lplpDDPalette: IDirectDrawPalette): HResult; stdcall;
function GetPixelFormat(var lpDDPixelFormat: TDDPixelFormat): HResult; stdcall;
function GetSurfaceDesc(var lpDDSurfaceDesc: TDDSurfaceDesc): HResult; stdcall;
function IsLost: HResult; stdcall;
function Lock(lpDestRect: PRect; const lpDDSurfaceDesc: TDDSurfaceDesc;
dwFlags: DWORD; hEvent: THandle): HResult; stdcall;
function ReleaseDC(hDC: HDC): HResult; stdcall;
function Restore: HResult; stdcall;
function SetClipper(lpDDClipper: IDirectDrawClipper): HResult; stdcall;
function SetColorKey(dwFlags: DWORD; const lpDDColorKey: TDDColorKey): HResult; stdcall;
function SetOverlayPosition(lX, lY: Longint): HResult; stdcall;
function SetPalette(lpDDPalette: IDirectDrawPalette): HResult; stdcall;
function Unlock(lpSurfaceData: Pointer): HResult; stdcall;
function UpdateOverlay(const lpSrcRect: TRect; lpDDDestSurface: IDirectDrawSurface;
const lpDestRect: TRect; dwFlags: DWORD; const lpDDOverlayFx: TDDOverlayFX): HResult; stdcall;
function UpdateOverlayZOrder(dwFlags: DWORD; lpDDSReference: IDirectDrawSurface): HResult; stdcall;
function GetDDInterface(out lplpDD: IUnknown): HResult; stdcall;
function AlphaBlt (const lpDestRect: TRect; lpDDSrcSurface: IDirectDrawSurface;
const lpSrcRect: TRect; dwFlags: DWORD; const lpDDAlphaBltFx: TDDALPHABLTFX): HResult; stdcall;
end;

{ IDirectDrawColorControl}

IDirectDrawColorControl = interface(IUnknown)
['{4B9F0EE0-0D7E-11D0-9B06-00A0C903A3B8}']
// IDirectDrawColorControl methods
function GetColorControls(var lpColorControl: TDDColorControl): HResult; stdcall;
function SetColorControls(const lpColorControl: TDDColorControl): HResult; stdcall;
end;

{ IDirectDrawGammaControl}

IDirectDrawGammaControl = interface(IUnknown)
['{69C11C3E-B46B-11D1-AD7A-00C04FC29B4E}']
// IDirectDrawGammaControl methods
function GetGammaRamp(dwFlags: DWORD; var lpRampData: TDDGammaRamp): HResult; stdcall;
function SetGammaRamp(dwFlags: DWORD; const lpRampData: TDDGammaRamp): HResult; stdcall;
end;

{ DirectDraw Macros }

function MAKEFOURCC(ch0, ch1, ch2, ch3: Char) : DWORD;

// * Direct Draw Capability Flags

// * Surface Capability Flags
const
DDSCAPS_ALPHA = $00000001;
DDSCAPS_BACKBUFFER = $00000002;
DDSCAPS_FLIP = $00000004;
DDSCAPS_FRONTBUFFER = $00000008;
DDSCAPS_OVERLAY = $00000010;
DDSCAPS_PALETTE = $00000020;
DDSCAPS_PRIMARYSURFACE = $00000040;
DDSCAPS_SYSTEMMEMORY = $00000080;
DDSCAPS_VIDEOMEMORY = $00000100;
DDSCAPS_WRITEONLY = $00000200;
DDSCAPS_READONLY = $00000800;
DDSCAPS_NOTUSERLOCKABLE = $00002000;
DDSCAPS_DYNAMIC = $00004000;
DDSCAPS_VALID = DDSCAPS_ALPHA or DDSCAPS_BACKBUFFER or
DDSCAPS_FLIP or DDSCAPS_FRONTBUFFER or
DDSCAPS_OVERLAY or DDSCAPS_PALETTE or
DDSCAPS_PRIMARYSURFACE or DDSCAPS_SYSTEMMEMORY or
DDSCAPS_VIDEOMEMORY or DDSCAPS_WRITEONLY or
DDSCAPS_READONLY or DDSCAPS_NOTUSERLOCKABLE or
DDSCAPS_DYNAMIC;

// * Palette Capability Flags

DDPCAPS_PRIMARYSURFACE = $00000010;
DDPCAPS_ALPHA = $00000400;
DDPCAPS_VALID = DDPCAPS_PRIMARYSURFACE or DDPCAPS_ALPHA;

// * DirectDraw Capability Flags

// * General hardware blitting capabilities (For DDCAPS dwBltCaps field)
DDBLTCAPS_READSYSMEM = $00000001;
DDBLTCAPS_WRITESYSMEM = $00000002;
DDBLTCAPS_FOURCCTORGB = $00000004;
DDBLTCAPS_COPYFOURCC = $00000008;
DDBLTCAPS_FILLFOURCC = $00000010;
DDBLTCAPS_VALID = (((DDBLTCAPS_READSYSMEM or DDBLTCAPS_WRITESYSMEM) or DDBLTCAPS_FOURCCTORGB) or DDBLTCAPS_COPYFOURCC) or DDBLTCAPS_FILLFOURCC;

// * Hardware color key blitting capabilities (For DDCAPS dwCKeyCaps field)
DDCKEYCAPS_DESTBLT = $00000001;
DDCKEYCAPS_DESTBLTCLRSPACE = $00000002;
DDCKEYCAPS_DESTBLTCLRSPACEYUV = $00000004;
DDCKEYCAPS_SRCBLT = $00000200;
DDCKEYCAPS_SRCBLTCLRSPACE = $00000400;
DDCKEYCAPS_SRCBLTCLRSPACEYUV = $00000800;
DDCKEYCAPS_BOTHBLT = $00001000;
DDCKEYCAPS_VALID = (((((DDCKEYCAPS_DESTBLT or DDCKEYCAPS_DESTBLTCLRSPACE) or DDCKEYCAPS_DESTBLTCLRSPACEYUV) or DDCKEYCAPS_SRCBLT) or DDCKEYCAPS_SRCBLTCLRSPACE) or DDCKEYCAPS_SRCBLTCLRSPACEYUV) or DDCKEYCAPS_BOTHBLT;

// * Hardware alpha blitting capabilities (For DDCAPS dwAlphaCaps field)
DDALPHACAPS_ALPHAPIXELS = $00000001;
DDALPHACAPS_ALPHASURFACE = $00000002;
DDALPHACAPS_ALPHAPALETTE = $00000004;
DDALPHACAPS_ALPHACONSTANT = $00000008;
DDALPHACAPS_ARGBSCALE = $00000010;
DDALPHACAPS_SATURATE = $00000020;
DDALPHACAPS_PREMULT = $00000040;
DDALPHACAPS_NONPREMULT = $00000080;
DDALPHACAPS_ALPHAFILL = $00000800;
DDALPHACAPS_ALPHANEG = $00000100;
DDALPHACAPS_VALID = DDALPHACAPS_ALPHAPIXELS or DDALPHACAPS_ALPHASURFACE or
DDALPHACAPS_ALPHAPALETTE or DDALPHACAPS_ALPHACONSTANT or
DDALPHACAPS_ARGBSCALE or DDALPHACAPS_SATURATE or
DDALPHACAPS_PREMULT or DDALPHACAPS_NONPREMULT or
DDALPHACAPS_ALPHAFILL or DDALPHACAPS_ALPHANEG;

// * Overlay capabilities ( For DDCAPS dwOverlayCaps field)
DDOVERLAYCAPS_FLIP = $00000001;
DDOVERLAYCAPS_FOURCC = $00000004;
DDOVERLAYCAPS_ZORDER = $00000008;
DDOVERLAYCAPS_MIRRORLEFTRIGHT = $00000010;
DDOVERLAYCAPS_MIRRORUPDOWN = $00000020;
DDOVERLAYCAPS_CKEYSRC = $00000040;
DDOVERLAYCAPS_CKEYSRCCLRSPACE = $00000080;
DDOVERLAYCAPS_CKEYSRCCLRSPACEYUV = $00000100;
DDOVERLAYCAPS_CKEYDEST = $00000200;
DDOVERLAYCAPS_CKEYDESTCLRSPACE = $00000400;
DDOVERLAYCAPS_CKEYDESTCLRSPACEYUV = $00000800;
DDOVERLAYCAPS_CKEYBOTH = $00001000;
DDOVERLAYCAPS_ALPHADEST = $00002000;
DDOVERLAYCAPS_ALPHASRC = $00008000;
DDOVERLAYCAPS_ALPHADESTNEG = $00002000;
DDOVERLAYCAPS_ALPHASRCNEG = $00008000;
DDOVERLAYCAPS_ALPHACONSTANT = $00010000;
DDOVERLAYCAPS_ALPHAPREMULT = $00040000;
DDOVERLAYCAPS_ALPHANONPREMULT = $00080000;
DDOVERLAYCAPS_ALPHAANDKEYDEST = $00100000;
DDOVERLAYCAPS_OVERLAYSUPPORT = $80000000;
DDOVERLAYCAPS_VALID = DDOVERLAYCAPS_FLIP or
DDOVERLAYCAPS_FOURCC or
DDOVERLAYCAPS_ZORDER or
DDOVERLAYCAPS_MIRRORLEFTRIGHT or
DDOVERLAYCAPS_MIRRORUPDOWN or
DDOVERLAYCAPS_CKEYSRC or
DDOVERLAYCAPS_CKEYSRCCLRSPACE or
DDOVERLAYCAPS_CKEYSRCCLRSPACEYUV or
DDOVERLAYCAPS_CKEYDEST or
DDOVERLAYCAPS_CKEYDESTCLRSPACE or
DDOVERLAYCAPS_CKEYDESTCLRSPACEYUV or
DDOVERLAYCAPS_CKEYBOTH or
DDOVERLAYCAPS_ALPHADEST or
DDOVERLAYCAPS_ALPHASRC or
DDOVERLAYCAPS_ALPHADESTNEG or
DDOVERLAYCAPS_ALPHASRCNEG or
DDOVERLAYCAPS_ALPHACONSTANT or
DDOVERLAYCAPS_ALPHAPREMULT or
DDOVERLAYCAPS_ALPHANONPREMULT or
DDOVERLAYCAPS_ALPHAANDKEYDEST or
DDOVERLAYCAPS_OVERLAYSUPPORT;

// Miscellaneous Capability Flags (For DDCAPS dwMiscCaps member)
DDMISCCAPS_READSCANLINE = $00000001;
DDMISCCAPS_READMONITORFREQ = $00000002;
DDMISCCAPS_READVBLANKSTATUS = $00000004;
DDMISCCAPS_FLIPINTERVAL = $00000008;
DDMISCCAPS_FLIPODDEVEN = $00000010;
DDMISCCAPS_FLIPVSYNCWITHVBI = $00000020;
DDMISCCAPS_COLORCONTROLOVERLAY = $00000040;
DDMISCCAPS_COLORCONTROLPRIMARY = $00000080;
DDMISCCAPS_GAMMACONTROLOVERLAY = $00000100;
DDMISCCAPS_GAMMACONTROLPRIMARY = $00000200;
DDMISCCAPS_VALID = DDMISCCAPS_READSCANLINE or DDMISCCAPS_READMONITORFREQ or
DDMISCCAPS_READVBLANKSTATUS or DDMISCCAPS_FLIPINTERVAL or
DDMISCCAPS_FLIPODDEVEN or DDMISCCAPS_FLIPVSYNCWITHVBI or
DDMISCCAPS_COLORCONTROLOVERLAY or DDMISCCAPS_COLORCONTROLPRIMARY or
DDMISCCAPS_GAMMACONTROLOVERLAY or DDMISCCAPS_GAMMACONTROLPRIMARY;

// DirectDraw method flags

//* Flags for IDirectDraw::EnumSurfaces
DDENUMSURFACES_ALL = $00000001;
DDENUMSURFACES_MATCH = $00000002;
DDENUMSURFACES_NOMATCH = $00000004;
DDENUMSURFACES_CANBECREATED = $00000008;
DDENUMSURFACES_DOESEXIST = $00000010;
DDENUMSURFACES_VALID = DDENUMSURFACES_ALL or DDENUMSURFACES_MATCH or
DDENUMSURFACES_NOMATCH or DDENUMSURFACES_CANBECREATED or
DDENUMSURFACES_DOESEXIST;

//* Flags for IDirectDraw::SetCooperativeLevel
DDSCL_NORMAL = $00000000;
DDSCL_FULLSCREEN = $00000001;
DDSCL_VALID = DDSCL_FULLSCREEN or DDSCL_NORMAL;

// * Flags for IDirectDraw::WaitForVerticalBlank
DDWAITVB_BLOCKBEGIN = $00000001;
DDWAITVB_BLOCKEND = $00000004;
DDWAITVB_VALID = DDWAITVB_BLOCKBEGIN or DDWAITVB_BLOCKEND;

// * Flags for IDirectDrawSurface::GetColorKey and IDirectDrawSurface::SetColorKey
DDCKEY_COLORSPACE = $00000001;
DDCKEY_DESTBLT = $00000002;
DDCKEY_DESTOVERLAY = $00000004;
DDCKEY_SRCBLT = $00000008;
DDCKEY_SRCOVERLAY = $00000010;
DDCKEY_VALID = DDCKEY_DESTBLT or DDCKEY_DESTOVERLAY or DDCKEY_SRCBLT or DDCKEY_SRCOVERLAY;

// * Flags for IDirectDrawSurface::Blt
DDBLT_COLORFILL = $00000400;
DDBLT_KEYDEST = $00002000;
DDBLT_KEYDESTOVERRIDE = $00004000;
DDBLT_KEYSRC = $00008000;
DDBLT_KEYSRCOVERRIDE = $00010000;
DDBLT_ROP = $00020000;
DDBLT_WAITNOTBUSY = $01000000;
DDBLT_WAITVSYNC = $00000001;
DDBLT_VALID = ((((((DDBLT_COLORFILL or DDBLT_KEYDEST) or DDBLT_KEYDESTOVERRIDE) or DDBLT_KEYSRC) or DDBLT_KEYSRCOVERRIDE) or DDBLT_ROP) or DDBLT_WAITNOTBUSY) or DDBLT_WAITVSYNC;

// Flags for IDirectDrawSurface::AlphaBlt
DDABLT_NOBLEND = $02000000;
DDABLT_COLORFILL = $00100000;
DDABLT_ALPHADESTNEG = $00000004;
DDABLT_ALPHASRCNEG = $00000080;
DDABLT_WAITNOTBUSY = $01000000;
DDABLT_WAITVSYNC = $00000001;
DDABLT_VALID = ((((DDABLT_NOBLEND or DDABLT_COLORFILL) or DDABLT_ALPHADESTNEG) or DDABLT_ALPHASRCNEG) or DDABLT_WAITNOTBUSY) or DDABLT_WAITVSYNC;

// Flags for IDirectDrawSurface::Flip
DDFLIP_EVEN = $00000002;
DDFLIP_ODD = $00000004;
DDFLIP_INTERVAL1 = $01000000;
DDFLIP_INTERVAL2 = $02000000;
DDFLIP_INTERVAL4 = $04000000;
DDFLIP_WAITNOTBUSY = $00000008;
DDFLIP_WAITVSYNC = $00000001;
DDFLIP_VALID = (((((DDFLIP_EVEN or DDFLIP_ODD) or DDFLIP_INTERVAL1) or DDFLIP_INTERVAL2) or DDFLIP_INTERVAL4) or DDFLIP_WAITNOTBUSY) or DDFLIP_WAITVSYNC;
DDFLIP_INTERVAL3 = DDFLIP_INTERVAL1 or DDFLIP_INTERVAL2;
DDFLIP_INTERVALMASK = (DDFLIP_INTERVAL1 or DDFLIP_INTERVAL2) or DDFLIP_INTERVAL4;

// * Flag values for IDirectDrawSurface::UpdateOverlay
DDOVER_ALPHADEST = $00000001;
DDOVER_ALPHADESTNEG = $00000002;
DDOVER_ALPHASRC = $00000004;
DDOVER_ALPHASRCNEG = $00000008;
DDOVER_ALPHACONSTOVERRIDE = $00000010;
DDOVER_HIDE = $00000020;
DDOVER_KEYDEST = $00000040;
DDOVER_KEYDESTOVERRIDE = $00000080;
DDOVER_KEYSRC = $00000100;
DDOVER_KEYSRCOVERRIDE = $00000200;
DDOVER_SHOW = $00000400;
DDOVER_MIRRORLEFTRIGHT = $00001000;
DDOVER_MIRRORUPDOWN = $00002000;
DDOVER_WAITNOTBUSY = $00004000;
DDOVER_WAITVSYNC = $00008000;
DDOVER_VALID = DDOVER_ALPHADEST or DDOVER_ALPHADESTNEG or
DDOVER_ALPHASRC or DDOVER_ALPHASRCNEG or
DDOVER_ALPHACONSTOVERRIDE or DDOVER_HIDE or
DDOVER_KEYDEST or DDOVER_KEYDESTOVERRIDE or
DDOVER_KEYSRC or DDOVER_KEYSRCOVERRIDE or
DDOVER_SHOW or DDOVER_MIRRORLEFTRIGHT or
DDOVER_MIRRORUPDOWN or DDOVER_WAITNOTBUSY or
DDOVER_WAITVSYNC;

// * Flags for IDirectDrawSurface::Lock
DDLOCK_READONLY = $00000001;
DDLOCK_WRITEONLY = $00000002;
DDLOCK_DISCARD = $00000004;
DDLOCK_WAITNOTBUSY = $00000008;
DDLOCK_VALID = ((DDLOCK_READONLY or DDLOCK_WRITEONLY) or DDLOCK_DISCARD) or DDLOCK_WAITNOTBUSY;

// * Flags for IDirectDrawSurface::GetFlipStatus
DDGFS_CANFLIP = $00000001;
DDGFS_ISFLIPDONE = $00000002;
DDGFS_VALID = DDGFS_CANFLIP or DDGFS_ISFLIPDONE;

// * Flags for IDirectDrawSurface::GetBltStatus
DDGBS_CANBLT = $00000001;
DDGBS_ISBLTDONE = $00000002;
DDGBS_VALID = DDGBS_CANBLT or DDGBS_ISBLTDONE;

// * Flags for IDirectDrawSurface::EnumOverlayZOrders
DDENUMOVERLAYZ_FRONTTOBACK = $00000001;
DDENUMOVERLAYZ_VALID = DDENUMOVERLAYZ_FRONTTOBACK;

// * Flags for IDirectDrawSurface::UpdateOverlayZOrder
DDOVERZ_SENDTOFRONT = $00000000;
DDOVERZ_SENDTOBACK = $00000001;
DDOVERZ_MOVEFORWARD = $00000002;
DDOVERZ_MOVEBACKWARD = $00000003;
DDOVERZ_INSERTINFRONTOF = $00000004;
DDOVERZ_INSERTINBACKOF = $00000005;

//
// DirectDraw Return Codes
//

// * Enumeration function return values.
DDENUMRET_CANCEL = 0;
DDENUMRET_OK = 1;

//
// DirectDraw error codes.
//

const

DD_OK = 0;
DD_FALSE = S_FALSE;

DDERR_CURRENTLYNOTAVAIL = HResult($88760000 + 40);
DDERR_GENERIC = HResult(E_FAIL);
DDERR_HEIGHTALIGN = HResult($88760000 + 90);
DDERR_INCOMPATIBLEPRIMARY = HResult($88760000 + 95);
DDERR_INVALIDCAPS = HResult($88760000 + 100);
DDERR_INVALIDCLIPLIST = HResult($88760000 + 110);
DDERR_INVALIDMODE = HResult($88760000 + 120);
DDERR_INVALIDOBJECT = HResult($88760000 + 130);
DDERR_INVALIDPARAMS = HResult(E_INVALIDARG);
DDERR_INVALIDPIXELFORMAT = HResult($88760000 + 145);
DDERR_INVALIDRECT = HResult($88760000 + 150);
DDERR_LOCKEDSURFACES = HResult($88760000 + 160);
DDERR_NO3D = HResult($88760000 + 170);
DDERR_NOALPHAHW = HResult($88760000 + 180);
DDERR_NOCLIPLIST = HResult($88760000 + 205);
DDERR_NOCOLORCONVHW = HResult($88760000 + 210);
DDERR_NOCOOPERATIVELEVELSET = HResult($88760000 + 212);
DDERR_NOCOLORKEY = HResult($88760000 + 215);
DDERR_NOFLIPHW = HResult($88760000 + 230);
DDERR_NOGDI = HResult($88760000 + 240);
DDERR_NOMIRRORHW = HResult($88760000 + 250);
DDERR_NOTFOUND = HResult($88760000 + 255);
DDERR_NOOVERLAYHW = HResult($88760000 + 260);
DDERR_OVERLAPPINGRECTS = HResult($88760000 + 270);
DDERR_NORASTEROPHW = HResult($88760000 + 280);
DDERR_NOSTRETCHHW = HResult($88760000 + 310);
DDERR_NOVSYNCHW = HResult($88760000 + 335);
DDERR_NOZOVERLAYHW = HResult($88760000 + 350);
DDERR_OUTOFCAPS = HResult($88760000 + 360);
DDERR_OUTOFMEMORY = HResult(E_OUTOFMEMORY);
DDERR_OUTOFVIDEOMEMORY = HResult($88760000 + 380);
DDERR_PALETTEBUSY = HResult($88760000 + 387);
DDERR_COLORKEYNOTSET = HResult($88760000 + 400);
DDERR_SURFACEBUSY = HResult($88760000 + 430);
DDERR_CANTLOCKSURFACE = HResult($88760000 + 435);
DDERR_SURFACELOST = HResult($88760000 + 450);
DDERR_TOOBIGHEIGHT = HResult($88760000 + 470);
DDERR_TOOBIGSIZE = HResult($88760000 + 480);
DDERR_TOOBIGWIDTH = HResult($88760000 + 490);
DDERR_UNSUPPORTED = HResult(E_NOTIMPL);
DDERR_UNSUPPORTEDFORMAT = HResult($88760000 + 536);
DDERR_VERTICALBLANKINPROGRESS = HResult($88760000 + 537);
DDERR_WASSTILLDRAWING = HResult($88760000 + 540);
DDERR_DIRECTDRAWALREADYCREATED = HResult($88760000 + 562);
DDERR_PRIMARYSURFACEALREADYEXISTS = HResult($88760000 + 564);
DDERR_REGIONTOOSMALL = HResult($88760000 + 566);
DDERR_CLIPPERISUSINGHWND = HResult($88760000 + 567);
DDERR_NOCLIPPERATTACHED = HResult($88760000 + 568);
DDERR_NOPALETTEATTACHED = HResult($88760000 + 572);
DDERR_NOPALETTEHW = HResult($88760000 + 573);
DDERR_NOBLTHW = HResult($88760000 + 575);
DDERR_OVERLAYNOTVISIBLE = HResult($88760000 + 577);
DDERR_NOOVERLAYDEST = HResult($88760000 + 578);
DDERR_INVALIDPOSITION = HResult($88760000 + 579);
DDERR_NOTAOVERLAYSURFACE = HResult($88760000 + 580);
DDERR_EXCLUSIVEMODEALREADYSET = HResult($88760000 + 581);
DDERR_NOTFLIPPABLE = HResult($88760000 + 582);
DDERR_NOTLOCKED = HResult($88760000 + 584);
DDERR_CANTCREATEDC = HResult($88760000 + 585);
DDERR_NODC = HResult($88760000 + 586);
DDERR_WRONGMODE = HResult($88760000 + 587);
DDERR_IMPLICITLYCREATED = HResult($88760000 + 588);
DDERR_NOTPALETTIZED = HResult($88760000 + 589);
DDERR_DCALREADYCREATED = HResult($88760000 + 620);
DDERR_MOREDATA = HResult($88760000 + 690);
DDERR_VIDEONOTACTIVE = HResult($88760000 + 695);
DDERR_DEVICEDOESNTOWNSURFACE = HResult($88760000 + 699);

implementation

function MAKEFOURCC(ch0, ch1, ch2, ch3: Char) : DWORD;
begin
Result := Ord(ch0) + (Ord(ch1) shl 8) + (Ord(ch2) shl 16) + (Ord(ch3) shl 24);
end;

end.