able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/video/ms/cirrus/disp/driver.h

1313 lines
50 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/******************************************************************************\
*
* $Workfile: driver.h $
*
* Contains prototypes for the display driver.
*
* Copyright (c) 1992-1995 Microsoft Corporation
* Copyright (c) 1996 Cirrus Logic, Inc.
*
*
* $Log: S:/projects/drivers/ntsrc/display/driver.h_v $
*
* Rev 1.7 Apr 03 1997 15:38:48 unknown
*
*
* Rev 1.6 28 Mar 1997 16:08:38 PLCHU
*
*
* Rev 1.5 18 Dec 1996 13:44:08 PLCHU
*
*
* Rev 1.4 Dec 13 1996 12:16:18 unknown
*
*
* Rev 1.3 Nov 07 1996 16:43:40 unknown
* Clean up CAPS flags
*
* Rev 1.1 Oct 10 1996 15:36:36 unknown
*
*
* Rev 1.13 12 Aug 1996 16:47:58 frido
* Added NT 3.5x/4.0 auto detection.
*
* Rev 1.12 08 Aug 1996 16:20:06 frido
* Added vMmCopyBlt36.
*
* Rev 1.11 31 Jul 1996 15:43:42 frido
* Added new brush caches.
*
* Rev 1.10 24 Jul 1996 14:38:24 frido
* Added ulFontCacheID for font cache cleanup.
*
* Rev 1.9 24 Jul 1996 14:30:26 frido
* Changed some structures for a new FONTCACHE chain.
*
* Rev 1.8 22 Jul 1996 20:45:48 frido
* Added font cache.
*
* Rev 1.7 19 Jul 1996 01:00:00 frido
* Added Dbg... declarations.
*
* Rev 1.6 15 Jul 1996 10:58:58 frido
* Changed back to old DirectDraw structures.
*
* Rev 1.5 12 Jul 1996 17:45:38 frido
* Change DirectDraw structures.
*
* Rev 1.4 10 Jul 1996 13:07:34 frido
* Changed LineTo function.
*
* Rev 1.3 09 Jul 1996 17:58:30 frido
* Added LineTo code.
*
* Rev 1.2 03 Jul 1996 13:44:36 frido
* Fixed a typo.
*
* Rev 1.1 03 Jul 1996 13:38:54 frido
* Added DirectDraw support.
*
* sge01 10-23-96 Add 5446BE flag
*
* chu01 12-16-96 Enable color correction
*
* myf0 : 08-19-96 added 85hz supported
* myf1 : 08-20-96 supported panning scrolling
* myf2 : 08-20-96 : fixed hardware save/restore state bug for matterhorn
* myf3 : 09-01-96 : Added IOCTL_CIRRUS_PRIVATE_BIOS_CALL for TV supported
* myf4 : 09-01-96 : patch Viking BIOS bug, PDR #4287, begin
* myf5 : 09-01-96 : Fixed PDR #4365 keep all default refresh rate
* myf6 : 09-17-96 : Merged Desktop SRC100<EFBFBD>1 & MINI10<EFBFBD>2
* myf7 : 09-19-96 : Fixed exclude 60Hz refresh rate selected
* myf8 :*09-21-96*: May be need change CheckandUpdateDDC2BMonitor --keystring[]
* myf9 : 09-21-96 : 8x6 panel in 6x4x256 mode, cursor can't move to bottom scrn
* ms0809:09-25-96 : fixed dstn panel icon corrupted
* ms923 :09-25-96 : merge MS-923 Disp.zip code
* myf10 :09-26-96 : Fixed DSTN reserved half-frame buffer bug.
* myf11 :09-26-96 : Fixed 755x CE chip HW bug, access ramdac before disable HW
* icons and cursor
* myf12 :10-01-96 : Supported Hot Key switch display
* myf13 :10-05-96 : Fixed /w panning scrolling, vertical expension on bug
* myf14 :10-15-96 : Fixed PDR#6917, 6x4 panel can't panning scrolling for 754x
* myf15 :10-16-96 : Fixed disable memory mapped IO for 754x, 755x
* myf16 :10-22-96 : Fixed PDR #6933,panel type set different demo board setting
* tao1 : 10-21-96 : added direct draw support for 7555.
* pat04: 12-20-96 : Supported NT3.51 software cursor with panning scrolling
* myf33 :03-21-97 : Support TV ON/OFF
*
\******************************************************************************/
//////////////////////////////////////////////////////////////////////
// Warning: The following defines are for private use only. They
// should only be used in such a fashion that when defined as 0,
// all code specific to punting is optimized out completely.
#define DRIVER_PUNT_ALL 0
#define DRIVER_PUNT_LINES 0
#define DRIVER_PUNT_BLT 0
#define DRIVER_PUNT_STRETCH 0
#define DRIVER_PUNT_PTR 1
#define DRIVER_PUNT_BRUSH 0
// myf1 09-01-96
//myf17 #define PANNING_SCROLL //myf1
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Put all the conditional-compile constants here. There had better
// not be many!
// Some Mips machines have bus problems that prevent GDI from being able
// to draw on the frame buffer. The DIRECT_ACCESS() macro is used to
// determine if we are running on one of these machines. Also, we map
// video memory as sparse on the ALPHA, so we need to control access to
// the framebuffer through the READ/WRITE_REGISTER macros.
#if defined(_ALPHA_)
#define DIRECT_ACCESS(ppdev) FALSE
#else
#define DIRECT_ACCESS(ppdev) TRUE
#endif
#define BANKING TRUE //ms923
#define HOST_XFERS_DISABLED(ppdev) (ppdev->pulXfer == NULL)
// Useful for visualizing the 2-d heap:
#define DEBUG_HEAP FALSE
//////////////////////////////////////////////////////////////////////
// Miscellaneous shared stuff
#if (_WIN32_WINNT < 0x0400)
// NT 3.51
#define DLL_NAME L"cirrus35" // Name of the DLL in UNICODE
#define NT_VERSION 0x0351
#define ALLOC(c) LocalAlloc(LPTR, c)
#define FREE(ptr) LocalFree(ptr)
#define IOCONTROL(h, ctrl, in, cin, out, cout, c) \
(DeviceIoControl(h, ctrl, in, cin, out, cout, c, NULL) == TRUE)
#else
// NT 4.0
#define DLL_NAME L"cirrus" // Name of the DLL in UNICODE
#define NT_VERSION 0x0400
#define ALLOC(c) EngAllocMem(FL_ZERO_MEMORY, c, ALLOC_TAG)
#define FREE(ptr) EngFreeMem(ptr)
#define IOCONTROL(h, ctrl, in, cin, out, cout, c) \
(EngDeviceIoControl(h, ctrl, in, cin, out, cout, c) == ERROR_SUCCESS)
#endif
// Default values if not yet defined.
#ifndef GDI_DRIVER_VERSION
#define GDI_DRIVER_VERSION 0x3500
#endif
#ifndef VIDEO_MODE_MAP_MEM_LINEAR
#define VIDEO_MODE_MAP_MEM_LINEAR 0x40000000
#endif
#define STANDARD_PERF_PREFIX "Cirrus [perf]: " // All perf output is prefixed
// by this string
#define STANDARD_DEBUG_PREFIX "Cirrus: " // All debug output is prefixed
// by this string
#define ALLOC_TAG ' lcD' // Dcl
// 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).
typedef struct _CLIPENUM {
LONG c;
RECTL arcl[CLIP_LIMIT]; // Space for enumerating complex clipping
} CLIPENUM; /* ce, pce */
////////////////////////////////////////////////////////////////////////////////
// D R I V E R C A P A B I L I T I E S //
////////////////////////////////////////////////////////////////////////////////
#if (NT_VERSION < 0x0400)
#define DIRECTDRAW 0 // DirectDraw not supported in NT 3.5x
#define LINETO 0 // DrvLineTo not supported in NT 3.5x
#else
#define DIRECTDRAW 1 // DirectDraw supported in NT 4.0
#define LINETO 0 // DrvLineTo not supported in NT 4.0
#endif
typedef struct _PDEV PDEV; // Handy forward declaration
//////////////////////////////////////////////////////////////////////
// Text stuff
#if 1 // Font cache.
#define MAX_GLYPHS 256 // Maximum number of glyphs per font.
#define FONT_ALLOC_X 128 // X allocation per font block in bytes.
#define FONT_ALLOC_Y 32 // Maximum height of font.
typedef struct _OH OH;
typedef struct _FONTMEMORY FONTMEMORY;
typedef struct _FONTCACHE FONTCACHE;
typedef struct _FONTMEMORY {
OH* poh; // Pointer to allocated memory block.
LONG x; // Last x of allocation.
LONG cx, cy; // Size of allocation in bytes.
LONG xy; // Linear address of current line.
FONTMEMORY* pfmNext; // Pointer to next allocated memory block.
} FONTMEMORY;
#define GLYPH_UNCACHEABLE -1
#define GLYPH_EMPTY -2
typedef struct _GLYPHCACHE {
BYTE* pjGlyph; // Linear address of glyph.
// If pjPos == NULL then glyph has not yet been cached.
POINTL ptlOrigin; // Origin of glyph.
SIZEL sizlBytes; // Adjusted size of glyph.
SIZEL sizlPixels; // Size of glyph.
// If sizlSize.cy == -1 then glyph if uncacheable.
// If sizlSize.cy == -2 then glyph is empty.
LONG lDelta; // Width of glyph on bytes.
} GLYPHCACHE;
typedef struct _FONTCACHE {
PDEV* ppdev; // Pointer to PDEV structure.
FONTMEMORY* pfm; // Pointer to first FONTMEMORY structure.
LONG cWidth; // Width of allocation in pixels.
LONG cHeight; // Height of allocation in pixels.
ULONG ulFontCacheID; // Font cache ID.
FONTOBJ* pfo; // Pointer to FONT object for this cache.
FONTCACHE* pfcPrev; // Pointer to previous FONTCACHE structure.
FONTCACHE* pfcNext; // Pointer to next FONTCACHE structure.
GLYPHCACHE aGlyphs[MAX_GLYPHS]; // Array of cached glyphs.
} FONTCACHE;
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 vClearMemDword(ULONG*, ULONG);
LONG cGetGlyphSize(GLYPHBITS*, POINTL*, SIZEL*);
LONG lAllocateGlyph(FONTCACHE*, GLYPHBITS*, GLYPHCACHE*);
BYTE* pjAllocateFontCache(FONTCACHE*, LONG);
BOOL bFontCache(PDEV*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, BRUSHOBJ*,
BRUSHOBJ*);
VOID vDrawGlyph(PDEV*, GLYPHBITS*, POINTL);
VOID vClipGlyph(PDEV*, GLYPHBITS*, POINTL, RECTL*, ULONG);
#if 1 // D5480
VOID vMmGlyphOut(PDEV*, FONTCACHE*, STROBJ*, ULONG);
VOID vMmGlyphOutClip(PDEV*, FONTCACHE*, STROBJ*, RECTL*, ULONG);
VOID vMmGlyphOut80(PDEV*, FONTCACHE*, STROBJ*, ULONG);
VOID vMmGlyphOutClip80(PDEV*, FONTCACHE*, STROBJ*, RECTL*, ULONG);
#endif // endif D5480
#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);
VOID vDitherColorToVideoMemory(ULONG*, VERTEX_DATA*, VERTEX_DATA*, ULONG);
//////////////////////////////////////////////////////////////////////
// Brush stuff
// '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
#if 1 // New brush cache.
#define RBRUSH_PATTERN 0 // Colored brush.
#define RBRUSH_MONOCHROME 1 // Monochrome brush.
#define RBRUSH_DITHER 2 // Dithered brush.
#define RBRUSH_XLATE 3 // 16-color translated brush.
#endif
#define TOTAL_BRUSH_COUNT FAST_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
#define BRUSH_TILE_FACTOR 4 // 2x2 tiled patterns require 4x the space
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
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
#if 1 // New brush cache.
ULONG ulUniq; // Unique value for cached brushes.
ULONG ulSlot; // Offset to cache slot (PDEV relative).
ULONG ulBrush; // Offset to off-screen brush.
LONG cjBytes; // Number of bytes in pattern.
#endif
ULONG aulPattern[0]; // 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
LONG xy; // offset 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);
#if 1 // New brush cache.
#define NUM_DITHERS 8
#define NUM_PATTERNS 8
#define NUM_MONOCHROMES 20
typedef struct _DITHERCACHE {
ULONG ulBrush; // Offset to off-screen brush.
ULONG ulColor; // Logical color.
} DITHERCACHE;
typedef struct _PATTERNCACHE {
ULONG ulBrush; // Offset to off-screen brush.
RBRUSH* prbUniq; // Pointer to realized brush.
} PATTERNCACHE;
typedef struct _MONOCACHE {
ULONG ulBrush; // Offset to off-screen brush cache.
ULONG ulUniq; // Unique counter for brush.
ULONG ulBackColor; // Background color for 24-bpp.
ULONG ulForeColor; // Foreground color for 24-bpp.
ULONG aulPattern[2]; // Monochrome pattern.
} MONOCACHE;
BOOL bCacheDither(PDEV*, RBRUSH*);
BOOL bCachePattern(PDEV*, RBRUSH*);
BOOL bCacheMonochrome(PDEV*, RBRUSH*);
#endif
//////////////////////////////////////////////////////////////////////
// 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 vDirectStretch24(STR_BLT*);
VOID vDirectStretch32(STR_BLT*);
#if 1 // D5480 chu01
VOID vDirectStretch8_80(STR_BLT*) ;
VOID vDirectStretch16_80(STR_BLT*) ;
VOID vDirectStretch24_80(STR_BLT*) ;
#endif // D5480 chu01
/////////////////////////////////////////////////////////////////////////
// Heap stuff
typedef enum {
OFL_INUSE = 1, // The device bitmap is no longer located in
// off-screen memory; it's been converted to
// a DIB
OFL_AVAILABLE = 2, // Space is in-use
OFL_PERMANENT = 4 // Space is available
} OHFLAGS; // Space is permanently allocated; never free it
typedef struct _DSURF DSURF;
typedef struct _OH OH;
typedef struct _OH
{
OHFLAGS ofl; // OH_ flags
LONG x; // x-coordinate of left edge of allocation
LONG y; // y-coordinate of top edge of allocation
LONG xy; // offset to top left corner of allocation
LONG cx; // Width in pixels of allocation
LONG cy; // Height in pixels of allocation
OH* pohNext; // When OFL_AVAILABLE, 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 OFL_INUSE, points to the next most recently
// blitted allocation. This is kept as a circular
// doubly-linked list so that the list can be
// quickly be updated on every blt.
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 ohAvailable; // Head of available list (pohNext points to
// smallest available rectangle, pohPrev
// points to largest available rectangle,
// sorted by cxcy)
OH ohDfb; // Head of the list of all DFBs currently in
// offscreen memory that are eligible to be
// tossed out of the heap (pohNext points to
// the most recently blitted; pohPrev points
// to least recently blitted)
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 8
// 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 = 0x00000001, // Don't kick stuff out of off-
// screen memory to make room
} FLOH;
BOOL bEnableOffscreenHeap(PDEV*);
VOID vDisableOffscreenHeap(PDEV*);
BOOL bAssertModeOffscreenHeap(PDEV*, BOOL);
OH* pohMoveOffscreenDfbToDib(PDEV*, OH*);
BOOL bMoveDibToOffscreenDfbIfRoom(PDEV*, DSURF*);
OH* pohAllocatePermanent(PDEV*, LONG, LONG);
BOOL bMoveAllDfbsFromOffscreenToDibs(PDEV* ppdev);
OH* pohAllocate(PDEV*, LONG, LONG, FLOH);
OH* pohFree(PDEV*, OH*);
VOID vCalculateMaximum(PDEV*);
/////////////////////////////////////////////////////////////////////////
// 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
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);
VOID vAssertHWiconcursor(PDEV*, BOOL); //myf11
UCHAR HWcur, HWicon0, HWicon1, HWicon2, HWicon3; //myf11
/////////////////////////////////////////////////////////////////////////
// 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))
#if DIRECTDRAW
//////////////////////////////////////////////////////////////////////
// DirectDraw stuff
#define ROUND_UP_TO_64K(x) (((ULONG)(x) + 0xFFFF) & ~0xFFFF)
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 bFlipFlag; // True if we think a flip is still
// pending
BOOL bHaveEverCrossedVBlank; // True if we noticed that we switched
// from inactive to vblank
BOOL bWasEverInDisplay; // True is we ever noticed that we were
// inactive
// crus
DWORD dwFlipScanLine;
} FLIPRECORD;
BOOL bEnableDirectDraw(PDEV*);
VOID vDisableDirectDraw(PDEV*);
VOID vAssertModeDirectDraw(PDEV*, BOOL);
#endif
//////////////////////////////////////////////////////////////////////
// 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*);
typedef VOID (FNBITS)(PDEV*, SURFOBJ*, RECTL*, POINTL*);
typedef BOOL (FNFASTFILL)(PDEV*, LONG, POINTFIX*, ULONG, ULONG, RBRUSH*,
POINTL*, RECTL*);
#if LINETO
typedef BOOL (FNLINETO)(PDEV*, LONG, LONG, LONG, LONG, ULONG, MIX, ULONG);
#endif
#if 1 // D5480
typedef VOID (FNGLYPHOUT)(PDEV*, FONTCACHE*, STROBJ*, ULONG);
typedef VOID (FNGLYPHOUTCLIP)(PDEV*, FONTCACHE*, STROBJ*, RECTL*, ULONG);
#endif // endif D5480
#if 1 // OVERLAY #sge
#if (_WIN32_WINNT >= 0x0400) //myf33
typedef VOID (FNREGINITVIDEO)(PDEV* ppdev, PDD_SURFACE_LOCAL lpSurface);
typedef VOID (FNREGMOVEVIDEO)(PDEV* ppdev, PDD_SURFACE_LOCAL lpSurface);
typedef BOOL (FNBANDWIDTHEQ)(PDEV* ppdev, WORD wVideoDepth, LPRECTL lpSrc, LPRECTL lpDest, DWORD dwFlags);
typedef VOID (FNDISABLEOVERLAY)(PDEV* ppdev);
typedef VOID (FNCLEARALTFIFO)(PDEV* ppdev);
#endif
#endif
FNFILL vIoFillPat;
FNFILL vIoFillSolid;
FNXFER vIoXfer1bpp;
FNXFER vIoXfer4bpp;
FNXFER vIoXferNative;
FNCOPY vIoCopyBlt;
FNFASTPATREALIZE vIoFastPatRealize;
#if LINETO
FNLINETO bIoLineTo;
#endif
FNFILL vMmFillPat;
FNFILL vMmFillSolid;
#if 1 // New pattern blt routines.
FNFILL vMmFillPat36;
FNFILL vMmFillSolid36;
FNCOPY vMmCopyBlt36;
#endif
FNXFER vMmXfer1bpp;
FNXFER vMmXfer4bpp;
FNXFER vMmXferNative;
FNCOPY vMmCopyBlt;
FNFASTPATREALIZE vMmFastPatRealize;
#if LINETO
FNLINETO bMmLineTo;
#endif
FNFASTFILL bFastFill;
FNXFER vXferNativeSrccopy;
FNXFER vXferScreenTo1bpp;
FNBITS vPutBits;
FNBITS vGetBits;
FNBITS vPutBitsLinear;
FNBITS vGetBitsLinear;
#if 1 // D5480
FNGLYPHOUT vMmGlyphOut;
FNGLYPHOUT vMmGlyphOut80;
FNGLYPHOUTCLIP vMmGlyphOutClip;
FNGLYPHOUTCLIP vMmGlyphOutClip80;
FNFILL vMmFillSolid80;
FNFILL vMmFillPat80;
FNCOPY vMmCopyBlt80;
FNXFER vMmXfer1bpp80;
FNXFER vMmXferNative80;
#endif // endif D5480
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 video miniport. They
// come from the 'DriverSpecificAttributeFlags' 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 video miniport
#define CAPS_NO_HOST_XFER 0x00000002 // Do not use host xfers to
// the blt engine.
#define CAPS_SW_POINTER 0x00000004 // Use software pointer.
#define CAPS_TRUE_COLOR 0x00000008 // Set upper color registers.
#define CAPS_MM_IO 0x00000010 // Use memory mapped IO.
#define CAPS_BLT_SUPPORT 0x00000020 // BLTs are supported
#define CAPS_IS_542x 0x00000040 // This is a 542x
#define CAPS_AUTOSTART 0x00000080 // Autostart feature support.
#define CAPS_CURSOR_VERT_EXP 0x00000100 // Flag set if 8x6 panel,
#define CAPS_DSTN_PANEL 0x00000200 // DSTN panel in use, ms0809
#define CAPS_VIDEO 0x00000400 // Video support.
#define CAPS_SECOND_APERTURE 0x00000800 // Second aperture support.
#define CAPS_COMMAND_LIST 0x00001000 // Command List support.
#define CAPS_GAMMA_CORRECT 0x00002000 // Color correction.
#define CAPS_VGA_PANEL 0x00004000 // use 6x4 VGA PANEL.
#define CAPS_SVGA_PANEL 0x00008000 // use 8x6 SVGA PANEL.
#define CAPS_XGA_PANEL 0x00010000 // use 10x7 XGA PANEL.
#define CAPS_PANNING 0x00020000 // Panning scrolling supported.
#define CAPS_TV_ON 0x00040000 // TV turn on supported., myf33
#define CAPS_TRANSPARENCY 0x00080000 // Transparency is supported
#define CAPS_ENGINEMANAGED 0x00100000 // Engine managed surface
//myf16, end
////////////////////////////////////////////////////////////////////////
// Status flags
typedef enum {
STAT_GLYPH_CACHE = 0x0001, // Glyph cache successfully allocated
STAT_BRUSH_CACHE = 0x0002, // Brush cache successfully allocated
#if 1 // New status flags.
STAT_DIRECTDRAW = 0x0004, // DirectDraw is enabled.
STAT_FONT_CACHE = 0x0008, // Font cache is available.
STAT_DITHER_CACHE = 0x0010, // Dither cache is available.
STAT_PATTERN_CACHE = 0x0020, // Pattern cache is available.
STAT_MONOCHROME_CACHE = 0x0040, // Monochrome cache is available.
// crus
STAT_STREAMS_ENABLED = 0x0080 // Overlay support
#endif
} STATUS;
// crus
#if 1 // OVERLAY #sge
#define MAX_STRETCH_SIZE 1024
typedef struct
{
RECTL rDest;
RECTL rSrc;
DWORD dwFourcc; //overlay video format
WORD wBitCount; //overlay color depth
LONG lAdjustSource; //when video start address needs adjusting
} OVERLAYWINDOW;
#endif
//
// Merger port and register access
//
#if defined(_X86_) || defined(_IA64_) || defined(_AMD64_)
typedef UCHAR (*FnREAD_PORT_UCHAR)(PVOID Port);
typedef USHORT (*FnREAD_PORT_USHORT)(PVOID Port);
typedef ULONG (*FnREAD_PORT_ULONG)(PVOID Port);
typedef VOID (*FnWRITE_PORT_UCHAR)(PVOID Port, UCHAR Value);
typedef VOID (*FnWRITE_PORT_USHORT)(PVOID Port, USHORT Value);
typedef VOID (*FnWRITE_PORT_ULONG)(PVOID Port, ULONG Value);
#elif defined(_ALPHA_)
typedef UCHAR (*FnREAD_PORT_UCHAR)(PVOID Port);
typedef USHORT (*FnREAD_PORT_USHORT)(PVOID Port);
typedef ULONG (*FnREAD_PORT_ULONG)(PVOID Port);
typedef VOID (*FnWRITE_PORT_UCHAR)(PVOID Port, ULONG Value);
typedef VOID (*FnWRITE_PORT_USHORT)(PVOID Port, ULONG Value);
typedef VOID (*FnWRITE_PORT_ULONG)(PVOID Port, ULONG Value);
#endif
////////////////////////////////////////////////////////////////////////
// The Physical Device data structure
typedef struct _PDEV
{
LONG xOffset;
LONG yOffset;
LONG xyOffset;
BYTE* pjBase; // Video coprocessor base
BYTE* pjPorts; // Video port base
BYTE* pjScreen; // Points to base screen address
ULONG iBitmapFormat; // BMF_8BPP or BMF_16BPP or BMF_24BPP
// (our current colour depth)
ULONG ulChipID;
ULONG ulChipNum;
// -------------------------------------------------------------------
// NOTE: Changes up to here in the PDEV structure must be reflected in
// i386\strucs.inc (assuming you're on an x86, of course)!
HBITMAP hbmTmpMono; // Handle to temporary buffer
SURFOBJ* psoTmpMono; // Temporary surface
ULONG flCaps; // Capabilities flags
//myf1, begin
// Panning Scrolling Supported for TI
LONG min_Xscreen; //Visible screen boundary.
LONG max_Xscreen; //Visible screen boundary.
LONG min_Yscreen; //Visible screen boundary.
LONG max_Yscreen; //Visible screen boundary.
LONG Hres; //current mode horizontal piexl.
LONG Vres; //current mode vertical piexl.
//myf1, end
SHORT bBlockSwitch; //display switch block flag //myf12
SHORT bDisplaytype; //display type, 0:LCD, 1:CRT, 2:SIM //myf12
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 ulMemSize; // Amount of video Memory
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 cBitsPerPixel; // 8 if 8bpp, 16 if 16bpp, 32 if 32bpp
LONG cBpp; // 1 if 8bpp, 2 if 16bpp, 3 if 24bpp, etc.
//
// The compiler should maintain DWORD alignment for the values following
// the BYTE jModeColor. There will be an ASSERT to guarentee this.
//
BYTE jModeColor; // HW flag for current color depth
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)
LONG lXferBank;
ULONG* pulXfer;
////////// Low-level blt function pointers:
FNFILL* pfnFillSolid;
FNFILL* pfnFillPat;
FNXFER* pfnXfer1bpp;
FNXFER* pfnXfer4bpp;
FNXFER* pfnXferNative;
FNCOPY* pfnCopyBlt;
FNFASTPATREALIZE* pfnFastPatRealize;
FNBITS* pfnGetBits;
FNBITS* pfnPutBits;
#if LINETO
FNLINETO* pfnLineTo;
#endif
////////// Palette stuff:
PALETTEENTRY* pPal; // The palette if palette managed
//
// chu01 : GAMMACORRECT
//
PALETTEENTRY* pCurrentPalette ; // The global palette for gamma
// correction.
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:
ULONG ulBankShiftFactor;
BOOL bLinearMode; // True if the framebuffer is linear
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 xPointerShape; // xPos of current hardware pointer
LONG yPointerShape; // yPos of current hardware pointer
SIZEL sizlPointer; // Size of current hardware pointer
//ms923 LONG lDeltaPointer; // Row offset for hardware pointer
FLONG flPointer; // Flags reflecting pointer state
PBYTE pjPointerAndMask;
PBYTE pjPointerXorMask;
LONG iPointerBank; // Bank containing pointer shape
VOID* pvPointerShape; // Points to pointer shape when bank
// is mapped in
LONG cjPointerOffset; // Byte offset from start of frame
// buffer to off-screen memory where
// we stored the pointer shape
//pat04, for NT 3.51 software cursor, begin
#if (_WIN32_WINNT < 0x0400)
#ifdef PANNING_SCROLL
OH* pjCBackground;
OH* pjPointerAndCMask;
OH* pjPointerCBitmap ;
LONG xcount;
LONG ppScanLine;
LONG oldx; // old x cordinate
LONG oldy; // old y cordinate
LONG globdat;
#endif
#endif
//pat04, for NT 3.51 software cursor, end
FNSHOWPOINTER* pfnShowPointer;
FNMOVEPOINTER* pfnMovePointer;
FNSETPOINTERSHAPE* pfnSetPointerShape;
FNENABLEPOINTER* pfnEnablePointer;
////////// Brush stuff:
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
ULONG ulSolidColorOffset;
ULONG ulAlignedPatternOffset;
#if 1 // New brush caches.
LONG iDitherCache; // Index to next dither cache entry.
DITHERCACHE aDithers[NUM_DITHERS]; // Dither cache.
LONG iPatternCache; // Index to next pattern cache entry.
PATTERNCACHE aPatterns[NUM_PATTERNS];
// Pattern cache.
LONG iMonochromeCache; // Index to next monochrome cache entry.
MONOCACHE aMonochromes[NUM_MONOCHROMES];
// Monochrome cache.
#endif
////////// DCI stuff:
BOOL bSupportDCI; // True if miniport supports DCI
#if DIRECTDRAW
////////// DirectDraw stuff:
FLIPRECORD flipRecord; // Used to track VBlank status
OH* pohDirectDraw; // Off-screen heap allocation for use by
// DirectDraw
ULONG ulCR1B; // Contents of CR1B register.
ULONG ulCR1D; // Contents of CR1D register.
DWORD dwLinearCnt; // Number of locks on surface.
// crus
#if 1 // OVERLAY #sge
PDD_SURFACE_LOCAL lpHardwareOwner;
PDD_SURFACE_LOCAL lpColorSurface;
PDD_SURFACE_LOCAL lpSrcColorSurface;
OVERLAYWINDOW sOverlay1;
DWORD dwPanningFlag;
WORD wColorKey;
DWORD dwSrcColorKeyLow;
DWORD dwSrcColorKeyHigh;
RECTL rOverlaySrc;
RECTL rOverlayDest;
BOOL bDoubleClock;
LONG lFifoThresh;
BYTE VertStretchCode[MAX_STRETCH_SIZE];
BYTE HorStretchCode[MAX_STRETCH_SIZE];
FLATPTR fpVisibleOverlay;
FLATPTR fpBaseOverlay;
LONG lBusWidth;
LONG lMCLKPeriod;
LONG lRandom;
LONG lPageMiss;
LONG OvlyCnt;
LONG PlanarCnt;
DWORD dwVsyncLine;
FLATPTR fpVidMem_gbls; // ptr to video memory, myf33
LONG lPitch_gbls; //pitch of surface, myf33
FNREGINITVIDEO* pfnRegInitVideo;
FNREGMOVEVIDEO* pfnRegMoveVideo;
FNBANDWIDTHEQ* pfnIsSufficientBandwidth;
FNDISABLEOVERLAY* pfnDisableOverlay;
FNCLEARALTFIFO* pfnClearAltFIFOThreshold;
#endif // OVERLAY
#endif
#if 1 // Font cache.
////////// Font cache stuff:
ULONG ulFontCacheID; // Font cache ID.
FONTCACHE* pfcChain; // Pointer to chain of FONTCACHE
// structures.
#endif
#if 1 // D5480
FNGLYPHOUT* pfnGlyphOut;
FNGLYPHOUTCLIP* pfnGlyphOutClip;
// Command List Stuff:
ULONG_PTR* pCommandList;
ULONG_PTR* pCLFirst;
ULONG_PTR* pCLSecond;
#endif // endif D5480
FnREAD_PORT_UCHAR pfnREAD_PORT_UCHAR;
FnREAD_PORT_USHORT pfnREAD_PORT_USHORT;
FnREAD_PORT_ULONG pfnREAD_PORT_ULONG;
FnWRITE_PORT_UCHAR pfnWRITE_PORT_UCHAR;
FnWRITE_PORT_USHORT pfnWRITE_PORT_USHORT;
FnWRITE_PORT_ULONG pfnWRITE_PORT_ULONG;
ULONG ulLastField; // This must remain the last field in
// this structure.
// Added to support GetAvailDriverMemory callback in DDraw
ULONG ulTotalAvailVideoMemory;
} PDEV, *PPDEV;
/////////////////////////////////////////////////////////////////////////
// Miscellaneous prototypes:
BOOL bIntersect(RECTL*, RECTL*, RECTL*);
LONG cIntersect(RECTL*, RECTL*, LONG);
VOID vImageTransfer(PDEV*, BYTE*, LONG, LONG, LONG);
#ifdef PANNING_SCROLL
VOID CirrusLaptopViewPoint(PDEV*, PVIDEO_MODE_INFORMATION); //myf17
#endif
BOOL bInitializeModeFields(PDEV*, GDIINFO*, DEVINFO*, DEVMODEW*);
BOOL bEnableHardware(PDEV*);
VOID vDisableHardware(PDEV*);
BOOL bAssertModeHardware(PDEV*, BOOL);
DWORD getAvailableModes(HANDLE, PVIDEO_MODE_INFORMATION*, DWORD*);
extern BYTE gajHwMixFromMix[];
extern BYTE gaRop3FromMix[];
extern BYTE gajHwMixFromRop2[];
extern ULONG gaulLeftClipMask[];
extern ULONG gaulRightClipMask[];
#if 1 // D5480
extern DWORD gajHwPackedMixFromRop2[];
extern DWORD gajHwPackedMixFromMix[];
#endif // endif D5480
/////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////
// PELS_TO_BYTES - converts a pel count to a byte count
// BYTES_TO_PELS - converts a byte count to a pel count
#define PELS_TO_BYTES(cPels) ((cPels) * ppdev->cBpp)
#define BYTES_TO_PELS(cPels) ((cPels) / ppdev->cBpp)
/////////////////////////////////////////////////////////////////////////
// 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); }
/////////////////////////////////////////////////////////////////////////
// BSWAP - "byte swap" reverses the bytes in a DWORD
#ifdef _X86_
#define BSWAP(ul)\
{\
_asm mov eax,ul\
_asm bswap eax\
_asm mov ul,eax\
}
#else
#define BSWAP(ul)\
{\
ul = ((ul & 0xff000000) >> 24) |\
((ul & 0x00ff0000) >> 8) |\
((ul & 0x0000ff00) << 8) |\
((ul & 0x000000ff) << 24);\
}
#endif
// 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 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 (NT_VERSION < 0x0400) //myf19
VOID DbgAssertMode(DHPDEV, BOOL);
#else
BOOL DbgAssertMode(DHPDEV, BOOL);
#endif //myf19
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);
#if 1 // Font cache
VOID DbgDestroyFont(FONTOBJ* pfo);
#endif
#if LINETO
BOOL DbgLineTo(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG, LONG,
RECTL*, MIX);
#endif
#if DIRECTDRAW
BOOL DbgGetDirectDrawInfo(DHPDEV, DD_HALINFO*, DWORD*, VIDEOMEMORY*, DWORD*,
DWORD*);
BOOL DbgEnableDirectDraw(DHPDEV, DD_CALLBACKS*, DD_SURFACECALLBACKS*,
DD_PALETTECALLBACKS*);
VOID DbgDisableDirectDraw(DHPDEV);
#endif
//
// chu01 : GAMMACORRECT
//
typedef struct _PGAMMA_VALUE
{
UCHAR value[4] ;
} GAMMA_VALUE, *PGAMMA_VALUE, *PCONTRAST_VALUE ;
//myf32 begin
//#define CL754x 0x1000
//#define CL755x 0x2000
#define CL7541 0x1000
#define CL7542 0x2000
#define CL7543 0x4000
#define CL7548 0x8000
#define CL754x (CL7541 | CL7542 | CL7543 | CL7548)
#define CL7555 0x10000
#define CL7556 0x20000
#define CL755x (CL7555 | CL7556)
#define CL756x 0x40000
// crus
#define CL6245 0x80000
//myf32 end
#define CL7542_ID 0x2C
#define CL7541_ID 0x34
#define CL7543_ID 0x30
#define CL7548_ID 0x38
#define CL7555_ID 0x40
#define CL7556_ID 0x4C
//#define CHIP754X
//#define CHIP755X
//myf32 end
Reference in a new issue Copy permalink