/******************************Module*Header*******************************\
* Module Name: driver.h
*
* Contains prototypes for the display driver.
*
* Copyright (c) 1992-1996 Microsoft Corporation
\**************************************************************************/
//////////////////////////////////////////////////////////////////////
// Warning: The following define is for private use only. It should
// only be used in such a fashion that when defined as 0,
// all code specific to punting is optimized out completely.
//
// ### Not sure if this should go in or not.
#define DRIVER_PUNT_ALL 0
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Put all the conditional-compile constants here. There had better
// not be many!
// Set this bit when GDI's HOOK_SYNCHRONIZEACCESS works so that we don't
// have to worry about synchronizing device-bitmap access. Note that
// this wasn't an option in the first release of NT:
#define SYNCHRONIZEACCESS_WORKS 1
#define DIRECT_ACCESS(ppdev) 1
// When running on an x86, we can make banked call-backs to GDI where
// GDI can write directly on the frame buffer. The Alpha has a weird
// bus scheme, and can't do that:
#if !defined(_ALPHA_)
#define GDI_BANKING 1
#else
#define GDI_BANKING 1 // was 0
#endif
// Both fast and slow patterns are enabled by default:
#define FASTFILL_PATTERNS 1
#define SLOWFILL_PATTERNS 1
// Useful for visualizing the 2-d heap:
#define DEBUG_HEAP 0
//////////////////////////////////////////////////////////////////////
// Miscellaneous shared stuff
#define DLL_NAME L"w32" // Name of the DLL in UNICODE
#define STANDARD_DEBUG_PREFIX "W32: " // All debug output is prefixed
// by this string
#define ALLOC_TAG '23WD' // Four byte tag (characters in
// reverse order) used for memory
// allocations
#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).
#if defined(ALPHA)
#define XFER_BUFFERS 16 // Defines the maximum number of write buffers
// possible on any Alpha. Must be a power
#else // of two.
#define XFER_BUFFERS 1 // On non-alpha systems, we don't have to
// worry about the chip caching our bus
#endif // writes.
#define XFER_MASK (XFER_BUFFERS - 1)
typedef struct _CLIPENUM {
LONG c;
RECTL arcl[CLIP_LIMIT]; // Space for enumerating complex clipping
} CLIPENUM; /* ce, pce */
typedef struct _PDEV PDEV; // Handy forward declaration
VOID vSetClipping(PDEV*, RECTL*);
VOID vResetClipping(PDEV*);
//////////////////////////////////////////////////////////////////////
// Text stuff
typedef struct _XLATECOLORS { // Specifies foreground and background
ULONG iBackColor; // colours for faking a 1bpp XLATEOBJ
ULONG iForeColor;
} XLATECOLORS; /* xlc, pxlc */
BOOL bEnableText(PDEV*);
VOID vDisableText(PDEV*);
VOID vAssertModeText(PDEV*, BOOL);
VOID vFastText(GLYPHPOS*, ULONG, BYTE*, ULONG, ULONG, RECTL*, RECTL*,
FLONG, RECTL*, RECTL*);
VOID vClearMemDword(ULONG*, ULONG);
//////////////////////////////////////////////////////////////////////
// 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
// 'Slow' brushes are used when we don't have hardware pattern capability,
// and we have to handle patterns using screen-to-screen blts:
#define SLOW_BRUSH_CACHE_DIM 3 // Controls the number of brushes cached
// in off-screen memory, when we don't
// have the W32 hardware pattern support.
// We allocate 3 x 3 brushes, so we can
// cache a total of 9 brushes:
#define SLOW_BRUSH_COUNT (SLOW_BRUSH_CACHE_DIM * SLOW_BRUSH_CACHE_DIM)
#define SLOW_BRUSH_DIMENSION 64 // After alignment is taken care of,
// every off-screen brush cache entry
// will be 64 pels in both dimensions
#define SLOW_BRUSH_ALLOCATION (SLOW_BRUSH_DIMENSION + 8)
// Actually allocate 72x72 pels for each
// pattern, using the 8 extra for brush
// alignment
// 'Fast' brushes are used when we have hardware pattern capability:
#define FAST_BRUSH_COUNT 16 // Total number of non-hardware brushes
// cached off-screen
#define FAST_BRUSH_DIMENSION 8 // Every off-screen brush cache entry
// is 8 pels in both dimensions
#define FAST_BRUSH_ALLOCATION 8 // We have to align ourselves, so this is
// the dimension of each brush allocation
// Common to both implementations:
#define RBRUSH_2COLOR 1 // For RBRUSH flags
#define TOTAL_BRUSH_COUNT max(FAST_BRUSH_COUNT, SLOW_BRUSH_COUNT)
// This is the maximum number of brushes
// we can possibly have cached off-screen
#define TOTAL_BRUSH_SIZE 64 // We'll only ever handle 8x8 patterns,
// and this is the number of pels
typedef struct _BRUSHENTRY BRUSHENTRY;
// NOTE: Changes to the RBRUSH or BRUSHENTRY structures must be reflected
// in strucs.inc!
typedef struct _RBRUSH {
FLONG fl; // Type flags
BOOL bTransparent; // TRUE if brush was realized for a transparent
// blt (meaning colours are white and black),
// FALSE if not (meaning it's already been
// colour-expanded to the correct colours).
// Value is undefined if the brush isn't
// 2 colour.
ULONG ulForeColor; // Foreground colour if 1bpp
ULONG ulBackColor; // Background colour if 1bpp
POINTL ptlBrushOrg; // Brush origin of cached pattern. Initial
// value should be -1
BRUSHENTRY* pbe; // 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
} 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*);
VOID vDirectStretch8Narrow(STR_BLT*);
VOID vDirectStretch8(STR_BLT*);
VOID vDirectStretch16(STR_BLT*);
VOID vDirectStretch32(STR_BLT*);
/////////////////////////////////////////////////////////////////////////
// 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 xy; // 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 */
typedef enum {
BANK_OFF = 0, // We've finished using the memory aperture
BANK_ON, // We're about to use the memory aperture
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 VOID (FNBANKMAP)(PDEV*, LONG);
typedef VOID (FNBANKSELECTMODE)(PDEV*, BANK_MODE);
typedef VOID (FNBANKINITIALIZE)(PDEV*, BOOL);
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 POINTER_DATA_SIZE 40 // Number of bytes to allocate for the
// miniport down-loaded pointer code
// working space
#define HW_INVISIBLE_OFFSET 2 // Offset from 'ppdev->yPointerBuffer'
// to the invisible pointer
#define HW_POINTER_DIMENSION 64 // Maximum dimension of default
// (built-in) hardware pointer
#define HW_POINTER_HIDE 63 // Hardware pointer start pixel
// position used to hide the pointer
typedef VOID (FNSHOWPOINTER)(VOID*, BOOL);
typedef VOID (FNMOVEPOINTER)(VOID*, LONG, LONG);
typedef BOOL (FNSETPOINTERSHAPE)(VOID*, LONG, LONG, LONG, LONG, LONG, LONG,
BYTE*);
typedef VOID (FNENABLEPOINTER)(VOID*, BOOL);
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))
/////////////////////////////////////////////////////////////////////////
// DirectDraw stuff
// There's a 64K granularity that applies to the mapping of the frame
// buffer into the application's address space:
#define ROUND_UP_TO_64K(x) (((ULONG)(x) + 0x10000 - 1) & ~(0x10000 - 1))
typedef struct _FLIPRECORD
{
FLATPTR fpFlipFrom; // Surface we last flipped from
LONGLONG liFlipTime; // Time at which last flip
// occured
LONGLONG liFlipDuration; // Precise amount of time it
// takes from vblank to vblank
BOOL bHaveEverCrossedVBlank; // True if we noticed that we
// switched from inactive to
// vblank
BOOL bWasEverInDisplay; // True if we ever noticed that
// we were inactive
BOOL bFlipFlag; // True if we think a flip is
// still pending
} FLIPRECORD;
BOOL bEnableDirectDraw(PDEV*);
VOID vDisableDirectDraw(PDEV*);
VOID vAssertModeDirectDraw(PDEV*, BOOL);
//////////////////////////////////////////////////////////////////////
// Low-level blt function prototypes
typedef VOID (FNFILL)(PDEV*, LONG, RECTL*, ROP4, RBRUSH_COLOR, POINTL*);
typedef VOID (FNXFER)(PDEV*, LONG, RECTL*, ROP4, SURFOBJ*, POINTL*,
RECTL*, XLATEOBJ*);
typedef VOID (FNCOPY)(PDEV*, LONG, RECTL*, ROP4, POINTL*, RECTL*);
typedef VOID (FNFASTPATREALIZE)(PDEV*, RBRUSH*, POINTL*, BOOL);
typedef VOID (FNBITS)(PDEV*, SURFOBJ*, RECTL*, POINTL*);
typedef VOID (FNLOWXFER)(PDEV*, BYTE*, LONG, LONG, LONG);
FNFILL vPatternFillScr;
FNFILL vSolidFillScr;
FNFILL vSolidFillScr24;
FNXFER vSlowXfer1bpp;
FNCOPY vScrToScr;
FNFASTPATREALIZE vFastPatRealize;
FNXFER vXferNativeSrccopy;
FNXFER vXferBlt8i;
FNXFER vXferBlt16i;
FNXFER vXferBlt24i;
FNXFER vXferBlt8p;
FNXFER vXferBlt16p;
FNXFER vXferBlt24p;
FNXFER vXferScreenTo1bpp;
FNBITS vPutBits;
FNBITS vGetBits;
FNBITS vPutBitsLinear;
FNBITS vGetBitsLinear;
FNXFER vET6000SlowXfer1bpp;
FNXFER vXferET6000;
FNLOWXFER vXfer_BYTES;
FNLOWXFER vXfer_DWORDS;
FNLOWXFER vXferI_1_Byte;
FNLOWXFER vXferI_2_Bytes;
FNLOWXFER vXferI_3_Bytes;
FNLOWXFER vXferP_1_Byte;
FNLOWXFER vXferP_2_Bytes;
FNLOWXFER vXferP_3_Bytes;
VOID vPutBits(PDEV*, SURFOBJ*, RECTL*, POINTL*);
VOID vGetBits(PDEV*, SURFOBJ*, RECTL*, POINTL*);
VOID vGetBitsLinear(PDEV*, SURFOBJ*, RECTL*, POINTL*);
VOID vIoSlowPatRealize(PDEV*, RBRUSH*, BOOL);
////////////////////////////////////////////////////////////////////////
// Capabilities flags
//
// These are private flags passed to us from the W32 miniport. They
// come from the high word of the 'AttributeFlags' field of the
// 'VIDEO_MODE_INFORMATION' structure (found in 'ntddvdeo.h') passed
// to us via an 'VIDEO_QUERY_AVAIL_MODES' or 'VIDEO_QUERY_CURRENT_MODE'
// IOCTL.
//
// NOTE: These definitions must match those in the W32 miniport's 'W32.h'!
typedef enum {
CAPS_HW_PATTERNS = 0x00010000, // 8x8 hardware pattern support
CAPS_MM_TRANSFER = 0x00020000, // Memory-mapped image transfers
CAPS_MM_IO = 0x00040000, // Memory-mapped I/O
CAPS_MM_32BIT_TRANSFER = 0x00080000, // Can do 32bit bus size transfers
CAPS_16_ENTRY_FIFO = 0x00100000, // At least 16 entries in FIFO
CAPS_SW_POINTER = 0x00200000, // No hardware pointer; use software
// simulation
CAPS_BT485_POINTER = 0x00400000, // Use Brooktree 485 pointer
CAPS_MASKBLT_CAPABLE = 0x00800000, // Hardware can handle masked blts
CAPS_NEW_BANK_CONTROL = 0x01000000, // Set if 801/805/928 style banking
CAPS_NEWER_BANK_CONTROL = 0x02000000, // Set if 864/964 style banking
CAPS_RE_REALIZE_PATTERN = 0x04000000, // Set if we have to work around the
// 864/964 hardware pattern bug
CAPS_SLOW_MONO_EXPANDS = 0x08000000, // Set if we have to slow down
// monochrome expansions
CAPS_MM_GLYPH_EXPAND = 0x10000000, // Use memory-mapped I/O glyph-
// expand method of drawing text
// (always implied for non-x86)
CAPS_SCALE_POINTER = 0x20000000, // Set if the W32 hardware pointer
// x position has to be scaled by
// two
CAPS_TI025_POINTER = 0x40000000, // Use TI TVP3025 pointer
} CAPS;
#define CAPS_DAC_POINTER (CAPS_BT485_POINTER | CAPS_TI025_POINTER)
////////////////////////////////////////////////////////////////////////
// Miniport stuff
typedef struct {
ULONG ulPhysicalAddress;
ULONG ulLength;
ULONG ulInIoSpace;
PVOID pvVirtualAddress;
} W32_ADDRESS_MAPPING_INFORMATION, *PW32_ADDRESS_MAPPING_INFORMATION;
////////////////////////////////////////////////////////////////////////
// Status flags
typedef enum {
STAT_GLYPH_CACHE = 0x0001, // Glyph cache successfully allocated
STAT_BRUSH_CACHE = 0x0002, // Brush cache successfully allocated
STAT_DIRECTDRAW = 0x0004, // DirectDraw is enabled
} STATUS;
////////////////////////////////////////////////////////////////////////
// The Physical Device data structure
typedef struct _PDEV
{
LONG xOffset;
LONG yOffset;
LONG xyOffset;
BYTE* pjBase; // Video coprocessor base
BYTE* pjScreen; // Points to base screen address
LONG iBoard; // Logical multi-board identifier
// (zero by default)
ULONG iBitmapFormat; // BMF_8BPP or BMF_16BPP or BMF_24BPP
// (our current colour depth)
ULONG ulChipID;
ULONG ulRevLevel;
// Precomputed values for the three aperatures in linear memory.
BYTE* pjMmu0;
BYTE* pjMmu1;
BYTE* pjMmu2;
// -------------------------------------------------------------------
// NOTE: Changes up to here in the PDEV structure must be reflected in
// i386\strucs.inc (assuming you're on an x86, of course)!
CAPS flCaps; // Capabilities flags
STATUS flStatus; // Status 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
LONG cxScreen; // Visible screen width
LONG cyScreen; // Visible screen height
LONG cxMemory; // Width of Video RAM
LONG cyMemory; // Height of Video RAM
ULONG ulMode; // Mode the mini-port driver is in.
LONG lDelta; // Distance from one scan to the next.
FLONG flHooks; // What we're hooking from GDI
LONG cPelSize; // 0 if 8bpp, 1 if 16bpp, 2 if 32bpp
LONG cBpp; // 1 if 8bpp, 2 if 16bpp, 3 if 32bpp
ULONG ulWhite; // 0xff if 8bpp, 0xffff if 16bpp,
// 0xffffffff if 32bpp
UCHAR* pucCsrBase; // Mapped IO port base for this PDEV
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)
UCHAR* apjMmXfer[XFER_BUFFERS];// Pre-computed array of unique
USHORT* apwMmXfer[XFER_BUFFERS];// addresses for doing memory-mapped
ULONG* apdMmXfer[XFER_BUFFERS];// transfers without memory barriers
////////// Low-level blt function pointers:
FNFILL* pfnFillSolid;
FNFILL* pfnFillPat;
FNXFER* pfnXfer1bpp;
FNXFER* pfnXferNative;
FNCOPY* pfnCopyBlt;
FNFASTPATREALIZE* pfnFastPatRealize;
FNBITS* pfnGetBits;
FNBITS* 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
////////// 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; // Allocation structure for the screen
////////// Banking stuff:
BOOL bAutoBanking; // True if the system is set up to have
// the memory manager do the banking
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
SURFOBJ* psoFrameBuffer; // Surface object for non-banked call backs
VOID* pvBankData; // Points to aulBankData[0]
ULONG aulBankData[BANK_DATA_SIZE / 4];
// Private work area for downloaded
// miniport banking code
FNBANKMAP* pfnBankMap;
FNBANKSELECTMODE* pfnBankSelectMode;
FNBANKCOMPUTE* pfnBankCompute;
////////// Pointer stuff:
LONG xPointerHot; // xHot of current hardware pointer
LONG yPointerHot; // yHot of current hardware pointer
LONG cjPointerOffset; // Byte offset from start of frame
// buffer to off-screen memory where
// we stored the pointer shape
LONG xPointerShape; // x-coordinate
LONG yPointerShape; // y-coordinate
LONG iPointerBank; // Bank containing pointer shape
VOID* pvPointerShape; // Points to pointer shape when bank
// is mapped in
LONG dyPointer; // Start y-pixel position for the
// current pointer
LONG cPointerShift; // Horizontal scaling factor for
// hardware pointer position
ULONG ulHwGraphicsCursorModeRegister_45;
// Default value for index 45
VOID* pvPointerData; // Points to ajPointerData[0]
BYTE ajPointerData[POINTER_DATA_SIZE];
// Private work area for downloaded
// miniport pointer code
FNSHOWPOINTER* pfnShowPointer;
FNMOVEPOINTER* pfnMovePointer;
FNSETPOINTERSHAPE* pfnSetPointerShape;
FNENABLEPOINTER* pfnEnablePointer;
////////// Brush stuff:
BOOL bRealizeTransparent; // Hint to DrvRealizeBrush for whether
// the brush should be realized as
// transparent or not
LONG iBrushCache; // Index for next brush to be allocated
LONG cBrushCache; // Total number of brushes cached
BRUSHENTRY abe[TOTAL_BRUSH_COUNT]; // Keeps track of brush cache
// W32 specific stuff
BYTE* pjPorts; // Video port base
ULONG w32PatternWrap; // Value for the Pattern Wrap register
// 8x8 pixels (varies with pel depth)
W32MMUINFO w32MmuInfo;
ULONG ulSolidColorOffset;
W32SPRITEDATA W32SpriteData;
// Rendering extensions colour information.
UCHAR rDepth; // Number of red bits
UCHAR gDepth; // Number of green bits
UCHAR bDepth; // Number of blue bits
UCHAR aDepth; // Number of alpha bits
UCHAR rBitShift; // Left bit-shift for red component
UCHAR gBitShift; // Left bit-shift for green component
UCHAR bBitShift; // Left bit-shift for blue component
UCHAR aBitShift; // Left bit-shift for alpha component
#if 0
////////// DCI stuff:
BOOL bSupportDCI; // True if miniport supports DCI
////////// 3D DDI Rendering Extension stuff:
VOID* pvOut; // Points to current output buffer
VOID* pvOutMax; // Points to end of current output buffer
VOID* pvInMax; // Points to end of current input buffer
OH* pohFrontBuffer; // Allocation structure for the screen
OH* pohBackBuffer; // Allocation structure for optional
// off-screen back buffer
LONG cDoubleBufferRef; // Reference count for current number
// of RC's that have active double-
// buffers
POINTL ptlDoubleBuffer[2]; // (x, y) positions of front and back
// buffers in video memory
// 0 -- RX_BACK_LEFT
// 1 -- RX_FRONT_LEFT
// Note: Make sure that the index
// is in the range [0, 1]!
#endif
// Extensions added for the ET6000
LONG lBltBufferPitch; // Pitch of our blt buffer.
OH* pohBltBuffer; // Pointer to offscreen memory used for
// double buffering blts and stretches.
ULONG PCIConfigSpaceAddr; // The Offset into IO space for PCI Cfg data
/////////// DirectDraw stuff:
FLIPRECORD flipRecord; // Used to track VBlank status
DWORD dwLinearCnt; // Reference count of active
// DirectDraw Locks
OH* pohDirectDraw; // Off-screen heap allocation for use
// by DirectDraw
} PDEV, *PPDEV;
/////////////////////////////////////////////////////////////////////////
// Miscellaneous prototypes:
BOOL bIntersect(RECTL*, RECTL*, RECTL*);
LONG cIntersect(RECTL*, RECTL*, LONG);
BOOL bFastFill(PDEV*, LONG, POINTFIX*, ULONG, ULONG, ULONG, RBRUSH*);
DWORD getAvailableModes(HANDLE, PVIDEO_MODE_INFORMATION*, DWORD*);
BOOL bInitializeModeFields(PDEV*, GDIINFO*, DEVINFO*, DEVMODEW*);
BOOL bEnableHardware(PDEV*);
VOID vDisableHardware(PDEV*);
BOOL bAssertModeHardware(PDEV*, BOOL);
extern BYTE aMixToRop3[];
/////////////////////////////////////////////////////////////////////////
// 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(i386)
#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 SWAP32(a, b) \
{ \
register ULONG tmp; \
tmp = (ULONG)(a); \
(ULONG)(a) = (ULONG)(b); \
(ULONG)(b) = tmp; \
}
#define SWAP(a, b, tmp) { (tmp) = (a); (a) = (b); (b) = (tmp); }
//////////////////////////////////////////////////////////
_inline ULONG COLOR_REPLICATE(PDEV* ppdev, ULONG x)
{
ULONG ulResult = x;
if (ppdev->cBpp == 1)
{
ulResult |= (ulResult << 8);
}
if (ppdev->cBpp <= 2)
{
ulResult |= (ulResult << 16);
}
return(ulResult);
}
/////////////////////////////////////////////////////////////////////////
// DUMPVAR - Dumps a variable name and value to the debugger.
// usage -> DUMPVAR(ppdev->cjPointerOffset,"%xh");
#define DUMPVAR(x,format_str) DISPDBG((0,#x" = "format_str,x));