|
|
/******************************************************************************\
** $Workfile: FILLPATH.C $** Contains the DrvFillPath routine.** Copyright (c) 1992-1995 Microsoft Corporation* Copyright (c) 1996 Cirrus Logic, Inc.** $Log: X:/log/laguna/nt35/displays/cl546x/FILLPATH.C $** Rev 1.14 Mar 04 1998 15:24:00 frido* Added new shadow macros.** Rev 1.13 Nov 03 1997 15:26:36 frido* Added REQUIRE macros.** Rev 1.12 08 Apr 1997 12:24:28 einkauf** add SYNC_W_3D to coordinate MCD/2D HW access** Rev 1.11 21 Mar 1997 11:41:44 noelv** Combined do_flag and sw_test_flag into point_switch** Rev 1.10 17 Dec 1996 17:04:26 SueS* Added test for writing to log file based on cursor at (0,0). Added* more information to the log file.** Rev 1.9 26 Nov 1996 10:46:10 noelv* Changed DBG LEVEL.** Rev 1.8 26 Nov 1996 10:24:10 SueS* Changed WriteLogFile parameters for buffering.** Rev 1.7 13 Nov 1996 15:58:52 SueS* Changed WriteFile calls to WriteLogFile.** Rev 1.6 06 Sep 1996 14:46:24 noelv** Updated NULL driver code for 4.0** Rev 1.5 20 Aug 1996 11:03:32 noelv* Bugfix release from Frido 8-19-96** Rev 1.2 17 Aug 1996 15:32:30 frido* #1244 - Fixed brush rotation for off-screen bitmaps.* Added new comment header.* Cleaned up some code.*\******************************************************************************/
#include "precomp.h"
BOOL CacheMono(PPDEV ppdev, PRBRUSH pRbrush);BOOL Cache4BPP(PPDEV ppdev, PRBRUSH pRbrush);BOOL CacheDither(PPDEV ppdev, PRBRUSH pRbrush);BOOL CacheBrush(PPDEV ppdev, PRBRUSH pRbrush);
// We have to be careful of arithmetic overflow in a number of places.
// Fortunately, the compiler is guaranteed to natively support 64-bit signed
// LONGLONGs and 64-bit unsigned DWORDLONGs.
//
// Int32x32To64(a, b) is a macro defined in 'winnt.h' that multiplies two
// 32-bit LONGs to produce a 64-bit LONGLONG result. I use it because it is
// much faster than 64x64 multiplies.
#define UInt64Div32To32(a, b) \
((((DWORDLONG)(a)) > ULONG_MAX) ? \ (ULONG)((DWORDLONG)(a) / (ULONG)(b)) : \ (ULONG)((ULONG)(a) / (ULONG)(b)))
#define TAKING_ALLOC_STATS 0
#define NUM_BUFFER_POINTS 96 // Maximum number of points in a path for
// which we'll attempt to join all the path
// records so that the path may still be
// drawn by FastFill
#if TAKING_ALLOC_STATS
ULONG BufferHitInFillpath = 0; ULONG BufferMissInFillpath = 0;#endif
#if LOG_CALLS
VOID LogFillPath(ULONG acc, PPDEV ppdev, SURFOBJ* pso);#else
#define LogFillPath(acc, ppdev, pso)
#endif
// Describe a single non-horizontal edge of a path to fill.
typedef struct _EDGE { PVOID pNext; INT iScansLeft; INT X; INT Y; INT iErrorTerm; INT iErrorAdjustUp; INT iErrorAdjustDown; INT iXWhole; INT iXDirection; INT iWindingDirection;} EDGE, *PEDGE;
// Maximum number of rects we'll fill per call to the fill code.
#define MAX_PATH_RECTS 50
#define RECT_BYTES (MAX_PATH_RECTS * sizeof(RECTL))
#define EDGE_BYTES (TMP_BUFFER_SIZE - RECT_BYTES)
#define MAX_EDGES (EDGE_BYTES/sizeof(EDGE))
#define FILLPATH_DBG_LEVEL 1
// MIX translation table. Translates a mix 1-16, into an old style ROP 0-255.
extern BYTE gaMix[];
VOID AdvanceAETEdges(EDGE* pAETHead);VOID XSortAETEdges(EDGE* pAETHead);VOID MoveNewEdges(EDGE* pGETHead, EDGE* pAETHead, INT iCurrentY);EDGE* AddEdgeToGET(EDGE* pGETHead, EDGE* pFreeEdge, POINTFIX* ppfxEdgeStart, POINTFIX* ppfxEdgeEnd, RECTL* pClipRect);BOOL ConstructGET(EDGE* pGETHead, EDGE* pFreeEdges, PATHOBJ* ppo, PATHDATA* pd, BOOL bMore, RECTL* pClipRect);VOID AdjustErrorTerm(INT* pErrorTerm, INT iErrorAdjustUp, INT iErrorAdjustDown, INT yJump, INT* pXStart, INT iXDirection);
extern BYTE Rop2ToRop3[];
BYTE gajRop[] ={ 0x00, 0xff, 0xb2, 0x4d, 0xd4, 0x2b, 0x66, 0x99, 0x90, 0x6f, 0x22, 0xdd, 0x44, 0xbb, 0xf6, 0x09, 0xe8, 0x17, 0x5a, 0xa5, 0x3c, 0xc3, 0x8e, 0x71, 0x78, 0x87, 0xca, 0x35, 0xac, 0x53, 0x1e, 0xe1, 0xa0, 0x5f, 0x12, 0xed, 0x74, 0x8b, 0xc6, 0x39, 0x30, 0xcf, 0x82, 0x7d, 0xe4, 0x1b, 0x56, 0xa9, 0x48, 0xb7, 0xfa, 0x05, 0x9c, 0x63, 0x2e, 0xd1, 0xd8, 0x27, 0x6a, 0x95, 0x0c, 0xf3, 0xbe, 0x41, 0xc0, 0x3f, 0x72, 0x8d, 0x14, 0xeb, 0xa6, 0x59, 0x50, 0xaf, 0xe2, 0x1d, 0x84, 0x7b, 0x36, 0xc9, 0x28, 0xd7, 0x9a, 0x65, 0xfc, 0x03, 0x4e, 0xb1, 0xb8, 0x47, 0x0a, 0xf5, 0x6c, 0x93, 0xde, 0x21, 0x60, 0x9f, 0xd2, 0x2d, 0xb4, 0x4b, 0x06, 0xf9, 0xf0, 0x0f, 0x42, 0xbd, 0x24, 0xdb, 0x96, 0x69, 0x88, 0x77, 0x3a, 0xc5, 0x5c, 0xa3, 0xee, 0x11, 0x18, 0xe7, 0xaa, 0x55, 0xcc, 0x33, 0x7e, 0x81, 0x80, 0x7f, 0x32, 0xcd, 0x54, 0xab, 0xe6, 0x19, 0x10, 0xef, 0xa2, 0x5d, 0xc4, 0x3b, 0x76, 0x89, 0x68, 0x97, 0xda, 0x25, 0xbc, 0x43, 0x0e, 0xf1, 0xf8, 0x07, 0x4a, 0xb5, 0x2c, 0xd3, 0x9e, 0x61, 0x20, 0xdf, 0x92, 0x6d, 0xf4, 0x0b, 0x46, 0xb9, 0xb0, 0x4f, 0x02, 0xfd, 0x64, 0x9b, 0xd6, 0x29, 0xc8, 0x37, 0x7a, 0x85, 0x1c, 0xe3, 0xae, 0x51, 0x58, 0xa7, 0xea, 0x15, 0x8c, 0x73, 0x3e, 0xc1, 0x40, 0xbf, 0xf2, 0x0d, 0x94, 0x6b, 0x26, 0xd9, 0xd0, 0x2f, 0x62, 0x9d, 0x04, 0xfb, 0xb6, 0x49, 0xa8, 0x57, 0x1a, 0xe5, 0x7c, 0x83, 0xce, 0x31, 0x38, 0xc7, 0x8a, 0x75, 0xec, 0x13, 0x5e, 0xa1, 0xe0, 0x1f, 0x52, 0xad, 0x34, 0xcb, 0x86, 0x79, 0x70, 0x8f, 0xc2, 0x3d, 0xa4, 0x5b, 0x16, 0xe9, 0x08, 0xf7, 0xba, 0x45, 0xdc, 0x23, 0x6e, 0x91, 0x98, 0x67, 0x2a, 0xd5, 0x4c, 0xb3, 0xfe, 0x01};
/******************************Public*Routine******************************\
* DrvFillPath** Fill the specified path with the specified brush and ROP. This routine* detects single convex polygons, and will call to separate faster convex* polygon code for those cases. This routine also detects polygons that* are really rectangles, and handles those separately as well.** Note: Multiple polygons in a path cannot be treated as being disjoint;* the fill must consider all the points in the path. That is, if the* path contains multiple polygons, you cannot simply draw one polygon* after the other (unless they don't overlap).** Note: This function is optional, but is recommended for good performance.* To get GDI to call this function, not only do you have to* HOOK_FILLPATH, you have to set GCAPS_ALTERNATEFILL and/or* GCAPS_WINDINGFILL.*\**************************************************************************/
BOOL DrvFillPath(SURFOBJ* pso,PATHOBJ* ppo,CLIPOBJ* pco,BRUSHOBJ* pbo,POINTL* pptlBrush,MIX mix,FLONG flOptions){ BYTE jClipping; // clipping type
EDGE *pCurrentEdge; EDGE AETHead; // dummy head/tail node & sentinel for Active Edge Table
EDGE *pAETHead; // pointer to AETHead
EDGE GETHead; // dummy head/tail node & sentinel for Global Edge Table
EDGE *pGETHead; // pointer to GETHead
EDGE *pFreeEdges; // pointer to memory free for use to store edges
ULONG ulNumRects; // # of rectangles to draw currently in rectangle list
RECTL *prclRects; // pointer to start of rectangle draw list
INT iCurrentY; // scan line for which we're currently scanning out the
// fill
ULONG uRop; // Hardware foreground mix value
ULONG uRopb; // Hardware background mix value
ULONG avec; // A-vector notation for ternary rop
ULONG iSolidColor; // Copy of pbo->iSolidColor
FNFILL *pfnFill; // Points to appropriate fill routine
BOOL bRealizeTransparent; // Need a transparent realization for Rop
BOOL bSolid; BOOL bMore; PATHDATA pd; RECTL ClipRect; PDEV *ppdev;
BOOL bRetVal=FALSE; // FALSE until proven TRUE
BOOL bMemAlloced=FALSE; // FALSE until proven TRUE
FLONG flFirstRecord; POINTFIX* pptfxTmp; ULONG cptfxTmp; POINTFIX aptfxBuf[NUM_BUFFER_POINTS]; ULONG ulBltDef = 0x1000;
#if NULL_PATH
{ if (pointer_switch) return(TRUE); } #endif
DISPDBG((FILLPATH_DBG_LEVEL,"DrvFillPath\n"));
// Set up the clipping
if (pco == (CLIPOBJ *) NULL) { // No CLIPOBJ provided, so we don't have to worry about clipping
jClipping = DC_TRIVIAL; } else { // Use the CLIPOBJ-provided clipping
jClipping = pco->iDComplexity; }
if (jClipping != DC_TRIVIAL) { if (jClipping != DC_RECT) { DISPDBG((FILLPATH_DBG_LEVEL,"Complex Clipping Early Out\n")); #if LOG_CALLS
ppdev = (PDEV*) pso->dhpdev; LogFillPath(2, ppdev, NULL); #endif
goto ReturnFalse; // there is complex clipping; let GDI fill the path
} // Clip to the clip rectangle
ClipRect = pco->rclBounds; } else { // So the y-clipping code doesn't do any clipping
// /16 so we don't blow the values out when we scale up to GIQ
ClipRect.top = (LONG_MIN + 1) / 16; // +1 to avoid compiler problem
ClipRect.bottom = LONG_MAX / 16; }
// There's nothing to do if there are only one or two points
if (ppo->cCurves <= 2) { DISPDBG((FILLPATH_DBG_LEVEL,"Nothing to do out\n")); #if LOG_CALLS
ppdev = (PDEV*) pso->dhpdev; LogFillPath(0, ppdev, pso); #endif
goto ReturnTrue; }
// Pass the surface off to GDI if it's a device bitmap that we've
// converted to a DIB:
// This is where to put device bit maps
ppdev = (PDEV*) pso->dhpdev;
SYNC_W_3D(ppdev);
if (pso->iType == STYPE_DEVBITMAP) { PDSURF pdsurf = (PDSURF) pso->dhsurf;
if ( pdsurf->pso && !bCreateScreenFromDib(ppdev, pdsurf) ) { LogFillPath(4, ppdev, NULL); return(EngFillPath(pdsurf->pso, ppo, pco, pbo, pptlBrush, mix, flOptions)); } ppdev->ptlOffset = pdsurf->ptl; } else { ppdev->ptlOffset.x = ppdev->ptlOffset.y = 0; }
pfnFill = vMmFillSolid; uRop = Rop2ToRop3[mix & 0xF]; uRopb = Rop2ToRop3[(mix >> 8) & 0xF]; bSolid = ((pbo == NULL) || (pbo->iSolidColor != -1));
//
// Make it simple and punt this one until later
//
avec = gajRop[uRop]; if ((uRop != uRopb) && !bSolid) { DISPDBG((FILLPATH_DBG_LEVEL, "ROPs it Fore=%x Back=%x ROP3=%x\n", uRop, uRopb, ROP3MIX(uRop, uRopb))); uRop = ROP3MIX(uRop, uRopb); avec = gajRop[uRop]; if (avec & AVEC_NEED_SOURCE) { // Use the implicit mask in the brush object.
// Note pre-align mask (as if "anchored")
if (!bSetMask(ppdev, pbo, pptlBrush, &ulBltDef)) { DISPDBG((FILLPATH_DBG_LEVEL, "Set Mask Failed")); LogFillPath(5, ppdev, NULL); return FALSE; } }
}
iSolidColor = 0; // Assume we won't need a pattern
bRealizeTransparent = FALSE; if (avec & AVEC_NEED_PATTERN) { iSolidColor = pbo->iSolidColor; if (pbo->iSolidColor == -1) { bRealizeTransparent = (uRop != uRopb); if (pbo->pvRbrush == NULL) { pbo->pvRbrush = BRUSHOBJ_pvGetRbrush(pbo); if (pbo->pvRbrush == NULL) { DISPDBG((FILLPATH_DBG_LEVEL,"Could Not Get Brush\n")); LogFillPath(6, ppdev, NULL); return(FALSE); } } pfnFill = vMmFillPatFast; } else ulBltDef |= (BD_OP2 * IS_SOLID); // Or in 0x0007
}
if (avec & AVEC_NEED_DEST) ulBltDef |= (BD_OP0 * IS_VRAM); // Or in 0x0100
// Enumerate path here first time to check for special
// cases (rectangles and monotone polygons)
// It is too difficult to determine interaction between
// multiple paths, if there is more than one, skip this
bMore = PATHOBJ_bEnum(ppo, &pd);
if (jClipping == DC_TRIVIAL) { // Try going through the fast non-complex fill code. We'll have
// to realize the brush first if we're going to handle a pattern:
if (iSolidColor == -1) {#ifdef S3
#if !FASTFILL_PATTERNS
goto SkipFastFill; #else
// We handle patterns in 'pfnFastFill' only if we can use the S3
// hardware patterns.
if (!(ppdev->flCaps & CAPS_HW_PATTERNS)) goto SkipFastFill;
// Note: prb->pbe will be NULL and prb->ptlBrushOrg.x will be -1 the
// first time an RBRUSH is used. So we have to check the
// alignment *before* dereferencing prb->pbe...
if ((rbc.prb->ptlBrushOrg.x != pptlBrush->x + ppdev->xOffset) || (rbc.prb->ptlBrushOrg.y != pptlBrush->y + ppdev->yOffset) || (rbc.prb->apbe[IBOARD(ppdev)]->prbVerify != rbc.prb) || (rbc.prb->bTransparent != bRealizeTransparent)) { vMmFastPatRealize(ppdev, pbo, pptlBrush, bRealizeTransparent);
} #endif
#endif
// Realize the brush
if (!SetBrush(ppdev, &ulBltDef, pbo, pptlBrush)) { DISPDBG((FILLPATH_DBG_LEVEL,"Could Not Set Brush\n")); LogFillPath(6, ppdev, NULL); return FALSE; } }
if (bMore) { // FastFill only knows how to take a single contiguous buffer
// of points. Unfortunately, GDI sometimes hands us paths
// that are split over multiple path data records. Convex
// figures such as Ellipses, Pies and RoundRects are almost
// always given in multiple records. Since probably 90% of
// multiple record paths could still be done by FastFill, for
// those cases we simply copy the points into a contiguous
// buffer...
// First make sure that the entire path would fit in the
// temporary buffer, and make sure the path isn't comprised
// of more than one subpath:
if ((ppo->cCurves >= NUM_BUFFER_POINTS) || (pd.flags & PD_ENDSUBPATH)) goto SkipFastFill;
pptfxTmp = &aptfxBuf[0];
RtlCopyMemory(pptfxTmp, pd.pptfx, sizeof(POINTFIX) * pd.count);
pptfxTmp += pd.count; cptfxTmp = pd.count; flFirstRecord = pd.flags; // Remember PD_BEGINSUBPATH flag
do { bMore = PATHOBJ_bEnum(ppo, &pd);
RtlCopyMemory(pptfxTmp, pd.pptfx, sizeof(POINTFIX) * pd.count); cptfxTmp += pd.count; pptfxTmp += pd.count; } while (!(pd.flags & PD_ENDSUBPATH));
// Fake up the path data record:
pd.pptfx = &aptfxBuf[0]; pd.count = cptfxTmp; pd.flags |= flFirstRecord;
// If there's more than one subpath, we can't call FastFill:
if (bMore) goto SkipFastFill; }
ppdev->uBLTDEF = ulBltDef; if (bMmFastFill(ppdev, pd.count, pd.pptfx, uRop, uRopb, iSolidColor, pbo)) { LogFillPath(0, ppdev, pso); return(TRUE); } }
SkipFastFill:
// Set up working storage in the temporary buffer
prclRects = (RECTL*) ppdev->pvTmpBuffer; // storage for list of rectangles to draw
if (!bMore) {
RECTL *rectangle; INT cPoints = pd.count;
// The count can't be less than three, because we got all the edges
// in this subpath, and above we checked that there were at least
// three edges
// If the count is four, check to see if the polygon is really a
// rectangle since we can really speed that up. We'll also check for
// five with the first and last points the same, because under Win 3.1,
// it was required to close polygons
if ((cPoints == 4) || ((cPoints == 5) && (pd.pptfx[0].x == pd.pptfx[4].x) && (pd.pptfx[0].y == pd.pptfx[4].y))) {
rectangle = prclRects;
/* we have to start somewhere so assume that most
applications specify the top left point first
we want to check that the first two points are either vertically or horizontally aligned. if they are then we check that the last point [3] is either horizontally or vertically aligned, and finally that the 3rd point [2] is aligned with both the first point and the last point */
#define FIX_SHIFT 4L
#define FIX_MASK (- (1 << FIX_SHIFT))
rectangle->top = pd.pptfx[0].y - 1 & FIX_MASK; rectangle->left = pd.pptfx[0].x - 1 & FIX_MASK; rectangle->right = pd.pptfx[1].x - 1 & FIX_MASK;
if (rectangle->left ^ rectangle->right) { if (rectangle->top ^ (pd.pptfx[1].y - 1 & FIX_MASK)) goto not_rectangle;
if (rectangle->left ^ (pd.pptfx[3].x - 1 & FIX_MASK)) goto not_rectangle;
if (rectangle->right ^ (pd.pptfx[2].x - 1 & FIX_MASK)) goto not_rectangle;
rectangle->bottom = pd.pptfx[2].y - 1 & FIX_MASK; if (rectangle->bottom ^ (pd.pptfx[3].y - 1 & FIX_MASK)) goto not_rectangle; } else { if (rectangle->top ^ (pd.pptfx[3].y - 1 & FIX_MASK)) goto not_rectangle;
rectangle->bottom = pd.pptfx[1].y - 1 & FIX_MASK; if (rectangle->bottom ^ (pd.pptfx[2].y - 1 & FIX_MASK)) goto not_rectangle;
rectangle->right = pd.pptfx[2].x - 1 & FIX_MASK; if (rectangle->right ^ (pd.pptfx[3].x - 1 & FIX_MASK)) goto not_rectangle; }
/* if the left is greater than the right then
swap them so the blt code doesn't wig out */
if (rectangle->left > rectangle->right) { FIX temp;
temp = rectangle->left; rectangle->left = rectangle->right; rectangle->right = temp; } else {
/* if left == right there's nothing to draw */
if (rectangle->left == rectangle->right) { LogFillPath(0, ppdev, pso); goto ReturnTrue; } }
/* shift the values to get pixel coordinates */
rectangle->left = (rectangle->left >> FIX_SHIFT) + 1; rectangle->right = (rectangle->right >> FIX_SHIFT) + 1;
if (rectangle->top > rectangle->bottom) { FIX temp;
temp = rectangle->top; rectangle->top = rectangle->bottom; rectangle->bottom = temp; } else { if (rectangle->top == rectangle->bottom) { LogFillPath(0, ppdev, pso); goto ReturnTrue; } }
/* shift the values to get pixel coordinates */
rectangle->top = (rectangle->top >> FIX_SHIFT) + 1; rectangle->bottom = (rectangle->bottom >> FIX_SHIFT) + 1;
// Finally, check for clipping
if (jClipping == DC_RECT) { // Clip to the clip rectangle
if (!bIntersect(rectangle, &ClipRect, rectangle)) { // Totally clipped, nothing to do
LogFillPath(0, ppdev, pso); goto ReturnTrue; } }
/* if we get here then the polygon is a rectangle,
set count to 1 and goto bottom to draw it */
ulNumRects = 1; goto draw_remaining_rectangles; }
not_rectangle:
;
}
// Do we have enough memory for all the edges?
// LATER does cCurves include closure?
if (ppo->cCurves > MAX_EDGES) {#if TAKING_ALLOC_STATS
BufferMissInFillpath++;#endif
//
// try to allocate enough memory
//
#ifdef WINNT_VER40
pFreeEdges = (EDGE *) MEM_ALLOC(0, (ppo->cCurves * sizeof(EDGE)), ALLOC_TAG);#else
pFreeEdges = (EDGE *) MEM_ALLOC(LMEM_FIXED, (ppo->cCurves * sizeof(EDGE)));#endif
if (pFreeEdges == NULL) { LogFillPath(1, ppdev, NULL); goto ReturnFalse; // too many edges; let GDI fill the path
} else { bMemAlloced = TRUE; } } else {#if TAKING_ALLOC_STATS
BufferHitInFillpath++;#endif
pFreeEdges = (EDGE*) ((BYTE*) ppdev->pvTmpBuffer + RECT_BYTES); // use our handy temporary buffer (it's big enough)
}
// Initialize an empty list of rectangles to fill
ulNumRects = 0;
// Enumerate the path edges and build a Global Edge Table (GET) from them
// in YX-sorted order.
pGETHead = &GETHead; if (!ConstructGET(pGETHead, pFreeEdges, ppo, &pd, bMore, &ClipRect)) { LogFillPath(7, ppdev, NULL); goto ReturnFalse; // outside GDI's 2**27 range
}
// Create an empty AET with the head node also a tail sentinel
pAETHead = &AETHead; AETHead.pNext = pAETHead; // mark that the AET is empty
AETHead.X = 0x7FFFFFFF; // this is greater than any valid X value, so
// searches will always terminate
// Top scan of polygon is the top of the first edge we come to
iCurrentY = ((EDGE *)GETHead.pNext)->Y;
// Loop through all the scans in the polygon, adding edges from the GET to
// the Active Edge Table (AET) as we come to their starts, and scanning out
// the AET at each scan into a rectangle list. Each time it fills up, the
// rectangle list is passed to the filling routine, and then once again at
// the end if any rectangles remain undrawn. We continue so long as there
// are edges to be scanned out
while (1) {
// Advance the edges in the AET one scan, discarding any that have
// reached the end (if there are any edges in the AET)
if (AETHead.pNext != pAETHead) { AdvanceAETEdges(pAETHead); }
// If the AET is empty, done if the GET is empty, else jump ahead to
// the next edge in the GET; if the AET isn't empty, re-sort the AET
if (AETHead.pNext == pAETHead) { if (GETHead.pNext == pGETHead) { // Done if there are no edges in either the AET or the GET
break; } // There are no edges in the AET, so jump ahead to the next edge in
// the GET
iCurrentY = ((EDGE *)GETHead.pNext)->Y; } else { // Re-sort the edges in the AET by X coordinate, if there are at
// least two edges in the AET (there could be one edge if the
// balancing edge hasn't yet been added from the GET)
if (((EDGE *)AETHead.pNext)->pNext != pAETHead) { XSortAETEdges(pAETHead); } }
// Move any new edges that start on this scan from the GET to the AET;
// bother calling only if there's at least one edge to add
if (((EDGE *)GETHead.pNext)->Y == iCurrentY) { MoveNewEdges(pGETHead, pAETHead, iCurrentY); }
// Scan the AET into rectangles to fill (there's always at least one
// edge pair in the AET)
pCurrentEdge = AETHead.pNext; // point to the first edge
do {
INT iLeftEdge;
// The left edge of any given edge pair is easy to find; it's just
// wherever we happen to be currently
iLeftEdge = pCurrentEdge->X;
// Find the matching right edge according to the current fill rule
if ((flOptions & FP_WINDINGMODE) != 0) {
INT iWindingCount;
// Do winding fill; scan across until we've found equal numbers
// of up and down edges
iWindingCount = pCurrentEdge->iWindingDirection; do { pCurrentEdge = pCurrentEdge->pNext; iWindingCount += pCurrentEdge->iWindingDirection; } while (iWindingCount != 0); } else { // Odd-even fill; the next edge is the matching right edge
pCurrentEdge = pCurrentEdge->pNext; }
// See if the resulting span encompasses at least one pixel, and
// add it to the list of rectangles to draw if so
if (iLeftEdge < pCurrentEdge->X) {
// We've got an edge pair to add to the list to be filled; see
// if there's room for one more rectangle
if (ulNumRects >= MAX_PATH_RECTS) { // No more room; draw the rectangles in the list and reset
// it to empty
ppdev->uBLTDEF = ulBltDef; (*pfnFill)(ppdev, ulNumRects, prclRects, uRop, uRopb, pbo, pptlBrush);
// Reset the list to empty
ulNumRects = 0; }
// Add the rectangle representing the current edge pair
if (jClipping == DC_RECT) { // Clipped
// Clip to left
prclRects[ulNumRects].left = max(iLeftEdge, ClipRect.left); // Clip to right
prclRects[ulNumRects].right = min(pCurrentEdge->X, ClipRect.right); // Draw only if not fully clipped
if (prclRects[ulNumRects].left < prclRects[ulNumRects].right) { prclRects[ulNumRects].top = iCurrentY; prclRects[ulNumRects].bottom = iCurrentY+1; ulNumRects++; } } else { // Unclipped
prclRects[ulNumRects].top = iCurrentY; prclRects[ulNumRects].bottom = iCurrentY+1; prclRects[ulNumRects].left = iLeftEdge; prclRects[ulNumRects].right = pCurrentEdge->X; ulNumRects++; } } } while ((pCurrentEdge = pCurrentEdge->pNext) != pAETHead);
iCurrentY++; // next scan
}
/* draw the remaining rectangles, if there are any */
draw_remaining_rectangles:
if (ulNumRects > 0) { ppdev->uBLTDEF = ulBltDef; (*pfnFill)(ppdev, ulNumRects, prclRects, uRop, uRopb, pbo, pptlBrush); }
LogFillPath(0, ppdev, pso);
ReturnTrue: bRetVal = TRUE; // done successfully
ReturnFalse:
// bRetVal is originally false. If you jumped to ReturnFalse from somewhere,
// then it will remain false, and be returned.
if (bMemAlloced) { //
// we did allocate memory, so release it
//
MEMORY_FREE (pFreeEdges); }
return(bRetVal);}
// Advance the edges in the AET to the next scan, dropping any for which we've
// done all scans. Assumes there is at least one edge in the AET.
VOID AdvanceAETEdges(EDGE *pAETHead){ EDGE *pLastEdge, *pCurrentEdge;
pLastEdge = pAETHead; pCurrentEdge = pLastEdge->pNext; do {
// Count down this edge's remaining scans
if (--pCurrentEdge->iScansLeft == 0) { // We've done all scans for this edge; drop this edge from the AET
pLastEdge->pNext = pCurrentEdge->pNext; } else { // Advance the edge's X coordinate for a 1-scan Y advance
// Advance by the minimum amount
pCurrentEdge->X += pCurrentEdge->iXWhole; // Advance the error term and see if we got one extra pixel this
// time
pCurrentEdge->iErrorTerm += pCurrentEdge->iErrorAdjustUp; if (pCurrentEdge->iErrorTerm >= 0) { // The error term turned over, so adjust the error term and
// advance the extra pixel
pCurrentEdge->iErrorTerm -= pCurrentEdge->iErrorAdjustDown; pCurrentEdge->X += pCurrentEdge->iXDirection; }
pLastEdge = pCurrentEdge; } } while ((pCurrentEdge = pLastEdge->pNext) != pAETHead);}
// X-sort the AET, because the edges may have moved around relative to
// one another when we advanced them. We'll use a multipass bubble
// sort, which is actually okay for this application because edges
// rarely move relative to one another, so we usually do just one pass.
// Also, this makes it easy to keep just a singly-linked list. Assumes there
// are at least two edges in the AET.
VOID XSortAETEdges(EDGE *pAETHead){ BOOL bEdgesSwapped; EDGE *pLastEdge, *pCurrentEdge, *pNextEdge;
do {
bEdgesSwapped = FALSE; pLastEdge = pAETHead; pCurrentEdge = pLastEdge->pNext; pNextEdge = pCurrentEdge->pNext;
do { if (pNextEdge->X < pCurrentEdge->X) {
// Next edge is to the left of the current edge; swap them
pLastEdge->pNext = pNextEdge; pCurrentEdge->pNext = pNextEdge->pNext; pNextEdge->pNext = pCurrentEdge; bEdgesSwapped = TRUE; pCurrentEdge = pNextEdge; // continue sorting before the edge
// we just swapped; it might move
// farther yet
} pLastEdge = pCurrentEdge; pCurrentEdge = pLastEdge->pNext; } while ((pNextEdge = pCurrentEdge->pNext) != pAETHead); } while (bEdgesSwapped);}
// Moves all edges that start on the current scan from the GET to the AET in
// X-sorted order. Parameters are pointer to head of GET and pointer to dummy
// edge at head of AET, plus current scan line. Assumes there's at least one
// edge to be moved.
VOID MoveNewEdges(EDGE *pGETHead, EDGE *pAETHead, INT iCurrentY){ EDGE *pCurrentEdge = pAETHead; EDGE *pGETNext = pGETHead->pNext;
do {
// Scan through the AET until the X-sorted insertion point for this
// edge is found. We can continue from where the last search left
// off because the edges in the GET are in X sorted order, as is
// the AET. The search always terminates because the AET sentinel
// is greater than any valid X
while (pGETNext->X > ((EDGE *)pCurrentEdge->pNext)->X) { pCurrentEdge = pCurrentEdge->pNext; }
// We've found the insertion point; add the GET edge to the AET, and
// remove it from the GET
pGETHead->pNext = pGETNext->pNext; pGETNext->pNext = pCurrentEdge->pNext; pCurrentEdge->pNext = pGETNext; pCurrentEdge = pGETNext; // continue insertion search for the next
// GET edge after the edge we just added
pGETNext = pGETHead->pNext;
} while (pGETNext->Y == iCurrentY);}
// Build the Global Edge Table from the path. There must be enough memory in
// the free edge area to hold all edges. The GET is constructed in Y-X order,
// and has a head/tail/sentinel node at pGETHead.
BOOL ConstructGET( EDGE *pGETHead, EDGE *pFreeEdges, PATHOBJ *ppo, PATHDATA *pd, BOOL bMore, RECTL *pClipRect){ POINTFIX pfxPathStart; // point that started the current subpath
POINTFIX pfxPathPrevious; // point before the current point in a subpath;
// starts the current edge
/* Create an empty GET with the head node also a tail sentinel */
pGETHead->pNext = pGETHead; // mark that the GET is empty
pGETHead->Y = 0x7FFFFFFF; // this is greater than any valid Y value, so
// searches will always terminate
/* PATHOBJ_vEnumStart is implicitly performed by engine
already and first path is enumerated by the caller */
next_subpath:
/* Make sure the PATHDATA is not empty (is this necessary) */
if (pd->count != 0) {
/* If first point starts a subpath, remember it as such
and go on to the next point, so we can get an edge */
if (pd->flags & PD_BEGINSUBPATH) {
/* the first point starts the subpath; remember it */
pfxPathStart = *pd->pptfx; /* the subpath starts here */ pfxPathPrevious = *pd->pptfx; /* this points starts the next edge */ pd->pptfx++; /* advance to the next point */ pd->count--; /* count off this point */ }
/* add edges in PATHDATA to GET, in Y-X sorted order */
while (pd->count--) { if ((pFreeEdges = AddEdgeToGET(pGETHead, pFreeEdges, &pfxPathPrevious, pd->pptfx, pClipRect)) == NULL) { goto ReturnFalse; } pfxPathPrevious = *pd->pptfx; /* current point becomes previous */ pd->pptfx++; /* advance to the next point */ }
/* If last point ends the subpath, insert the edge that
connects to first point (is this built in already?) */
if (pd->flags & PD_ENDSUBPATH) { if ((pFreeEdges = AddEdgeToGET(pGETHead, pFreeEdges, &pfxPathPrevious, &pfxPathStart, pClipRect)) == NULL) { goto ReturnFalse; } } }
/* the initial loop conditions preclude a do, while or for */
if (bMore) { bMore = PATHOBJ_bEnum(ppo, pd); goto next_subpath; }
return(TRUE); // done successfully
ReturnFalse: return(FALSE); // failed
}
// Adds the edge described by the two passed-in points to the Global Edge
// Table, if the edge spans at least one pixel vertically.
EDGE * AddEdgeToGET(EDGE *pGETHead, EDGE *pFreeEdge, POINTFIX *ppfxEdgeStart, POINTFIX *ppfxEdgeEnd, RECTL *pClipRect){ INT iYStart, iYEnd, iXStart, iXEnd, iYHeight, iXWidth; INT yJump, yTop;
// Set the winding-rule direction of the edge, and put the endpoints in
// top-to-bottom order
iYHeight = ppfxEdgeEnd->y - ppfxEdgeStart->y; if (iYHeight == 0) { return(pFreeEdge); // zero height; ignore this edge
} else if (iYHeight >= 0) { iXStart = ppfxEdgeStart->x; iYStart = ppfxEdgeStart->y; iXEnd = ppfxEdgeEnd->x; iYEnd = ppfxEdgeEnd->y; pFreeEdge->iWindingDirection = 1; } else { iYHeight = -iYHeight; iXEnd = ppfxEdgeStart->x; iYEnd = ppfxEdgeStart->y; iXStart = ppfxEdgeEnd->x; iYStart = ppfxEdgeEnd->y; pFreeEdge->iWindingDirection = -1; }
if (iYHeight & 0x80000000) { return(NULL); // too large; outside 2**27 GDI range
}
// Set the error term and adjustment factors, all in GIQ coordinates for
// now
iXWidth = iXEnd - iXStart; if (iXWidth >= 0) { // Left to right, so we change X as soon as we move at all
pFreeEdge->iXDirection = 1; pFreeEdge->iErrorTerm = -1; } else { // Right to left, so we don't change X until we've moved a full GIQ
// coordinate
iXWidth = -iXWidth; pFreeEdge->iXDirection = -1; pFreeEdge->iErrorTerm = -iYHeight; }
if (iXWidth & 0x80000000) { return(NULL); // too large; outside 2**27 GDI range
}
if (iXWidth >= iYHeight) { // Calculate base run length (minimum distance advanced in X for a 1-
// scan advance in Y)
pFreeEdge->iXWhole = iXWidth / iYHeight; // Add sign back into base run length if going right to left
if (pFreeEdge->iXDirection == -1) { pFreeEdge->iXWhole = -pFreeEdge->iXWhole; } pFreeEdge->iErrorAdjustUp = iXWidth % iYHeight; } else { // Base run length is 0, because line is closer to vertical than
// horizontal
pFreeEdge->iXWhole = 0; pFreeEdge->iErrorAdjustUp = iXWidth; } pFreeEdge->iErrorAdjustDown = iYHeight;
// Calculate the number of pixels spanned by this edge, accounting for
// clipping
// Top true pixel scan in GIQ coordinates
// Shifting to divide and multiply by 16 is okay because the clip rect
// always contains positive numbers
yTop = max(pClipRect->top << 4, (iYStart + 15) & ~0x0F); pFreeEdge->Y = yTop >> 4; // initial scan line on which to fill edge
// Calculate # of scans to actually fill, accounting for clipping
if ((pFreeEdge->iScansLeft = min(pClipRect->bottom, ((iYEnd + 15) >> 4)) - pFreeEdge->Y) <= 0) {
return(pFreeEdge); // no pixels at all are spanned, so we can
// ignore this edge
}
// If the edge doesn't start on a pixel scan (that is, it starts at a
// fractional GIQ coordinate), advance it to the first pixel scan it
// intersects. Ditto if there's top clipping. Also clip to the bottom if
// needed
if (iYStart != yTop) { // Jump ahead by the Y distance in GIQ coordinates to the first pixel
// to draw
yJump = yTop - iYStart;
// Advance x the minimum amount for the number of scans traversed
iXStart += pFreeEdge->iXWhole * yJump;
AdjustErrorTerm(&pFreeEdge->iErrorTerm, pFreeEdge->iErrorAdjustUp, pFreeEdge->iErrorAdjustDown, yJump, &iXStart, pFreeEdge->iXDirection); } // Turn the calculations into pixel rather than GIQ calculations
// Move the X coordinate to the nearest pixel, and adjust the error term
// accordingly
// Dividing by 16 with a shift is okay because X is always positive
pFreeEdge->X = (iXStart + 15) >> 4; // convert from GIQ to pixel coordinates
// LATER adjust only if needed (if prestepped above)?
if (pFreeEdge->iXDirection == 1) { // Left to right
pFreeEdge->iErrorTerm -= pFreeEdge->iErrorAdjustDown * (((iXStart + 15) & ~0x0F) - iXStart); } else { // Right to left
pFreeEdge->iErrorTerm -= pFreeEdge->iErrorAdjustDown * ((iXStart - 1) & 0x0F); }
// Scale the error term down 16 times to switch from GIQ to pixels.
// Shifts work to do the multiplying because these values are always
// non-negative
pFreeEdge->iErrorTerm >>= 4;
// Insert the edge into the GET in YX-sorted order. The search always ends
// because the GET has a sentinel with a greater-than-possible Y value
while ((pFreeEdge->Y > ((EDGE *)pGETHead->pNext)->Y) || ((pFreeEdge->Y == ((EDGE *)pGETHead->pNext)->Y) && (pFreeEdge->X > ((EDGE *)pGETHead->pNext)->X))) { pGETHead = pGETHead->pNext; }
pFreeEdge->pNext = pGETHead->pNext; // link the edge into the GET
pGETHead->pNext = pFreeEdge;
return(++pFreeEdge); // point to the next edge storage location for next
// time
}
// Adjust the error term for a skip ahead in y. This is in ASM because there's
// a multiply/divide that may involve a larger than 32-bit value.
void AdjustErrorTerm(INT *pErrorTerm, INT iErrorAdjustUp, INT iErrorAdjustDown, INT yJump, INT *pXStart, INT iXDirection){#if defined(_X86_) || defined(i386)
// Adjust the error term up by the number of y coordinates we'll skip
//*pErrorTerm += iErrorAdjustUp * yJump;
_asm mov ebx,pErrorTerm _asm mov eax,iErrorAdjustUp _asm mul yJump _asm add eax,[ebx] _asm adc edx,-1 // the error term starts out negative
// See if the error term turned over even once while skipping
//if (*pErrorTerm >= 0) {
_asm js short NoErrorTurnover
// # of times we'll turn over the error term and step an extra x
// coordinate while skipping
// NumAdjustDowns = (*pErrorTerm / iErrorAdjustDown) + 1;
_asm div iErrorAdjustDown _asm inc eax // Note that EDX is the remainder; (EDX - iErrorAdjustDown) is where
// the error term ends up ultimately
// Advance x appropriately for the # of times the error term
// turned over
// if (iXDirection == 1) {
// *pXStart += NumAdjustDowns;
// } else {
// *pXStart -= NumAdjustDowns;
// }
_asm mov ecx,pXStart _asm cmp iXDirection,1 _asm jz short GoingRight _asm neg eaxGoingRight: _asm add [ecx],eax
// Adjust the error term down to its proper post-skip value
// *pErrorTerm -= iErrorAdjustDown * NumAdjustDowns;
_asm sub edx,iErrorAdjustDown _asm mov eax,edx // put into EAX for storing to pErrorTerm next
// }
NoErrorTurnover: _asm mov [ebx],eax#else
LONGLONG llErrorTerm; INT NumAdjustDowns;
llErrorTerm = *pErrorTerm;
// Adjust the error term up by the number of y coordinates we'll skip
llErrorTerm += Int32x32To64(iErrorAdjustUp,yJump);
// See if the error term turned over even once while skipping
if (llErrorTerm >= 0) { // # of times we'll turn over the error term and step an extra x
// coordinate while skipping
NumAdjustDowns = (UInt64Div32To32(llErrorTerm,iErrorAdjustDown)) + 1;
// Advance x appropriately for the # of times the error term
// turned over
if (iXDirection == 1) { *pXStart += NumAdjustDowns; } else { *pXStart -= NumAdjustDowns; }
// Adjust the error term down to its proper post-skip value
llErrorTerm -= iErrorAdjustDown * NumAdjustDowns; }
*pErrorTerm = (INT) llErrorTerm;#endif
}
//--------------------------------------------------------------------------//
// //
// bSetMask() //
// Used by DrvFillPath //
// to setup the chip to use the current mask. //
// We don't set the BLTDEF register directly here. We set a local copy, //
// which the calling routine will further modify befor writing it to //
// the chip. //
// //
//--------------------------------------------------------------------------//
BOOL bSetMask( PPDEV ppdev, BRUSHOBJ *pbo, POINTL *pptlBrush, ULONG *bltdef){ PRBRUSH pRbrush = 0; USHORT patoff_x, patoff_y;
DISPDBG((FILLPATH_DBG_LEVEL, "bSetMask - Entry\n"));
// Guard against a solid brush (pen) in case the caller didn't
if ((pbo ==NULL) || (pbo->iSolidColor != -1)) { RIP("bSetMask - solid mask!\n"); *bltdef |= BD_OP1_IS_SRAM_MONO; REQUIRE(4); LL_FGCOLOR(0xFFFFFFFF, 2); // totally
LL_BGCOLOR(0xFFFFFFFF, 2); // foreground
return (TRUE); } else if (pbo->pvRbrush != NULL) { pRbrush = pbo->pvRbrush; } else { pRbrush = BRUSHOBJ_pvGetRbrush(pbo); // Fail if we do not handle the brush.
if (pRbrush == NULL) { DISPDBG((FILLPATH_DBG_LEVEL, "pRbrush is NULL\n")); return (FALSE); } }
//
// Set pattern offset.
// NT specifies patttern offset as which pixel on the screen to align
// with pattern(0,0). Laguna specifies pattern offset as which pixel
// of the pattern to align with screen(0,0). Only the lowest three
// bits are significant, so we can ignore any overflow when converting.
// Also, even though PATOFF is a reg_16, we can't do byte wide writes
// to it. We have to write both PATOFF.pt.X and PATOFF.pt.Y in a single
// 16 bit write.
//
#if 1 //#1244
patoff_x = (USHORT)(-(pptlBrush->x + ppdev->ptlOffset.x) & 7); patoff_y = (USHORT)(-(pptlBrush->y + ppdev->ptlOffset.y) & 7);#else
patoff_x = 8 - (BYTE)(pptlBrush->x & 0x07); patoff_y = 8 - (BYTE)(pptlBrush->y & 0x07);#endif
REQUIRE(1); LL16 (grPATOFF.w, ((patoff_y << 8) | patoff_x ));
//
// What kind of brush is it?
//
if (pRbrush->iType == BRUSH_MONO) // Monochrome brush.
{ DISPDBG((FILLPATH_DBG_LEVEL, "bSetMask: Using monochrome brush.\n")); #define mb ((MC_ENTRY*)(((BYTE*)ppdev->Mtable) + pRbrush->cache_slot))
if (mb->iUniq != pRbrush->iUniq) { CacheMono(ppdev, pRbrush); }
// Load the fg and bg color registers.
REQUIRE(6); LL_FGCOLOR(0xFFFFFFFF, 0); LL_BGCOLOR(0x00000000, 0);
LL32(grOP2_opMRDRAM, pRbrush->cache_xy); *bltdef |= 0x00D0; return(TRUE); } else if (pRbrush->iType == BRUSH_4BPP) // 4-bpp brush.
{ DISPDBG((FILLPATH_DBG_LEVEL, "bSetMask: Using 4-bpp brush.\n")); #define xb ((XC_ENTRY*)(((BYTE*)ppdev->Xtable) + pRbrush->cache_slot))
if (xb->iUniq != pRbrush->iUniq) { Cache4BPP(ppdev, pRbrush); } REQUIRE(2); LL32(grOP2_opMRDRAM, pRbrush->cache_xy); *bltdef |= 0x0090; return(TRUE); } else if (pRbrush->iType == BRUSH_DITHER) // Dither brush.
{ DISPDBG((FILLPATH_DBG_LEVEL, "bSetMask: Using dither brush.\n")); #define db ((DC_ENTRY*)(((BYTE*)ppdev->Dtable) + pRbrush->cache_slot))
if (db->ulColor != pRbrush->iUniq) { CacheDither(ppdev, pRbrush); } REQUIRE(2); LL32(grOP2_opMRDRAM, pRbrush->cache_xy); *bltdef |= 0x0090; return(TRUE); } else // Color brush.
{ DISPDBG((FILLPATH_DBG_LEVEL, "bSetMask: Using color brush.\n")); #define cb ((BC_ENTRY*)(((BYTE*)ppdev->Ctable) + pRbrush->cache_slot))
if (cb->brushID != pRbrush) { CacheBrush(ppdev, pRbrush); } REQUIRE(2); LL32(grOP2_opMRDRAM, pRbrush->cache_xy); *bltdef |= 0x0090; return(TRUE); }
DISPDBG((FILLPATH_DBG_LEVEL, "SetMask Ret False\n")); return FALSE;} #if LOG_CALLS
extern long lg_i;extern char lg_buf[256];
void LogFillPath(ULONG acc,PPDEV ppdev,SURFOBJ *pso){
#if ENABLE_LOG_SWITCH
if (pointer_switch == 0) return; #endif
lg_i = sprintf(lg_buf,"DrvFillPath: "); WriteLogFile(ppdev->pmfile, lg_buf, lg_i, ppdev->TxtBuff, &ppdev->TxtBuffIndex);
// Did we realize it? If not, why?
switch (acc) { case 0: lg_i = sprintf(lg_buf,"(ACCL) Id=%p", pso); break; case 1: lg_i = sprintf(lg_buf,"(Punted - Too many edges) "); break; case 2: lg_i = sprintf(lg_buf,"(Punted - Complex clipping) "); break; case 3: lg_i = sprintf(lg_buf,"(Punted - S3) "); break; case 4: lg_i = sprintf(lg_buf,"(Punted - DevBmp on host) "); break; case 5: lg_i = sprintf(lg_buf,"(Punted - Failed mask) "); break; case 6: lg_i = sprintf(lg_buf,"(Punted - Failed brush) "); break; case 7: lg_i = sprintf(lg_buf,"(Punted - Edge table failed) "); break; default: lg_i = sprintf(lg_buf,"(STATUS UNKNOWN) "); break; } WriteLogFile(ppdev->pmfile, lg_buf, lg_i, ppdev->TxtBuff, &ppdev->TxtBuffIndex);
lg_i = sprintf(lg_buf,"\r\n"); WriteLogFile(ppdev->pmfile, lg_buf, lg_i, ppdev->TxtBuff, &ppdev->TxtBuffIndex);
}#endif
|
