1155 lines
46 KiB
C
1155 lines
46 KiB
C
/******************************Module*Header*******************************\
|
||
* Module Name: driver.h
|
||
*
|
||
* Contains prototypes for the display driver.
|
||
*
|
||
* Copyright (c) 1992-1995 Microsoft Corporation
|
||
\**************************************************************************/
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Put all the conditional-compile constants here. There had better
|
||
// not be many!
|
||
|
||
// Multi-board support can be enabled by setting this to 1:
|
||
|
||
#define MULTI_BOARDS 0
|
||
|
||
// This is the maximum number of boards we'll support in a single
|
||
// virtual driver:
|
||
|
||
#if MULTI_BOARDS
|
||
#define MAX_BOARDS 16
|
||
#define IBOARD(ppdev) ((ppdev)->iBoard)
|
||
#else
|
||
#define MAX_BOARDS 1
|
||
#define IBOARD(ppdev) 0
|
||
#endif
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Miscellaneous shared stuff
|
||
|
||
#define DLL_NAME L"ati" // Name of the DLL in UNICODE
|
||
#define STANDARD_DEBUG_PREFIX "ATI: " // All debug output is prefixed
|
||
// by this string
|
||
#define ALLOC_TAG ' ITA' // Four byte tag used for tracking
|
||
// memory allocations (characters
|
||
// are in reverse order)
|
||
|
||
#define CLIP_LIMIT 50 // We'll be taking 800 bytes of stack space
|
||
|
||
#define DRIVER_EXTRA_SIZE 0 // Size of the DriverExtra information in the
|
||
// DEVMODE structure
|
||
|
||
#define TMP_BUFFER_SIZE 8192 // Size in bytes of 'pvTmpBuffer'. Has to
|
||
// be at least enough to store an entire
|
||
// scan line (i.e., 6400 for 1600x1200x32).
|
||
|
||
#define ROUND8(x) (((x)+7)&~7)
|
||
|
||
typedef struct _CLIPENUM {
|
||
LONG c;
|
||
RECTL arcl[CLIP_LIMIT]; // Space for enumerating complex clipping
|
||
|
||
} CLIPENUM; /* ce, pce */
|
||
|
||
typedef struct _PDEV PDEV; // Handy forward declaration
|
||
|
||
// Basic Mach types:
|
||
|
||
typedef enum {
|
||
MACH_IO_32, // Mach8 or Mach32
|
||
MACH_MM_32, // Mach32 capable of memory-mapped I/O
|
||
MACH_MM_64, // Mach64
|
||
} MACHTYPE;
|
||
|
||
// Specific ASIC types:
|
||
|
||
typedef enum {
|
||
ASIC_38800_1, // Mach8
|
||
ASIC_68800_3, // Mach32
|
||
ASIC_68800_6, // Mach32
|
||
ASIC_68800AX, // Mach32
|
||
ASIC_88800GX, // Mach64
|
||
ASIC_COUNT
|
||
} ASIC;
|
||
|
||
// Frame buffer aperture types:
|
||
|
||
typedef enum {
|
||
APERTURE_NONE,
|
||
APERTURE_FULL,
|
||
APERTURE_PAGE_SINGLE,
|
||
APERTURE_PAGE_DOUBLE,
|
||
APERTURE_COUNT
|
||
} APERTURE;
|
||
|
||
|
||
// NOTE: Must be kept in sync with miniport version of the structure!
|
||
|
||
#include "atint.h"
|
||
|
||
|
||
#if TARGET_BUILD > 351
|
||
|
||
#define AtiDeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned) \
|
||
(!EngDeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned))
|
||
|
||
#define AtiAllocMem(a,b,allocSize) EngAllocMem((b),allocSize,ALLOC_TAG)
|
||
#define AtiFreeMem(ptr) EngFreeMem(ptr)
|
||
|
||
#else
|
||
|
||
#define AtiDeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned) \
|
||
DeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned,NULL)
|
||
|
||
#define AtiAllocMem(a,b,allocSize) LocalAlloc((a),allocSize)
|
||
#define AtiFreeMem(ptr) LocalFree(ptr)
|
||
|
||
#endif
|
||
|
||
|
||
VOID vSetClipping(PDEV*, RECTL*);
|
||
VOID vResetClipping(PDEV*);
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Text stuff
|
||
|
||
#define GLYPH_CACHE_CX 64 // Maximal width of glyphs that we'll consider
|
||
// caching
|
||
|
||
#define GLYPH_CACHE_CY 64 // Maximum height of glyphs that we'll consider
|
||
// caching
|
||
|
||
#define GLYPH_ALLOC_SIZE 8100
|
||
// Do all cached glyph memory allocations
|
||
// in 8k chunks
|
||
|
||
#define HGLYPH_SENTINEL ((ULONG) -1)
|
||
// GDI will never give us a glyph with a
|
||
// handle value of 0xffffffff, so we can
|
||
// use this as a sentinel for the end of
|
||
// our linked lists
|
||
|
||
#define GLYPH_HASH_SIZE 256
|
||
|
||
#define GLYPH_HASH_FUNC(x) ((x) & (GLYPH_HASH_SIZE - 1))
|
||
|
||
typedef struct _CACHEDGLYPH CACHEDGLYPH;
|
||
typedef struct _CACHEDGLYPH
|
||
{
|
||
CACHEDGLYPH* pcgNext; // Points to next glyph that was assigned
|
||
// to the same hash table bucket
|
||
HGLYPH hg; // Handles in the bucket-list are kept in
|
||
// increasing order
|
||
POINTL ptlOrigin; // Origin of glyph bits
|
||
|
||
// Device specific fields below here:
|
||
|
||
LONG cx; // Width of the glyph
|
||
LONG cy; // Height of the glyph
|
||
LONG cxy; // Height and width encoded
|
||
LONG cw; // Number of words in glyph
|
||
LONG cd; // Number of dwords in glyph
|
||
|
||
// Glyph bits follow here:
|
||
|
||
ULONG ad[1]; // Start of glyph bits
|
||
} CACHEDGLYPH; /* cg, pcg */
|
||
|
||
typedef struct _GLYPHALLOC GLYPHALLOC;
|
||
typedef struct _GLYPHALLOC
|
||
{
|
||
GLYPHALLOC* pgaNext; // Points to next glyph structure that
|
||
// was allocated for this font
|
||
CACHEDGLYPH acg[1]; // This array is a bit misleading, because
|
||
// the CACHEDGLYPH structures are actually
|
||
// variable sized
|
||
} GLYPHAALLOC; /* ga, pga */
|
||
|
||
typedef struct _CACHEDFONT
|
||
{
|
||
GLYPHALLOC* pgaChain; // Points to start of allocated memory list
|
||
CACHEDGLYPH* pcgNew; // Points to where in the current glyph
|
||
// allocation structure a new glyph should
|
||
// be placed
|
||
LONG cjAlloc; // Bytes remaining in current glyph allocation
|
||
// structure
|
||
CACHEDGLYPH cgSentinel; // Sentinel entry of the end of our bucket
|
||
// lists, with a handle of HGLYPH_SENTINEL
|
||
CACHEDGLYPH* apcg[GLYPH_HASH_SIZE];
|
||
// Hash table for glyphs
|
||
|
||
} CACHEDFONT; /* cf, pcf */
|
||
|
||
BOOL bEnableText(PDEV*);
|
||
VOID vDisableText(PDEV*);
|
||
VOID vAssertModeText(PDEV*, BOOL);
|
||
|
||
/////////////////////////////////////////////////////////////////////
|
||
// for overlay support
|
||
#if TARGET_BUILD > 351
|
||
// new stuff from overlay.c
|
||
|
||
#define UPDATEOVERLAY 0x01L
|
||
#define SETOVERLAYPOSITION 0x02L
|
||
#define DOUBLE_PITCH 0x04L
|
||
#define OVERLAY_ALLOCATED 0x08L
|
||
#define OVERLAY_VISIBLE 0x10L
|
||
#define CRTC_INTERLACE_EN 0x00000002L
|
||
#define CRTC_VLINE_CRNT_VLINE 0x04
|
||
#define CLOCK_CNTL 0x24
|
||
|
||
#define DD_RESERVED_DIFFERENTPIXELFORMAT 0x0001
|
||
|
||
typedef struct tagOVERLAYINFO16
|
||
{
|
||
DWORD dwFlags;
|
||
RECTL rSrc;
|
||
RECTL rDst;
|
||
RECTL rOverlay;
|
||
DWORD dwBuf0Start;
|
||
LONG lBuf0Pitch;
|
||
DWORD dwBuf1Start;
|
||
LONG lBuf1Pitch;
|
||
DWORD dwOverlayKeyCntl;
|
||
DWORD dwHInc;
|
||
DWORD dwVInc;
|
||
}
|
||
OVERLAYINFO16;
|
||
|
||
/*****************************************************************************
|
||
|
||
VT - GT Registers
|
||
|
||
*****************************************************************************/
|
||
|
||
#define DD_OVERLAY_Y_X 0x00
|
||
#define DD_OVERLAY_Y_X_END 0x01
|
||
#define DD_OVERLAY_VIDEO_KEY_CLR 0x02
|
||
#define DD_OVERLAY_VIDEO_KEY_MSK 0x03
|
||
#define DD_OVERLAY_GRAPHICS_KEY_CLR 0x04
|
||
#define DD_OVERLAY_GRAPHICS_KEY_MSK 0x05
|
||
#define DD_OVERLAY_KEY_CNTL 0x06
|
||
#define DD_OVERLAY_SCALE_INC 0x08
|
||
#define DD_OVERLAY_SCALE_CNTL 0x09
|
||
#define DD_SCALER_HEIGHT_WIDTH 0x0A
|
||
#define DD_OVERLAY_TEST 0x0B
|
||
#define DD_SCALER_THRESHOLD 0x0C
|
||
#define DD_SCALER_BUF0_OFFSET 0x0D
|
||
#define DD_SCALER_BUF1_OFFSET 0x0E
|
||
#define DD_SCALER_BUF_PITCH 0x0F
|
||
#define DD_VIDEO_FORMAT 0x12
|
||
#define DD_VIDEO_CONFIG 0x13
|
||
#define DD_CAPTURE_CONFIG 0x14
|
||
#define DD_TRIG_CNTL 0x15
|
||
#define DD_VMC_CONFIG 0x18
|
||
#define DD_BUF0_OFFSET 0x20
|
||
#define DD_BUF0_PITCH 0x23
|
||
#define DD_BUF1_OFFSET 0x26
|
||
#define DD_BUF1_PITCH 0x29
|
||
// for RAGE III
|
||
#define DD_SCALER_COLOUR_CNTL 0x54
|
||
#define DD_SCALER_H_COEFF0 0x55
|
||
#define DD_SCALER_H_COEFF1 0x56
|
||
#define DD_SCALER_H_COEFF2 0x57
|
||
#define DD_SCALER_H_COEFF3 0x58
|
||
#define DD_SCALER_H_COEFF4 0x59
|
||
|
||
/*****************************************************************************/
|
||
// stuff from overlay.c
|
||
|
||
#define MAKE_FOURCC( ch0, ch1, ch2, ch3 ) \
|
||
( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \
|
||
( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
|
||
|
||
#define FOURCC_YUY2 MAKE_FOURCC('Y','U','Y','2')
|
||
#define FOURCC_UYVY MAKE_FOURCC('U','Y','V','Y')
|
||
#define FOURCC_YVYU MAKE_FOURCC('Y','V','Y','U')
|
||
// end overlay support
|
||
#endif
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Dither stuff
|
||
|
||
// Describes a single colour tetrahedron vertex for dithering:
|
||
|
||
typedef struct _VERTEX_DATA {
|
||
ULONG ulCount; // Number of pixels in this vertex
|
||
ULONG ulVertex; // Vertex number
|
||
} VERTEX_DATA; /* vd, pv */
|
||
|
||
VERTEX_DATA* vComputeSubspaces(ULONG, VERTEX_DATA*);
|
||
VOID vDitherColor(ULONG*, VERTEX_DATA*, VERTEX_DATA*, ULONG);
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Brush stuff
|
||
|
||
#define TOTAL_BRUSH_COUNT 8 // We'll keep room for 8 brushes in our
|
||
// Mach64 off-screen brush cache.
|
||
// Must be a power of two.
|
||
|
||
#define TOTAL_BRUSH_SIZE 64 // We'll only ever handle 8x8 patterns,
|
||
// and this is the number of pels
|
||
|
||
#define RBRUSH_2COLOR 1 // For RBRUSH flags
|
||
|
||
typedef struct _BRUSHENTRY BRUSHENTRY;
|
||
typedef union _RBRUSH_COLOR RBRUSH_COLOR;
|
||
|
||
typedef VOID (FNFILL)(PDEV*, LONG, RECTL*, ULONG, RBRUSH_COLOR, POINTL*);
|
||
|
||
typedef struct _RBRUSH {
|
||
FLONG fl; // Type flags
|
||
ULONG ulForeColor; // Foreground colour if 1bpp
|
||
ULONG ulBackColor; // Background colour if 1bpp
|
||
POINTL ptlBrush; // Monochrome brush's alignment
|
||
FNFILL* pfnFillPat; // Fill routine to be called for this brush
|
||
BRUSHENTRY* apbe[MAX_BOARDS];// Points to brush-entry that keeps track
|
||
// of the cached off-screen brush bits
|
||
ULONG aulPattern[1]; // Open-ended array for keeping copy of the
|
||
// Don't put anything // actual pattern bits in case the brush
|
||
// after here, or // origin changes, or someone else steals
|
||
// you'll be sorry! // our brush entry (declared as a ULONG
|
||
// for proper dword alignment)
|
||
|
||
} RBRUSH; /* rb, prb */
|
||
|
||
typedef struct _BRUSHENTRY {
|
||
RBRUSH* prbVerify; // We never dereference this pointer to
|
||
// find a brush realization; it is only
|
||
// ever used in a compare to verify
|
||
// that for a given realized brush, our
|
||
// off-screen brush entry is still valid.
|
||
LONG x; // x-position of cached pattern
|
||
LONG y; // y-position of cached pattern
|
||
ULONG ulOffsetPitch; // Packed offset and pitch of cached brush
|
||
// in off-screen memory on the Mach64
|
||
|
||
} BRUSHENTRY; /* be, pbe */
|
||
|
||
typedef union _RBRUSH_COLOR {
|
||
RBRUSH* prb;
|
||
ULONG iSolidColor;
|
||
} RBRUSH_COLOR; /* rbc, prbc */
|
||
|
||
BOOL bEnableBrushCache(PDEV*);
|
||
VOID vDisableBrushCache(PDEV*);
|
||
VOID vAssertModeBrushCache(PDEV*, BOOL);
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Stretch stuff
|
||
|
||
typedef struct _STR_BLT {
|
||
PDEV* ppdev;
|
||
PBYTE pjSrcScan;
|
||
LONG lDeltaSrc;
|
||
LONG XSrcStart;
|
||
PBYTE pjDstScan;
|
||
LONG lDeltaDst;
|
||
LONG XDstStart;
|
||
LONG XDstEnd;
|
||
LONG YDstStart;
|
||
LONG YDstCount;
|
||
ULONG ulXDstToSrcIntCeil;
|
||
ULONG ulXDstToSrcFracCeil;
|
||
ULONG ulYDstToSrcIntCeil;
|
||
ULONG ulYDstToSrcFracCeil;
|
||
ULONG ulXFracAccumulator;
|
||
ULONG ulYFracAccumulator;
|
||
} STR_BLT;
|
||
|
||
typedef VOID (*PFN_DIRSTRETCH)(STR_BLT*);
|
||
typedef BOOL (FN_STRETCHDIB)(PDEV*, VOID*, LONG, RECTL*, VOID*, LONG, RECTL*, RECTL*);
|
||
|
||
VOID vDirectStretch8Narrow(STR_BLT*);
|
||
VOID vM64DirectStretch8(STR_BLT*);
|
||
VOID vM64DirectStretch16(STR_BLT*);
|
||
VOID vM64DirectStretch32(STR_BLT*);
|
||
VOID vM32DirectStretch8(STR_BLT*);
|
||
VOID vM32DirectStretch16(STR_BLT*);
|
||
VOID vI32DirectStretch8(STR_BLT*);
|
||
VOID vI32DirectStretch16(STR_BLT*);
|
||
|
||
FN_STRETCHDIB bM64StretchDIB;
|
||
FN_STRETCHDIB bM32StretchDIB;
|
||
FN_STRETCHDIB bI32StretchDIB;
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Heap stuff
|
||
|
||
typedef enum {
|
||
OH_FREE = 0, // The off-screen allocation is available for use
|
||
OH_DISCARDABLE, // The allocation is occupied by a discardable bitmap
|
||
// that may be moved out of off-screen memory
|
||
OH_PERMANENT, // The allocation is occupied by a permanent bitmap
|
||
// that cannot be moved out of off-screen memory
|
||
} OHSTATE;
|
||
|
||
typedef struct _DSURF DSURF;
|
||
typedef struct _OH OH;
|
||
typedef struct _OH
|
||
{
|
||
OHSTATE ohState; // State of off-screen allocation
|
||
LONG x; // x-coordinate of left edge of allocation
|
||
LONG y; // y-coordinate of top edge of allocation
|
||
LONG cx; // Width in pixels of allocation
|
||
LONG cy; // Height in pixels of allocation
|
||
LONG cxReserved; // Dimensions of original reserved rectangle;
|
||
LONG cyReserved; // zero if rectangle is not 'reserved'
|
||
OH* pohNext; // When OH_FREE or OH_RESERVE, points to the next
|
||
// free node, in ascending cxcy value. This is
|
||
// kept as a circular doubly-linked list with a
|
||
// sentinel at the end.
|
||
// When OH_DISCARDABLE, points to the next most
|
||
// recently created allocation. This is kept as
|
||
// a circular doubly-linked list.
|
||
OH* pohPrev; // Opposite of 'pohNext'
|
||
ULONG cxcy; // Width and height in a dword for searching
|
||
OH* pohLeft; // Adjacent allocation when in-use or available
|
||
OH* pohUp;
|
||
OH* pohRight;
|
||
OH* pohDown;
|
||
DSURF* pdsurf; // Points to our DSURF structure
|
||
VOID* pvScan0; // Points to start of first scan-line
|
||
}; /* oh, poh */
|
||
|
||
// This is the smallest structure used for memory allocations:
|
||
|
||
typedef struct _OHALLOC OHALLOC;
|
||
typedef struct _OHALLOC
|
||
{
|
||
OHALLOC* pohaNext;
|
||
OH aoh[1];
|
||
} OHALLOC; /* oha, poha */
|
||
|
||
typedef struct _HEAP
|
||
{
|
||
LONG cxMax; // Largest possible free space by area
|
||
LONG cyMax;
|
||
OH ohFree; // Head of the free list, containing those
|
||
// rectangles in off-screen memory that are
|
||
// available for use. pohNext points to
|
||
// hte smallest available rectangle, and pohPrev
|
||
// points to the largest available rectangle,
|
||
// sorted by cxcy.
|
||
OH ohDiscardable; // Head of the discardable list that contains all
|
||
// bitmaps located in offscreen memory that
|
||
// are eligible to be tossed out of the heap.
|
||
// It is kept in order of creation: pohNext
|
||
// points to the most recently created; pohPrev
|
||
// points to the least recently created.
|
||
OH ohPermanent; // List of permanently allocated rectangles
|
||
OH* pohFreeList; // List of OH node data structures available
|
||
OHALLOC* pohaChain; // Chain of allocations
|
||
} HEAP; /* heap, pheap */
|
||
|
||
typedef enum {
|
||
DT_SCREEN, // Surface is kept in screen memory
|
||
DT_DIB // Surface is kept as a DIB
|
||
} DSURFTYPE; /* dt, pdt */
|
||
|
||
typedef struct _DSURF
|
||
{
|
||
DSURFTYPE dt; // DSURF status (whether off-screen or in a DIB)
|
||
SIZEL sizl; // Size of the original bitmap (could be smaller
|
||
// than poh->sizl)
|
||
PDEV* ppdev; // Need this for deleting the bitmap
|
||
union {
|
||
OH* poh; // If DT_SCREEN, points to off-screen heap node
|
||
SURFOBJ* pso; // If DT_DIB, points to locked GDI surface
|
||
};
|
||
|
||
// The following are used for DT_DIB only...
|
||
|
||
ULONG cBlt; // Counts down the number of blts necessary at
|
||
// the current uniqueness before we'll consider
|
||
// putting the DIB back into off-screen memory
|
||
ULONG iUniq; // Tells us whether there have been any heap
|
||
// 'free's since the last time we looked at
|
||
// this DIB
|
||
|
||
} DSURF; /* dsurf, pdsurf */
|
||
|
||
// GDI expects dword alignment for any bitmaps on which it is expected
|
||
// to draw. Since we occasionally ask GDI to draw directly on our off-
|
||
// screen bitmaps, this means that any off-screen bitmaps must be dword
|
||
// aligned in the frame buffer. We enforce this merely by ensuring that
|
||
// all off-screen bitmaps are four-pel aligned (we may waste a couple of
|
||
// pixels at the higher colour depths):
|
||
|
||
#define HEAP_X_ALIGNMENT 4
|
||
|
||
// Number of blts necessary before we'll consider putting a DIB DFB back
|
||
// into off-screen memory:
|
||
|
||
#define HEAP_COUNT_DOWN 6
|
||
|
||
// Flags for 'pohAllocate':
|
||
|
||
typedef enum {
|
||
FLOH_ONLY_IF_ROOM = 0x0001, // Don't kick stuff out of off-
|
||
// screen memory to make room
|
||
FLOH_MAKE_PERMANENT = 0x0002, // Allocate a permanent entry
|
||
FLOH_RESERVE = 0x0004, // Allocate an off-screen entry,
|
||
// but let it be used by discardable
|
||
// bitmaps until it's needed
|
||
} FLOH;
|
||
|
||
// Publicly callable heap APIs:
|
||
|
||
OH* pohAllocate(PDEV*, POINTL*, LONG, LONG, FLOH);
|
||
BOOL bOhCommit(PDEV*, OH*, BOOL);
|
||
OH* pohFree(PDEV*, OH*);
|
||
|
||
OH* pohMoveOffscreenDfbToDib(PDEV*, OH*);
|
||
BOOL bMoveDibToOffscreenDfbIfRoom(PDEV*, DSURF*);
|
||
BOOL bMoveAllDfbsFromOffscreenToDibs(PDEV* ppdev);
|
||
|
||
BOOL bEnableOffscreenHeap(PDEV*);
|
||
VOID vDisableOffscreenHeap(PDEV*);
|
||
BOOL bAssertModeOffscreenHeap(PDEV*, BOOL);
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Bank manager stuff
|
||
|
||
#define BANK_DATA_SIZE 80 // Number of bytes to allocate for the
|
||
// miniport down-loaded bank code working
|
||
// space
|
||
|
||
typedef struct _BANK
|
||
{
|
||
// Private data:
|
||
|
||
RECTL rclDraw; // Rectangle describing the remaining undrawn
|
||
// portion of the drawing operation
|
||
RECTL rclSaveBounds; // Saved from original CLIPOBJ for restoration
|
||
BYTE iSaveDComplexity; // Saved from original CLIPOBJ for restoration
|
||
BYTE fjSaveOptions; // Saved from original CLIPOBJ for restoration
|
||
LONG iBank; // Current bank
|
||
PDEV* ppdev; // Saved copy
|
||
|
||
// Public data:
|
||
|
||
SURFOBJ* pso; // Surface wrapped around the bank. Has to be
|
||
// passed as the surface in any banked call-
|
||
// back.
|
||
CLIPOBJ* pco; // Clip object that is the intersection of the
|
||
// original clip object with the bounds of the
|
||
// current bank. Has to be passed as the clip
|
||
// object in any banked call-back.
|
||
|
||
} BANK; /* bnk, pbnk */
|
||
|
||
// Note: BANK_MODE is duplicated in i386\strucs.inc!
|
||
|
||
typedef enum {
|
||
BANK_OFF = 0, // We've finished using the memory aperture
|
||
BANK_ON, // We're about to use the memory aperture
|
||
BANK_ON_NO_WAIT, // We're about to use the memory aperture, and are
|
||
// doing our own hardware synchronization
|
||
BANK_DISABLE, // We're about to enter full-screen; shut down banking
|
||
BANK_ENABLE, // We've exited full-screen; re-enable banking
|
||
|
||
} BANK_MODE; /* bankm, pbankm */
|
||
|
||
typedef struct _BANKDATA {
|
||
ULONG ulDumb; // !!!!!!!!
|
||
|
||
} BANKDATA; /* bd, pbd */
|
||
|
||
typedef VOID (FNBANKMAP)(PDEV*, BANKDATA*, LONG);
|
||
typedef VOID (FNBANKSELECTMODE)(PDEV*, BANKDATA*, BANK_MODE);
|
||
typedef VOID (FNBANKINITIALIZE)(PDEV*, BANKDATA*);
|
||
typedef BOOL (FNBANKCOMPUTE)(PDEV*, RECTL*, RECTL*, LONG*, LONG*);
|
||
|
||
VOID vBankStart(PDEV*, RECTL*, CLIPOBJ*, BANK*);
|
||
BOOL bBankEnum(BANK*);
|
||
|
||
FNBANKCOMPUTE bBankComputeNonPower2;
|
||
FNBANKCOMPUTE bBankComputePower2;
|
||
|
||
BOOL bEnableBanking(PDEV*);
|
||
VOID vDisableBanking(PDEV*);
|
||
VOID vAssertModeBanking(PDEV*, BOOL);
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Pointer stuff
|
||
|
||
#define MONO_POINTER_UP 0x0001
|
||
#define NO_HARDWARE_CURSOR 0x0002
|
||
|
||
#define CURSOR_CY 64
|
||
#define CURSOR_CX 64
|
||
|
||
typedef struct _CUROBJ
|
||
{
|
||
POINTL ptlHotSpot; // Pointer hot spot
|
||
SIZEL szlPointer; // Extent of the pointer
|
||
POINTL ptlLastPosition; // Last position of pointer
|
||
POINTL ptlLastOffset; // Last offset from 0,0 within cursor
|
||
ULONG flPointer; // Pointer specific flags.
|
||
ULONG mono_offset; // Hardware cursor offset
|
||
POINTL hwCursor;
|
||
} CUROBJ, *PCUROBJ;
|
||
|
||
BOOL bEnablePointer(PDEV*);
|
||
VOID vDisablePointer(PDEV*);
|
||
VOID vAssertModePointer(PDEV*, BOOL);
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Palette stuff
|
||
|
||
BOOL bEnablePalette(PDEV*);
|
||
VOID vDisablePalette(PDEV*);
|
||
VOID vAssertModePalette(PDEV*, BOOL);
|
||
|
||
BOOL bInitializePalette(PDEV*, DEVINFO*);
|
||
VOID vUninitializePalette(PDEV*);
|
||
|
||
#define MAX_CLUT_SIZE (sizeof(VIDEO_CLUT) + (sizeof(ULONG) * 256))
|
||
|
||
#define REDSHIFT ((ppdev->flRed & 1)? 0:((ppdev->flRed & 0x100)? 8:16))
|
||
#define GREENSHIFT ((ppdev->flGreen & 1)? 0:((ppdev->flGreen & 0x100)? 8:16))
|
||
#define BLUESHIFT ((ppdev->flBlue & 1)? 0:((ppdev->flBlue & 0x100)? 8:16))
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Low-level blt function prototypes
|
||
|
||
typedef VOID (FNXFER)(PDEV*, LONG, RECTL*, ULONG, SURFOBJ*, POINTL*,
|
||
RECTL*, XLATEOBJ*);
|
||
typedef VOID (FNCOPY)(PDEV*, LONG, RECTL*, ULONG, POINTL*, RECTL*);
|
||
typedef BOOL (FNTEXTOUT)(PDEV*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*,
|
||
BRUSHOBJ*, BRUSHOBJ*);
|
||
typedef VOID (FNLINETOTRIVIAL)(PDEV*, LONG, LONG, LONG, LONG, ULONG, MIX, RECTL*);
|
||
typedef VOID (FNPATREALIZE)(PDEV*, RBRUSH*);
|
||
|
||
FNFILL vI32FillPatColor;
|
||
FNFILL vI32FillPatMonochrome;
|
||
FNFILL vI32FillSolid;
|
||
FNXFER vI32Xfer1bpp;
|
||
FNXFER vI32Xfer4bpp;
|
||
FNXFER vI32Xfer8bpp;
|
||
FNXFER vI32XferNative;
|
||
FNCOPY vI32CopyBlt;
|
||
FNLINETOTRIVIAL vI32LineToTrivial;
|
||
FNTEXTOUT bI32TextOut;
|
||
|
||
FNFILL vM32FillPatColor;
|
||
FNFILL vM32FillPatMonochrome;
|
||
FNFILL vM32FillSolid;
|
||
FNXFER vM32Xfer1bpp;
|
||
FNXFER vM32Xfer4bpp;
|
||
FNXFER vM32Xfer8bpp;
|
||
FNXFER vM32XferNative;
|
||
FNCOPY vM32CopyBlt;
|
||
FNLINETOTRIVIAL vM32LineToTrivial;
|
||
FNTEXTOUT bM32TextOut;
|
||
|
||
FNFILL vM64FillPatColor;
|
||
FNFILL vM64FillPatMonochrome;
|
||
FNFILL vM64FillSolid;
|
||
FNXFER vM64Xfer1bpp;
|
||
FNXFER vM64Xfer4bpp;
|
||
FNXFER vM64Xfer8bpp;
|
||
FNXFER vM64XferNative;
|
||
FNCOPY vM64CopyBlt;
|
||
FNCOPY vM64CopyBlt_VTA4;
|
||
FNLINETOTRIVIAL vM64LineToTrivial;
|
||
FNTEXTOUT bM64TextOut;
|
||
FNPATREALIZE vM64PatColorRealize;
|
||
|
||
FNFILL vM64FillPatColor24;
|
||
FNFILL vM64FillPatMonochrome24;
|
||
FNFILL vM64FillSolid24;
|
||
FNXFER vM64XferNative24;
|
||
FNCOPY vM64CopyBlt24;
|
||
FNCOPY vM64CopyBlt24_VTA4;
|
||
FNLINETOTRIVIAL vM64LineToTrivial24;
|
||
FNTEXTOUT bM64TextOut24;
|
||
|
||
typedef VOID (FNXFERBITS)(PDEV*, SURFOBJ*, RECTL*, POINTL*);
|
||
|
||
FNXFERBITS vPutBits;
|
||
FNXFERBITS vGetBits;
|
||
FNXFERBITS vI32PutBits;
|
||
FNXFERBITS vI32GetBits;
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Low-level hardware cursor function prototypes
|
||
|
||
typedef VOID (FNSETCURSOROFFSET)(PDEV*);
|
||
typedef VOID (FNUPDATECURSOROFFSET)(PDEV*,LONG,LONG,LONG);
|
||
typedef VOID (FNUPDATECURSORPOSITION)(PDEV*,LONG,LONG);
|
||
typedef VOID (FNCURSOROFF)(PDEV*);
|
||
typedef VOID (FNCURSORON)(PDEV*,LONG);
|
||
typedef VOID (FNPOINTERBLIT)(PDEV*,LONG,LONG,LONG,LONG,BYTE*,LONG);
|
||
|
||
FNSETCURSOROFFSET vM64SetCursorOffset;
|
||
FNUPDATECURSOROFFSET vM64UpdateCursorOffset;
|
||
FNUPDATECURSORPOSITION vM64UpdateCursorPosition;
|
||
FNCURSOROFF vM64CursorOff;
|
||
FNCURSORON vM64CursorOn;
|
||
FNSETCURSOROFFSET vM64SetCursorOffset_TVP;
|
||
FNUPDATECURSOROFFSET vM64UpdateCursorOffset_TVP;
|
||
FNUPDATECURSORPOSITION vM64UpdateCursorPosition_TVP;
|
||
FNCURSOROFF vM64CursorOff_TVP;
|
||
FNCURSORON vM64CursorOn_TVP;
|
||
FNSETCURSOROFFSET vM64SetCursorOffset_IBM514;
|
||
FNUPDATECURSOROFFSET vM64UpdateCursorOffset_IBM514;
|
||
FNUPDATECURSORPOSITION vM64UpdateCursorPosition_IBM514;
|
||
FNCURSOROFF vM64CursorOff_IBM514;
|
||
FNCURSORON vM64CursorOn_IBM514;
|
||
FNUPDATECURSOROFFSET vM64UpdateCursorOffset_CT;
|
||
FNCURSOROFF vM64CursorOff_CT;
|
||
FNCURSORON vM64CursorOn_CT;
|
||
FNPOINTERBLIT vM64PointerBlit;
|
||
FNPOINTERBLIT vM64PointerBlit_TVP;
|
||
FNPOINTERBLIT vM64PointerBlit_IBM514;
|
||
|
||
FNSETCURSOROFFSET vI32SetCursorOffset;
|
||
FNUPDATECURSOROFFSET vI32UpdateCursorOffset;
|
||
FNUPDATECURSORPOSITION vI32UpdateCursorPosition;
|
||
FNCURSOROFF vI32CursorOff;
|
||
FNCURSORON vI32CursorOn;
|
||
FNPOINTERBLIT vI32PointerBlit;
|
||
|
||
FNPOINTERBLIT vPointerBlitLFB;
|
||
|
||
#if TARGET_BUILD > 351
|
||
|
||
///////////////////////////////////////////////////////////////////////
|
||
// DirectDraw stuff
|
||
|
||
typedef struct _FLIPRECORD
|
||
{
|
||
FLATPTR fpFlipFrom;
|
||
LONGLONG liFlipTime;
|
||
LONGLONG liFlipDuration;
|
||
DWORD wFlipScanLine;
|
||
BOOL bHaveEverCrossedVBlank;
|
||
BOOL bWasEverInDisplay;
|
||
BOOL bFlipFlag;
|
||
WORD wstartOfVBlank;// only used in MACH32
|
||
|
||
} FLIPRECORD;
|
||
typedef FLIPRECORD *LPFLIPRECORD;
|
||
|
||
#define ROUND_UP_TO_64K(x) (((ULONG)(x) + 0x10000 - 1) & ~(0x10000 - 1))
|
||
#define ROUND_DOWN_TO_64K(x) (((ULONG)(x) & 0xFFFF0000 ))
|
||
|
||
BOOL bEnableDirectDraw(PDEV*);
|
||
VOID vDisableDirectDraw(PDEV*);
|
||
VOID vAssertModeDirectDraw(PDEV*, BOOL);
|
||
|
||
#endif
|
||
|
||
////////////////////////////////////////////////////////////////////////
|
||
// Capabilities flags
|
||
|
||
typedef enum {
|
||
CAPS_MONOCHROME_PATTERNS = 1, // Hardware has 8x8 monochrome pattern
|
||
// capability in this mode
|
||
CAPS_COLOR_PATTERNS = 2, // Capable of colour patterns. I.e.,
|
||
// running at 8bpp on Mach32, and
|
||
// a brush cache has been allocated
|
||
// on the Mach64
|
||
CAPS_LINEAR_FRAMEBUFFER = 4, // Frame buffer is mapped linearly
|
||
} CAPS;
|
||
|
||
// DIRECT_ACCESS returns TRUE if there is any sort of aperture that
|
||
// can be directly accessed:
|
||
|
||
#define DIRECT_ACCESS(ppdev) (ppdev->iAperture != APERTURE_NONE)
|
||
|
||
////////////////////////////////////////////////////////////////////////
|
||
// The Physical Device data structure
|
||
|
||
typedef struct _PDEV
|
||
{
|
||
#ifdef OGLMCD //start OGLMCD support
|
||
|
||
DWORD dwSize; // size of PDEV structure; used by atimcd.dll
|
||
|
||
// All the OpenGL MCD support in the PDEV must be at the begining of the structure
|
||
// because atimcd.dll and ati.dll don't have to be in sync, but any additions to PDEV
|
||
// that can affect the MCD used field's offset in the structure will break the MCD
|
||
|
||
// new fields for MCDOGL containing revision no.
|
||
BYTE MCDMajorRev;
|
||
BYTE MCDMinorRev;
|
||
|
||
|
||
////////// This is only for OGL MCD support
|
||
//functions pointers to ALLOC and FREE functions from heap.c
|
||
// CJ PFN pohAllocate;
|
||
// CJ PFN pohFree;
|
||
OH* (*pohAllocate)(PDEV*, POINTL*, LONG, LONG, FLOH);
|
||
OH* (*pohFree)(PDEV*, OH*);
|
||
|
||
ULONG iUniqueness; // display uniqueness for tracking
|
||
// resolution changes
|
||
LONG cDoubleBufferRef; // Reference count for current number
|
||
// of RC's that have active double-
|
||
// buffers
|
||
OH* pohBackBuffer; // Our 2-d heap allocation structure
|
||
// for the back-buffer
|
||
ULONG ulBackBuffer; // Byte offset in the frame buffer
|
||
// to the start of the back-buffer
|
||
LONG cZBufferRef; // Reference count for current number
|
||
// of RC's that have active z-buffers
|
||
// (which, on Athenta, is all RC's)
|
||
OH* pohZBuffer; // Our 2-d heap allocation structure
|
||
// for the z-buffer
|
||
ULONG ulFrontZBuffer; // Byte offset in the frame buffer
|
||
// to the start of the front z-buffer
|
||
// (the MGA sometimes has to have
|
||
// separate z-buffers for front and
|
||
// back)
|
||
ULONG ulBackZBuffer; // Byte offset in the frame buffer
|
||
// to the start of the back z-buffer
|
||
|
||
HANDLE hMCD; // Handle to MCD engine dll
|
||
MCDENGESCFILTERFUNC pMCDFilterFunc; // MCD engine filter function
|
||
|
||
HANDLE hMCD_ATI; // Handle to ATI MCD driver dll
|
||
PFN pMCDrvGetEntryPoints; // ATI MCD function for filling supported functions index
|
||
|
||
#endif // end OGLMCD
|
||
|
||
LONG xOffset; // Pixel offset from (0, 0) to current
|
||
LONG yOffset; // DFB located in off-screen memory
|
||
BYTE* pjMmBase; // Start of memory mapped I/O
|
||
BYTE* VideoRamBase; // fixup for pjMmBase so that vDisableHardware can free it
|
||
UCHAR* pjIoBase; // Start of I/O space (NULL on x86)
|
||
BYTE* pjScreen; // Points to base screen address
|
||
LONG lDelta; // Distance from one scan to the next.
|
||
LONG cPelSize; // 0 if 8bpp, 1 if 16bpp, 2 if 32bpp
|
||
LONG cjPelSize; // 1 if 8bpp, 2 if 16bpp, 3 if 24bpp,
|
||
// 4 if 32bpp
|
||
ULONG iBitmapFormat; // BMF_8BPP or BMF_16BPP or BMF_32BPP
|
||
// (our current colour depth)
|
||
LONG iBoard; // Logical multi-board identifier
|
||
// (zero by default)
|
||
|
||
// Important data for accessing the frame buffer.
|
||
|
||
VOID* pvBankData; // Points to aulBankData[0]
|
||
FNBANKSELECTMODE* pfnBankSelectMode; // Routine to enable or disable
|
||
// direct frame buffer access
|
||
BANK_MODE bankmOnOverlapped; // BANK_ON or BANK_ON_NO_WAIT,
|
||
// depending on whether card
|
||
// can handle simulataneous
|
||
// frame buffer and accelerator
|
||
// access
|
||
|
||
// -------------------------------------------------------------------
|
||
// NOTE: Changes up to here in the PDEV structure must be reflected in
|
||
// i386\strucs.inc (assuming you're on an x86, of course)!
|
||
|
||
ASIC iAsic; // Specific Mach ASIC type
|
||
APERTURE iAperture; // Aperture type
|
||
ULONG ulTearOffset; // For uneven scans in 1152 or 1280 in 24bpp, and 1600 in 16bpp (mach64 only)
|
||
ULONG ulVramOffset; // ulTearOffset / 8
|
||
ULONG ulScreenOffsetAndPitch; // Screen offset and pitch for primary
|
||
// display
|
||
ULONG ulMonoPixelWidth; // Default value of DP_PIX_WID register
|
||
ULONG SetGuiEngineDefault; // new feature for Rage II+ and above
|
||
|
||
CAPS flCaps; // Capabilities flags
|
||
BOOL bEnabled; // In graphics mode (not full-screen)
|
||
|
||
HANDLE hDriver; // Handle to \Device\Screen
|
||
HDEV hdevEng; // Engine's handle to PDEV
|
||
HSURF hsurfScreen; // Engine's handle to screen surface
|
||
DSURF* pdsurfScreen; // Our private DSURF for the screen
|
||
HSURF hsurfPunt; // Just for 24bpp mach32 with linear aperture
|
||
|
||
LONG cxScreen; // Visible screen width
|
||
LONG cyScreen; // Visible screen height
|
||
LONG cxMemory; // Width of Video RAM
|
||
LONG cyMemory; // Height of Video RAM
|
||
LONG cBitsPerPel; // Bits per pel (8, 15, 16, 24 or 32)
|
||
ULONG ulMode; // Mode the mini-port driver is in.
|
||
|
||
FLONG flHooks; // What we're hooking from GDI
|
||
ULONG ulWhite; // 0xff if 8bpp, 0xffff if 16bpp,
|
||
// 0xffffffff if 32bpp
|
||
VOID* pvTmpBuffer; // General purpose temporary buffer,
|
||
// TMP_BUFFER_SIZE bytes in size
|
||
// (Remember to synchronize if you
|
||
// use this for device bitmaps or
|
||
// async pointers)
|
||
|
||
MACHTYPE iMachType; // Type of I/O to do based on Mach type
|
||
ULONG FeatureFlags; // ENH_VERSION_NT FeatureFlags
|
||
|
||
ATI_MODE_INFO *pModeInfo; // ATI-specific mode information (see ATINT.H)
|
||
|
||
////////// Context stuff
|
||
|
||
BYTE *pjContextBase;
|
||
ULONG ulContextCeiling; // Keep track of available contexts
|
||
ULONG iDefContext; // Used to initialize graphics operations
|
||
|
||
////////// Low-level blt function pointers:
|
||
|
||
FNFILL* pfnFillSolid;
|
||
FNFILL* pfnFillPatColor;
|
||
FNFILL* pfnFillPatMonochrome;
|
||
FNXFER* pfnXfer1bpp;
|
||
FNXFER* pfnXfer4bpp;
|
||
FNXFER* pfnXfer8bpp;
|
||
FNXFER* pfnXferNative;
|
||
FNCOPY* pfnCopyBlt;
|
||
FNTEXTOUT* pfnTextOut;
|
||
FNLINETOTRIVIAL* pfnLineToTrivial;
|
||
|
||
FNXFERBITS* pfnGetBits;
|
||
FNXFERBITS* pfnPutBits;
|
||
|
||
////////// Palette stuff:
|
||
|
||
PALETTEENTRY* pPal; // The palette if palette managed
|
||
HPALETTE hpalDefault; // GDI handle to the default palette.
|
||
FLONG flRed; // Red mask for 16/32bpp bitfields
|
||
FLONG flGreen; // Green mask for 16/32bpp bitfields
|
||
FLONG flBlue; // Blue mask for 16/32bpp bitfields
|
||
ULONG cPaletteShift; // number of bits the 8-8-8 palette must
|
||
// be shifted by to fit in the hardware
|
||
// palette.
|
||
////////// Heap stuff:
|
||
|
||
HEAP heap; // All our off-screen heap data
|
||
ULONG iHeapUniq; // Incremented every time room is freed
|
||
// in the off-screen heap
|
||
SURFOBJ* psoPunt; // Wrapper surface for having GDI draw
|
||
// on off-screen bitmaps
|
||
SURFOBJ* psoPunt2; // Another one for off-screen to off-
|
||
// screen blts
|
||
OH* pohScreen; // Off-screen heap structure for the
|
||
// visible screen
|
||
|
||
////////// Banking stuff:
|
||
|
||
LONG cjBank; // Size of a bank, in bytes
|
||
LONG cPower2ScansPerBank; // Used by 'bBankComputePower2'
|
||
LONG cPower2BankSizeInBytes; // Used by 'bBankComputePower2'
|
||
CLIPOBJ* pcoBank; // Clip object for banked call backs
|
||
SURFOBJ* psoBank; // Surface object for banked call backs
|
||
ULONG aulBankData[BANK_DATA_SIZE / 4];
|
||
// Private work area for downloaded
|
||
// miniport banking code
|
||
|
||
FNBANKMAP* pfnBankMap;
|
||
FNBANKCOMPUTE* pfnBankCompute;
|
||
|
||
////////// Pointer stuff:
|
||
|
||
CUROBJ pointer1; // pointer double-buffering
|
||
CUROBJ pointer2; // pointer double-buffering
|
||
CUROBJ *ppointer;
|
||
BOOL bAltPtrActive;
|
||
|
||
FNSETCURSOROFFSET* pfnSetCursorOffset;
|
||
FNUPDATECURSOROFFSET* pfnUpdateCursorOffset;
|
||
FNUPDATECURSORPOSITION* pfnUpdateCursorPosition;
|
||
FNCURSOROFF* pfnCursorOff;
|
||
FNCURSORON* pfnCursorOn;
|
||
FNPOINTERBLIT* pfnPointerBlit;
|
||
|
||
////////// Brush stuff:
|
||
|
||
LONG iBrushCache; // Index for next brush to be allcoated
|
||
BRUSHENTRY abe[TOTAL_BRUSH_COUNT]; // Keeps track of off-screen brush
|
||
// cache
|
||
|
||
////////// Text stuff:
|
||
|
||
SURFOBJ* psoText; // 1bpp surface to which we will have
|
||
// GDI draw our glyphs for us
|
||
|
||
////////// Stretch stuff:
|
||
|
||
FN_STRETCHDIB* pfnStretchDIB;
|
||
|
||
BYTE* pjMmBase_Ext; // Start of memory mapped I/O
|
||
|
||
////////// Palindrome stuff:
|
||
#if PAL_SUPPORT
|
||
//structure specific for pal support
|
||
PPDEV_PAL_NT pal_str;
|
||
#endif // PALINDROME_SUPPORT
|
||
|
||
////////// Palindrome and Overlay common stuff:
|
||
DWORD semph_overlay; // this semaphore is used for allocating the overlay resource:
|
||
// = 0 ; resource free
|
||
// = 1 ; in use by DDraw
|
||
// = 2 ; in use by Palindrome
|
||
|
||
|
||
#if TARGET_BUILD > 351
|
||
////////// DirectDraw stuff:
|
||
BOOL bPassVBlank; // flag used for detecting the VBlank hang on GX cards on high speed multiprocessors machines
|
||
|
||
FLIPRECORD flipRecord; // Used to track VBlank status
|
||
OH* pohDirectDraw; // Off-screen heap allocation for use
|
||
// by DirectDraw
|
||
// STUFF FOR OVERLAY SUPPORT
|
||
|
||
// this must be in ppdev
|
||
OVERLAYINFO16 OverlayInfo16;
|
||
// the following variables maybe should be in ppdev
|
||
DWORD OverlayWidth,OverlayHeight; //the last updated overlay's width and height
|
||
DWORD OverlayScalingDown;
|
||
|
||
FLATPTR fpVisibleOverlay; // Frame buffer offset to currently
|
||
// visible overlay; will be zero if
|
||
// no overlay is visible
|
||
DWORD dwOverlayFlipOffset; // Overlay flip offset
|
||
// END STUFF FOR OVERLAY SUPP
|
||
|
||
#endif
|
||
|
||
} PDEV;
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Miscellaneous prototypes:
|
||
|
||
BOOL bIntersect(RECTL*, RECTL*, RECTL*);
|
||
LONG cIntersect(RECTL*, RECTL*, LONG);
|
||
DWORD getAvailableModes(HANDLE, PVIDEO_MODE_INFORMATION*, DWORD*);
|
||
|
||
BOOL bInitializeModeFields(PDEV*, GDIINFO*, DEVINFO*, DEVMODEW*);
|
||
BOOL bFastFill(PDEV*, LONG, POINTFIX*, ULONG, ULONG, RBRUSH*, POINTL*, RECTL*);
|
||
|
||
BOOL bEnableHardware(PDEV*);
|
||
VOID vDisableHardware(PDEV*);
|
||
BOOL bAssertModeHardware(PDEV*, BOOL);
|
||
|
||
extern BYTE gaRop3FromMix[];
|
||
extern ULONG gaul32HwMixFromMix[];
|
||
extern ULONG gaul64HwMixFromMix[];
|
||
extern ULONG gaul32HwMixFromRop2[];
|
||
extern ULONG gaul64HwMixFromRop2[];
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// The x86 C compiler insists on making a divide and modulus operation
|
||
// into two DIVs, when it can in fact be done in one. So we use this
|
||
// macro.
|
||
//
|
||
// Note: QUOTIENT_REMAINDER implicitly takes unsigned arguments.
|
||
|
||
#if defined(_X86_)
|
||
|
||
#define QUOTIENT_REMAINDER(ulNumerator, ulDenominator, ulQuotient, ulRemainder) \
|
||
{ \
|
||
__asm mov eax, ulNumerator \
|
||
__asm sub edx, edx \
|
||
__asm div ulDenominator \
|
||
__asm mov ulQuotient, eax \
|
||
__asm mov ulRemainder, edx \
|
||
}
|
||
|
||
#else
|
||
|
||
#define QUOTIENT_REMAINDER(ulNumerator, ulDenominator, ulQuotient, ulRemainder) \
|
||
{ \
|
||
ulQuotient = (ULONG) ulNumerator / (ULONG) ulDenominator; \
|
||
ulRemainder = (ULONG) ulNumerator % (ULONG) ulDenominator; \
|
||
}
|
||
|
||
#endif
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// OVERLAP - Returns TRUE if the same-size lower-right exclusive
|
||
// rectangles defined by 'pptl' and 'prcl' overlap:
|
||
|
||
#define OVERLAP(prcl, pptl) \
|
||
(((prcl)->right > (pptl)->x) && \
|
||
((prcl)->bottom > (pptl)->y) && \
|
||
((prcl)->left < ((pptl)->x + (prcl)->right - (prcl)->left)) && \
|
||
((prcl)->top < ((pptl)->y + (prcl)->bottom - (prcl)->top)))
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// SWAP - Swaps the value of two variables, using a temporary variable
|
||
|
||
#define SWAP(a, b, tmp) { (tmp) = (a); (a) = (b); (b) = (tmp); }
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// These Mul prototypes are thunks for multi-board support:
|
||
|
||
ULONG MulGetModes(HANDLE, ULONG, DEVMODEW*);
|
||
DHPDEV MulEnablePDEV(DEVMODEW*, PWSTR, ULONG, HSURF*, ULONG, ULONG*,
|
||
ULONG, DEVINFO*, HDEV, PWSTR, HANDLE);
|
||
VOID MulCompletePDEV(DHPDEV, HDEV);
|
||
HSURF MulEnableSurface(DHPDEV);
|
||
BOOL MulStrokePath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*,
|
||
POINTL*, LINEATTRS*, MIX);
|
||
BOOL MulFillPath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*,
|
||
MIX, FLONG);
|
||
BOOL MulBitBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
|
||
RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4);
|
||
VOID MulDisablePDEV(DHPDEV);
|
||
VOID MulDisableSurface(DHPDEV);
|
||
BOOL MulAssertMode(DHPDEV, BOOL);
|
||
VOID MulMovePointer(SURFOBJ*, LONG, LONG, RECTL*);
|
||
ULONG MulSetPointerShape(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG,
|
||
LONG, LONG, LONG, RECTL*, FLONG);
|
||
ULONG MulDitherColor(DHPDEV, ULONG, ULONG, ULONG*);
|
||
BOOL MulSetPalette(DHPDEV, PALOBJ*, FLONG, ULONG, ULONG);
|
||
BOOL MulCopyBits(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*);
|
||
BOOL MulTextOut(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*,
|
||
BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX);
|
||
VOID MulDestroyFont(FONTOBJ*);
|
||
BOOL MulPaint(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX);
|
||
BOOL MulRealizeBrush(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*,
|
||
ULONG);
|
||
HBITMAP MulCreateDeviceBitmap(DHPDEV, SIZEL, ULONG);
|
||
VOID MulDeleteDeviceBitmap(DHSURF);
|
||
BOOL MulStretchBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
|
||
COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*,
|
||
ULONG);
|
||
|
||
// These Dbg prototypes are thunks for debugging:
|
||
|
||
ULONG DbgGetModes(HANDLE, ULONG, DEVMODEW*);
|
||
DHPDEV DbgEnablePDEV(DEVMODEW*, PWSTR, ULONG, HSURF*, ULONG, ULONG*,
|
||
ULONG, DEVINFO*, HDEV, PWSTR, HANDLE);
|
||
VOID DbgCompletePDEV(DHPDEV, HDEV);
|
||
HSURF DbgEnableSurface(DHPDEV);
|
||
BOOL DbgLineTo(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG, LONG,
|
||
RECTL*, MIX);
|
||
BOOL DbgStrokePath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*,
|
||
POINTL*, LINEATTRS*, MIX);
|
||
BOOL DbgFillPath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*,
|
||
MIX, FLONG);
|
||
BOOL DbgBitBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
|
||
RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4);
|
||
VOID DbgDisablePDEV(DHPDEV);
|
||
VOID DbgDisableSurface(DHPDEV);
|
||
#if TARGET_BUILD > 351
|
||
BOOL DbgAssertMode(DHPDEV, BOOL);
|
||
#else
|
||
VOID DbgAssertMode(DHPDEV, BOOL);
|
||
#endif
|
||
VOID DbgMovePointer(SURFOBJ*, LONG, LONG, RECTL*);
|
||
ULONG DbgSetPointerShape(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG,
|
||
LONG, LONG, LONG, RECTL*, FLONG);
|
||
ULONG DbgDitherColor(DHPDEV, ULONG, ULONG, ULONG*);
|
||
BOOL DbgSetPalette(DHPDEV, PALOBJ*, FLONG, ULONG, ULONG);
|
||
BOOL DbgCopyBits(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*);
|
||
BOOL DbgTextOut(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*,
|
||
BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX);
|
||
VOID DbgDestroyFont(FONTOBJ*);
|
||
BOOL DbgPaint(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX);
|
||
BOOL DbgRealizeBrush(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*,
|
||
ULONG);
|
||
HBITMAP DbgCreateDeviceBitmap(DHPDEV, SIZEL, ULONG);
|
||
VOID DbgDeleteDeviceBitmap(DHSURF);
|
||
BOOL DbgStretchBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
|
||
COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*,
|
||
ULONG);
|
||
ULONG DbgEscape(SURFOBJ*, ULONG, ULONG, VOID*, ULONG, VOID*);
|
||
|