Ros-diffs February 2021

ros-diffs@reactos.org

30 participants
434 discussions

[reactos] 01/01: [NTOS:CM] Report key creation to the notify code

by Eric Kohl

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9ff015f770be41f04ca91… commit 9ff015f770be41f04ca9184e32be02c2db9fae69 Author: Eric Kohl <eric.kohl(a)reactos.org> AuthorDate: Sun Feb 21 15:49:06 2021 +0100 Commit: Eric Kohl <eric.kohl(a)reactos.org> CommitDate: Sun Feb 21 15:49:06 2021 +0100 [NTOS:CM] Report key creation to the notify code --- ntoskrnl/config/cmparse.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/ntoskrnl/config/cmparse.c b/ntoskrnl/config/cmparse.c index 872a79619ae..c5376cf083d 100644 --- a/ntoskrnl/config/cmparse.c +++ b/ntoskrnl/config/cmparse.c @@ -379,6 +379,12 @@ CmpDoCreateChild(IN PHHIVE Hive, /* Now that the security descriptor is copied in the hive, we can free the original */ SeDeassignSecurity(&NewDescriptor); + if (NT_SUCCESS(Status)) + { + /* Send notification to registered callbacks */ + CmpReportNotify(Kcb, Hive, Kcb->KeyCell, REG_NOTIFY_CHANGE_NAME); + } + Quickie: /* Check if we got here because of failure */ if (!NT_SUCCESS(Status))

3 years, 10 months

[reactos] 01/01: [SHIMGVW] Use _countof instead of ARRAYSIZE and use UINT (#3471)

by Katayama Hirofumi MZ

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0c15f7d1837a397feda9d… commit 0c15f7d1837a397feda9d14c9eda405c50e41999 Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> AuthorDate: Sun Feb 21 10:28:08 2021 +0900 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Feb 21 10:28:08 2021 +0900 [SHIMGVW] Use _countof instead of ARRAYSIZE and use UINT (#3471) - Use _countof macro instead of non-standard ARRAYSIZE macro. - Use UINT type for array index instead of INT type, to erase signed/unsigned comparison warning. JIRA issue: N/A --- dll/win32/shimgvw/shimgvw.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/dll/win32/shimgvw/shimgvw.c b/dll/win32/shimgvw/shimgvw.c index a70ef51cc41..962ddd50274 100644 --- a/dll/win32/shimgvw/shimgvw.c +++ b/dll/win32/shimgvw/shimgvw.c @@ -243,7 +243,7 @@ BOOL Anime_Step(DWORD *pdwDelay) static void ZoomInOrOut(BOOL bZoomIn) { - INT i; + UINT i; if (image == NULL) return; @@ -251,12 +251,12 @@ static void ZoomInOrOut(BOOL bZoomIn) if (bZoomIn) /* zoom in */ { /* find next step */ - for (i = 0; i < ARRAYSIZE(ZoomSteps); ++i) + for (i = 0; i < _countof(ZoomSteps); ++i) { if (ZoomPercents < ZoomSteps[i]) break; } - if (i == ARRAYSIZE(ZoomSteps)) + if (i == _countof(ZoomSteps)) ZoomPercents = MAX_ZOOM; else ZoomPercents = ZoomSteps[i]; @@ -271,7 +271,7 @@ static void ZoomInOrOut(BOOL bZoomIn) else /* zoom out */ { /* find previous step */ - for (i = ARRAYSIZE(ZoomSteps); i > 0; ) + for (i = _countof(ZoomSteps); i > 0; ) { --i; if (ZoomSteps[i] < ZoomPercents) @@ -507,7 +507,7 @@ pLoadImageFromNode(SHIMGVW_FILENODE *node, HWND hwnd) pLoadImage(node->FileName); - LoadStringW(hInstance, IDS_APPTITLE, szResStr, ARRAYSIZE(szResStr)); + LoadStringW(hInstance, IDS_APPTITLE, szResStr, _countof(szResStr)); if (image != NULL) { pchFileTitle = PathFindFileNameW(node->FileName); @@ -718,7 +718,7 @@ ImageView_DrawImage(HWND hwnd) { FillRect(hdc, &rect, white); - LoadStringW(hInstance, IDS_NOPREVIEW, szText, ARRAYSIZE(szText)); + LoadStringW(hInstance, IDS_NOPREVIEW, szText, _countof(szText)); SetTextColor(hdc, RGB(0, 0, 0)); SetBkMode(hdc, TRANSPARENT); @@ -859,7 +859,7 @@ ImageView_CreateToolBar(HWND hwnd) hImageList = ImageList_Create(TB_IMAGE_WIDTH, TB_IMAGE_HEIGHT, ILC_MASK | ILC_COLOR24, 1, 1); if (hImageList == NULL) return FALSE; - for (INT n = 0; n < _countof(BtnConfig); n++) + for (UINT n = 0; n < _countof(BtnConfig); n++) { ImageList_AddMasked(hImageList, LoadImageW(hInstance, MAKEINTRESOURCEW(BtnConfig[n].idb), IMAGE_BITMAP, TB_IMAGE_WIDTH, TB_IMAGE_HEIGHT, LR_DEFAULTCOLOR), RGB(255, 255, 255)); @@ -1127,7 +1127,7 @@ ImageView_CreateWindow(HWND hwnd, LPCWSTR szFileName) if (!RegisterClassW(&WndClass)) return -1; - LoadStringW(hInstance, IDS_APPTITLE, szBuf, ARRAYSIZE(szBuf)); + LoadStringW(hInstance, IDS_APPTITLE, szBuf, _countof(szBuf)); hMainWnd = CreateWindowExW(0, L"shimgvw_window", szBuf, WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CAPTION, CW_USEDEFAULT, CW_USEDEFAULT, @@ -1197,7 +1197,7 @@ ImageView_FullscreenA(HWND hwnd, HINSTANCE hInst, LPCSTR path, int nShow) { WCHAR szFile[MAX_PATH]; - if (MultiByteToWideChar(CP_ACP, 0, path, -1, szFile, ARRAYSIZE(szFile))) + if (MultiByteToWideChar(CP_ACP, 0, path, -1, szFile, _countof(szFile))) { ImageView_CreateWindow(hwnd, szFile); }

3 years, 10 months

[reactos] 01/01: [WIN32K] Add StretchBlt function ability to flip images (#3458)

by Doug Lyons

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ce7836c6d3cb755d82c0a… commit ce7836c6d3cb755d82c0a5de7e6fad225b949c3f Author: Doug Lyons <douglyons(a)douglyons.com> AuthorDate: Sat Feb 20 17:28:36 2021 -0600 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Feb 21 08:28:36 2021 +0900 [WIN32K] Add StretchBlt function ability to flip images (#3458) Modify dib\dibxxbpp.c programs to understand flipped images. See Videos at CORE-16642 1. Mirroring Horizontally works. 2. Mirroring Vertically works. 3. Rotation 180° works. CORE-16642, CORE-14408, CORE-16634 --- win32ss/gdi/dib/dib16bpp.c | 309 +++++++++++++++++++++++-- win32ss/gdi/dib/dib1bpp.c | 210 +++++++++++++++-- win32ss/gdi/dib/dib24bpp.c | 289 +++++++++++++++++++++-- win32ss/gdi/dib/dib32bpp.c | 532 ++++++++++++++++++++++++++++++++++++++----- win32ss/gdi/dib/dib32bppc.c | 3 + win32ss/gdi/dib/dib4bpp.c | 201 ++++++++++++++-- win32ss/gdi/dib/dib8bpp.c | 313 +++++++++++++++++++++++-- win32ss/gdi/dib/stretchblt.c | 63 ++++- win32ss/gdi/eng/bitblt.c | 77 ++++++- win32ss/gdi/eng/copybits.c | 55 ++++- win32ss/gdi/eng/stretchblt.c | 344 +++++++++++++++++++++++++++- win32ss/gdi/ntgdi/bitblt.c | 61 +++++ win32ss/gdi/ntgdi/dibobj.c | 12 +- 13 files changed, 2304 insertions(+), 165 deletions(-) diff --git a/win32ss/gdi/dib/dib16bpp.c b/win32ss/gdi/dib/dib16bpp.c index 6ce4568293b..52789cfb3e4 100644 --- a/win32ss/gdi/dib/dib16bpp.c +++ b/win32ss/gdi/dib/dib16bpp.c @@ -6,6 +6,7 @@ * PROGRAMMERS: Jason Filby * Thomas Bluemel * Gregor Anich + * Doug Lyons */ #include <win32k.h> @@ -13,6 +14,9 @@ #define NDEBUG #include <debug.h> +#define DEC_OR_INC(var, decTrue, amount) \ + ((var) = (decTrue) ? ((var) - (amount)) : ((var) + (amount))) + VOID DIB_16BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c) { @@ -142,17 +146,66 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) LONG i, j, sx, sy, xColor, f1; PBYTE SourceBits, DestBits, SourceLine, DestLine; PBYTE SourceBits_4BPP, SourceLine_4BPP; + PWORD Source32, Dest32; + DWORD Index, StartLeft, EndRight; + BOOLEAN bTopToBottom, bLeftToRight; + + DPRINT("DIB_16BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n", + BltInfo->SourceSurface->sizlBitmap.cx, BltInfo->SourceSurface->sizlBitmap.cy, + BltInfo->DestSurface->sizlBitmap.cx, BltInfo->DestSurface->sizlBitmap.cy, + BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom); + + /* Get back left to right flip here */ + bLeftToRight = BltInfo->DestRect.left > BltInfo->DestRect.right; + + /* Check for top to bottom flip needed. */ + bTopToBottom = BltInfo->DestRect.top > BltInfo->DestRect.bottom; + + DPRINT("BltInfo->SourcePoint.x is '%d' & BltInfo->SourcePoint.y is '%d'.\n", + BltInfo->SourcePoint.x, BltInfo->SourcePoint.y); + + /* Make WellOrdered with top < bottom and left < right */ + RECTL_vMakeWellOrdered(&BltInfo->DestRect); + + DPRINT("BPP is '%d/%d' & BltInfo->SourcePoint.x is '%d' & BltInfo->SourcePoint.y is '%d'.\n", + BltInfo->SourceSurface->iBitmapFormat, BltInfo->SourcePoint.x, BltInfo->SourcePoint.y); + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + 2 * BltInfo->DestRect.left; switch(BltInfo->SourceSurface->iBitmapFormat) { case BMF_1BPP: + DPRINT("1BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); sx = BltInfo->SourcePoint.x; + + /* This sets sy to the top line */ sy = BltInfo->SourcePoint.y; + + if (bTopToBottom) + { + /* This sets sy to the bottom line */ + sy += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; - for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) + + if (bLeftToRight) + { + /* This sets the sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + StartLeft = BltInfo->DestRect.left + 1; + EndRight = BltInfo->DestRect.right + 1; + } + else + { + StartLeft = BltInfo->DestRect.left; + EndRight = BltInfo->DestRect.right; + } + + for (i = StartLeft; i < EndRight; i++) { if(DIB_1BPP_GetPixel(BltInfo->SourceSurface, sx, sy) == 0) { @@ -164,21 +217,37 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) DIB_16BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 1)); } - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_4BPP: + DPRINT("4BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets SourceBits_4BPP to the top line */ SourceBits_4BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + (BltInfo->SourcePoint.x >> 1); + if (bTopToBottom) + { + /* This sets SourceBits_4BPP to the bottom line */ + SourceBits_4BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { SourceLine_4BPP = SourceBits_4BPP; sx = BltInfo->SourcePoint.x; + if (bLeftToRight) + { + /* This sets sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + f1 = sx & 1; for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) @@ -188,49 +257,76 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) DIB_16BPP_PutPixel(BltInfo->DestSurface, i, j, xColor); if(f1 == 1) { - SourceLine_4BPP++; + DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1); f1 = 0; } else { f1 = 1; } - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - SourceBits_4BPP += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceBits_4BPP, bTopToBottom, BltInfo->SourceSurface->lDelta); } break; case BMF_8BPP: + DPRINT("8BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets SourceLine to the top line */ SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; DestLine = DestBits; + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->SourceSurface->lDelta + * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { *((WORD *)DestBits) = (WORD)XLATEOBJ_iXlate( BltInfo->XlateSourceToDest, *SourceBits); - SourceBits += 1; + DEC_OR_INC(SourceBits, bLeftToRight, 1); DestBits += 2; } - - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_16BPP: - if (NULL == BltInfo->XlateSourceToDest || 0 != - (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL)) + DPRINT("16BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + DPRINT("BMF_16BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + if ((BltInfo->XlateSourceToDest == NULL || + (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL) != 0) && + (!bTopToBottom && !bLeftToRight)) { + DPRINT("XO_TRIVIAL is TRUE.\n"); if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { + /* This sets SourceBits to the top line */ SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * @@ -248,6 +344,7 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) } else { + /* This sets SourceBits to the bottom line */ SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * @@ -273,6 +370,11 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) } else { + DPRINT("XO_TRIVIAL is NOT TRUE.\n"); + if (!bTopToBottom && !bLeftToRight) + /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */ + { + DPRINT("Flip is None.\n"); if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + @@ -330,14 +432,165 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) DestLine -= BltInfo->DestSurface->lDelta; } } + } + else + { + /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */ + BOOL TopToBottomDone = FALSE; + + if (bLeftToRight) + { + DPRINT("Flip is bLeftToRight.\n"); + + /* Allocate enough pixels for a row in WORD's */ + WORD *store = ExAllocatePoolWithTag(NonPagedPool, + (BltInfo->DestRect.right - BltInfo->DestRect.left + 1) * 2, TAG_DIB); + if (store == NULL) + { + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + WORD Index; + + /* This sets SourceBits to the bottom line */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) + * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x; + + /* Sets DestBits to the bottom line */ + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + + (BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta + + 2 * BltInfo->DestRect.left + 2; + + for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) + { + /* Set Dest32 to right pixel */ + Dest32 = (WORD *) DestBits + (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + Source32 = (WORD *) SourceBits; + + Index = 0; + + /* Store pixels from left to right */ + for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + { + store[Index] = (WORD)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *(WORD *)Source32++); + Index++; + } + + Index = 0; + + /* Copy stored data to pixels from right to left */ + for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + { + *(WORD *)Dest32-- = store[Index]; + Index++; + } + + SourceBits -= BltInfo->SourceSurface->lDelta; + DestBits -= BltInfo->DestSurface->lDelta; + } + ExFreePoolWithTag(store, TAG_DIB); + TopToBottomDone = TRUE; + } + + if (bTopToBottom) + { + DPRINT("Flip is bTopToBottom.\n"); + + /* Allocate enough pixels for a column in WORD's */ + WORD *store = ExAllocatePoolWithTag(NonPagedPool, + (BltInfo->DestRect.bottom - BltInfo->DestRect.top + 1) * 2, TAG_DIB); + if (store == NULL) + { + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + + /* This set SourceBits to the top line */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 2 * BltInfo->SourcePoint.x; + + /* This sets DestBits to the top line */ + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + + ((BltInfo->DestRect.top) * BltInfo->DestSurface->lDelta) + + 2 * BltInfo->DestRect.left; + + if ((BltInfo->SourceSurface->fjBitmap & BMF_TOPDOWN) == 0) + { + DestBits += BltInfo->DestSurface->lDelta; + } + + if (bLeftToRight) + { + DPRINT("Adjusting DestBits for bLeftToRight.\n"); + DestBits += 2; + } + + /* The TopToBottomDone flag indicates that we are flipping for bTopToBottom and bLeftToRight + * and have already completed the bLeftToRight. So we will lose our first flip output + * unless we work with its output which is at the destination site. So in this case + * our new Source becomes the previous outputs Destination. */ + + if (TopToBottomDone) + { + /* This sets SourceBits to the top line */ + SourceBits = DestBits; + } + + for (j = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= j ; j--) + { + /* Set Dest32 to bottom pixel */ + Dest32 = (WORD *) DestBits + (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) + * BltInfo->DestSurface->lDelta / 2; + Source32 = (WORD *) SourceBits; + + Index = 0; + + /* Store pixels from top to bottom */ + for (i = BltInfo->DestRect.top; i <= BltInfo->DestRect.bottom - 1; i++) + { + store[Index] = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32); + Source32 += BltInfo->SourceSurface->lDelta / 2; + Index++; + } + + Index = 0; + + /* Copy stored data to pixels from bottom to top */ + for (i = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= i; i--) + { + *Dest32 = store[Index]; + Dest32 -= BltInfo->DestSurface->lDelta / 2; + Index++; + } + SourceBits += 2; + DestBits += 2; + } + ExFreePoolWithTag(store, TAG_DIB); + } + + } } break; case BMF_24BPP: + + DPRINT("BMF_24BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets SourceLine to the top line */ SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x; + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) @@ -345,6 +598,11 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets the SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 3; + } for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = (*(SourceBits + 2) << 0x10) + @@ -353,19 +611,27 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) *((WORD *)DestBits) = (WORD)XLATEOBJ_iXlate( BltInfo->XlateSourceToDest, xColor); - SourceBits += 3; + DEC_OR_INC(SourceBits, bLeftToRight, 3); DestBits += 2; } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_32BPP: + DPRINT("32BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1; + } DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) @@ -373,23 +639,29 @@ DIB_16BPP_BitBltSrcCopy(PBLTINFO BltInfo) SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 4; + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { *((WORD *)DestBits) = (WORD)XLATEOBJ_iXlate( BltInfo->XlateSourceToDest, *((PDWORD) SourceBits)); - SourceBits += 4; + DEC_OR_INC(SourceBits, bLeftToRight, 4); DestBits += 2; } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; default: - DPRINT1("DIB_16BPP_Bitblt: Unhandled Source BPP: %u\n", - BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat)); + DPRINT1("DIB_16BPP_BitBltSrcCopy: Unhandled Source BPP: %u\n", + BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat)); return FALSE; } @@ -402,6 +674,9 @@ DIB_16BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color) { LONG DestY; + /* Make WellOrdered with top < bottom and left < right */ + RECTL_vMakeWellOrdered(DestRect); + #if defined(_M_IX86) && !defined(_MSC_VER) /* This is about 10% faster than the generic C code below */ ULONG delta = DestSurface->lDelta; diff --git a/win32ss/gdi/dib/dib1bpp.c b/win32ss/gdi/dib/dib1bpp.c index e5dc0fda639..034570e9cad 100644 --- a/win32ss/gdi/dib/dib1bpp.c +++ b/win32ss/gdi/dib/dib1bpp.c @@ -4,6 +4,7 @@ * FILE: win32ss/gdi/dib/dib1bpp.c * PURPOSE: Device Independant Bitmap functions, 1bpp * PROGRAMMERS: Jason Filby + * Doug Lyons */ #include <win32k.h> @@ -11,6 +12,9 @@ #define NDEBUG #include <debug.h> +#define DEC_OR_INC(var, decTrue, amount) \ + ((var) = (decTrue) ? ((var) - (amount)) : ((var) + (amount))) + VOID DIB_1BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c) { @@ -57,13 +61,18 @@ DIB_1BPP_BitBltSrcCopy_From1BPP ( SURFOBJ* SourceSurf, XLATEOBJ* pxlo, PRECTL DestRect, - POINTL *SourcePoint ) + POINTL *SourcePoint, + BOOLEAN bTopToBottom, + BOOLEAN bLeftToRight ) { + + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); + // The 'window' in this sense is the x-position that corresponds // to the left-edge of the 8-pixel byte we are currently working with. // dwx is current x-window, dwx2 is the 'last' window we need to process. int dwx, dwx2; // Destination window x-position - int swx; // Source window y-position + int swx; // Source window x-position // Left and right edges of source and dest rectangles int dl = DestRect->left; // dest left @@ -96,39 +105,75 @@ DIB_1BPP_BitBltSrcCopy_From1BPP ( if ( DestRect->top <= SourcePoint->y ) { + DPRINT("Moving up (scan top -> bottom).\n"); // Moving up (scan top -> bottom) dy1 = DestRect->top; dy2 = DestRect->bottom - 1; - sy1 = SourcePoint->y; + if (bTopToBottom) + { + sy1 = SourcePoint->y + dy2 - dy1; + ySrcDelta = -SourceSurf->lDelta; + } + else + { + sy1 = SourcePoint->y; + ySrcDelta = SourceSurf->lDelta; + } yinc = 1; - ySrcDelta = SourceSurf->lDelta; yDstDelta = DestSurf->lDelta; } else { + DPRINT("Moving down (scan bottom -> top).\n"); // Moving down (scan bottom -> top) dy1 = DestRect->bottom - 1; dy2 = DestRect->top; - sy1 = SourcePoint->y + dy1 - dy2; + if (bTopToBottom) + { + sy1 = SourcePoint->y; + ySrcDelta = SourceSurf->lDelta; + } + else + { + sy1 = SourcePoint->y + dy1 - dy2; + ySrcDelta = -SourceSurf->lDelta; + } yinc = -1; - ySrcDelta = -SourceSurf->lDelta; yDstDelta = -DestSurf->lDelta; } if ( DestRect->left <= SourcePoint->x ) { + DPRINT("Moving left (scan left->right).\n"); // Moving left (scan left->right) dwx = dl&~7; - swx = (sl-(dl&7))&~7; dwx2 = dr&~7; - xinc = 1; + if (bLeftToRight) + { + swx = (sr - (dr & 7)) & ~7; + xinc = -1; + } + else + { + swx = (sl-(dl&7))&~7; + xinc = 1; + } } else { + DPRINT("Moving right (scan right->left).\n"); // Moving right (scan right->left) dwx = dr & ~7; - swx = (sr - (dr & 7)) & ~7; // (sr - 7) & ~7; // We need the left edge of this block. Thus the -7 dwx2 = dl & ~7; - xinc = -1; + if (bLeftToRight) + { + swx = (sl-(dl&7))&~7; + xinc = 1; + } + else + { + swx = (sr - (dr & 7)) & ~7; // (sr - 7) & ~7; // We need the left edge of this block. Thus the -7 + xinc = -1; + } } d = &(((PBYTE)DestSurf->pvScan0)[dy1*DestSurf->lDelta + (dwx>>3)]); s = &(((PBYTE)SourceSurf->pvScan0)[sy1*SourceSurf->lDelta + (swx>>3)]); @@ -227,81 +272,199 @@ BOOLEAN DIB_1BPP_BitBltSrcCopy(PBLTINFO BltInfo) { ULONG Color; - LONG i, j, sx, sy = BltInfo->SourcePoint.y; + LONG i, j, sx, sy; + BOOLEAN bTopToBottom, bLeftToRight; + + // This sets sy to the top line + sy = BltInfo->SourcePoint.y; + + DPRINT("DIB_1BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n", + BltInfo->SourceSurface->sizlBitmap.cx, BltInfo->SourceSurface->sizlBitmap.cy, + BltInfo->DestSurface->sizlBitmap.cx, BltInfo->DestSurface->sizlBitmap.cy, + BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom); + + /* Get back left to right flip here */ + bLeftToRight = (BltInfo->DestRect.left > BltInfo->DestRect.right); + + /* Check for top to bottom flip needed. */ + bTopToBottom = BltInfo->DestRect.top > BltInfo->DestRect.bottom; + + // Make WellOrdered with top < bottom and left < right + RECTL_vMakeWellOrdered(&BltInfo->DestRect); + + DPRINT("BPP is '%d' & BltInfo->SourcePoint.x is '%d' & BltInfo->SourcePoint.y is '%d'.\n", + BltInfo->SourceSurface->iBitmapFormat, BltInfo->SourcePoint.x, BltInfo->SourcePoint.y); switch ( BltInfo->SourceSurface->iBitmapFormat ) { case BMF_1BPP: - DIB_1BPP_BitBltSrcCopy_From1BPP ( BltInfo->DestSurface, BltInfo->SourceSurface, BltInfo->XlateSourceToDest, &BltInfo->DestRect, &BltInfo->SourcePoint ); + DPRINT("1BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + DIB_1BPP_BitBltSrcCopy_From1BPP ( BltInfo->DestSurface, BltInfo->SourceSurface, + BltInfo->XlateSourceToDest, &BltInfo->DestRect, &BltInfo->SourcePoint, + bTopToBottom, bLeftToRight ); break; case BMF_4BPP: + DPRINT("4BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + if (bTopToBottom) + { + // This sets sy to the bottom line + sy += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + // This sets the sx to the rightmost pixel + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy)); DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, Color); - sx++; + + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_8BPP: + DPRINT("8BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + if (bTopToBottom) + { + // This sets sy to the bottom line + sy += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + // This sets sx to the rightmost pixel + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_8BPP_GetPixel(BltInfo->SourceSurface, sx, sy)); DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, Color); - sx++; + + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_16BPP: + DPRINT("16BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + if (bTopToBottom) + { + // This sets sy to the bottom line + sy += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + // This sets the sx to the rightmost pixel + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_16BPP_GetPixel(BltInfo->SourceSurface, sx, sy)); DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, Color); - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_24BPP: + + DPRINT("24BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + if (bTopToBottom) + { + // This sets sy to the bottom line + sy += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + // This sets the sx to the rightmost pixel + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_24BPP_GetPixel(BltInfo->SourceSurface, sx, sy)); DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, Color); - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_32BPP: + + DPRINT("32BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + if (bTopToBottom) + { + // This sets sy to the bottom line + sy += BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + // This sets the sx to the rightmost pixel + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_32BPP_GetPixel(BltInfo->SourceSurface, sx, sy)); DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, Color); - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; @@ -460,6 +623,9 @@ DIB_1BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color) { LONG DestY; + /* Make WellOrdered with top < bottom and left < right */ + RECTL_vMakeWellOrdered(DestRect); + for (DestY = DestRect->top; DestY< DestRect->bottom; DestY++) { DIB_1BPP_HLine(DestSurface, DestRect->left, DestRect->right, DestY, color); diff --git a/win32ss/gdi/dib/dib24bpp.c b/win32ss/gdi/dib/dib24bpp.c index 0974842b503..bc12095843e 100644 --- a/win32ss/gdi/dib/dib24bpp.c +++ b/win32ss/gdi/dib/dib24bpp.c @@ -6,6 +6,7 @@ * PROGRAMMERS: Jason Filby * Thomas Bluemel * Gregor Anich + * Doug Lyons */ #include <win32k.h> @@ -13,6 +14,9 @@ #define NDEBUG #include <debug.h> +#define DEC_OR_INC(var, decTrue, amount) \ + ((var) = (decTrue) ? ((var) - (amount)) : ((var) + (amount))) + VOID DIB_24BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c) { @@ -53,6 +57,24 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) PBYTE SourceBits, DestBits, SourceLine, DestLine; PBYTE SourceBits_4BPP, SourceLine_4BPP; PWORD SourceBits_16BPP, SourceLine_16BPP; + BOOLEAN bTopToBottom, bLeftToRight; + + DPRINT("DIB_24BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n", + BltInfo->SourceSurface->sizlBitmap.cx, BltInfo->SourceSurface->sizlBitmap.cy, + BltInfo->DestSurface->sizlBitmap.cx, BltInfo->DestSurface->sizlBitmap.cy, + BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom); + + /* Get back left to right flip here */ + bLeftToRight = (BltInfo->DestRect.left > BltInfo->DestRect.right); + + /* Check for top to bottom flip needed. */ + bTopToBottom = BltInfo->DestRect.top > BltInfo->DestRect.bottom; + + DPRINT("BltInfo->SourcePoint.x is '%d' and BltInfo->SourcePoint.y is '%d'.\n", + BltInfo->SourcePoint.x, BltInfo->SourcePoint.y); + + /* Make WellOrdered by making top < bottom and left < right */ + RECTL_vMakeWellOrdered(&BltInfo->DestRect); DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left * 3; @@ -60,11 +82,26 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) { case BMF_1BPP: sx = BltInfo->SourcePoint.x; + + /* This sets sy to the top line */ sy = BltInfo->SourcePoint.y; + if (bTopToBottom) + { + /* This sets sy to the bottom line */ + sy += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + /* This sets sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { if(DIB_1BPP_GetPixel(BltInfo->SourceSurface, sx, sy) == 0) @@ -73,20 +110,37 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) } else { DIB_24BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 1)); } - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_4BPP: + DPRINT("4BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets SourceBits_4BPP to the top line */ SourceBits_4BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + (BltInfo->SourcePoint.x >> 1); + if (bTopToBottom) + { + /* This sets SourceBits_4BPP to the bottom line */ + SourceBits_4BPP += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { SourceLine_4BPP = SourceBits_4BPP; DestLine = DestBits; sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + /* This sets sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + f1 = sx & 1; for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) @@ -96,17 +150,33 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) *DestLine++ = xColor & 0xff; *(PWORD)DestLine = (WORD)(xColor >> 8); DestLine += 2; - if(f1 == 1) { SourceLine_4BPP++; f1 = 0; } else { f1 = 1; } - sx++; + if(f1 == 1) { + DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1); + f1 = 0; + } + else + { + f1 = 1; + } + DEC_OR_INC(sx, bLeftToRight, 1); } - - SourceBits_4BPP += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceBits_4BPP, bTopToBottom, BltInfo->SourceSurface->lDelta); DestBits += BltInfo->DestSurface->lDelta; } break; case BMF_8BPP: + DPRINT("8BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets SourceLine to the top line */ SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) @@ -114,47 +184,83 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets the SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *SourceBits); *DestBits = xColor & 0xff; *(PWORD)(DestBits + 1) = (WORD)(xColor >> 8); - SourceBits += 1; + DEC_OR_INC(SourceBits, bLeftToRight, 1); DestBits += 3; } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_16BPP: + DPRINT("16BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets SourceBits_16BPP to the top line */ SourceBits_16BPP = (PWORD)((PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x); + if (bTopToBottom) + { + /* This sets SourceBits_16BPP to the bottom line */ + SourceBits_16BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { SourceLine_16BPP = SourceBits_16BPP; DestLine = DestBits; + if (bLeftToRight) + { + /* This sets the SourceLine_16BPP to the rightmost pixel */ + SourceLine_16BPP += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { xColor = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *SourceLine_16BPP); *DestLine++ = xColor & 0xff; *(PWORD)DestLine = (WORD)(xColor >> 8); DestLine += 2; - SourceLine_16BPP++; + DEC_OR_INC(SourceLine_16BPP, bLeftToRight, 1); + } + if (bTopToBottom) + { + SourceBits_16BPP = (PWORD)((PBYTE)SourceBits_16BPP - BltInfo->SourceSurface->lDelta); + } + else + { + SourceBits_16BPP = (PWORD)((PBYTE)SourceBits_16BPP + BltInfo->SourceSurface->lDelta); } - - SourceBits_16BPP = (PWORD)((PBYTE)SourceBits_16BPP + BltInfo->SourceSurface->lDelta); DestBits += BltInfo->DestSurface->lDelta; } break; case BMF_24BPP: - if (NULL == BltInfo->XlateSourceToDest || 0 != (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL)) + DPRINT("24BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* Check for no flips here because we are about to use RtlMoveMemory and it can only do increasing src & dst */ + if ((BltInfo->XlateSourceToDest == NULL || + (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL) != 0) && + (!bTopToBottom && !bLeftToRight)) { + DPRINT("XO_TRIVIAL is TRUE.\n"); if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { + /* This sets SourceBits to the top line */ SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { @@ -176,6 +282,11 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) } } else + { + DPRINT("XO_TRIVIAL is NOT TRUE.\n"); + + if (!bTopToBottom && !bLeftToRight) + /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */ { sx = BltInfo->SourcePoint.x; sy = BltInfo->SourcePoint.y; @@ -191,11 +302,151 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) } sy++; } + } + else + { + /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */ + BOOL TopToBottomDone = FALSE; + + if (bLeftToRight) + { + DPRINT("Flip is bLeftToRight.\n"); + DWORD Index; + + /* Allocate enough pixels for a row in DWORD's */ + DWORD *store = ExAllocatePoolWithTag(NonPagedPool, + (BltInfo->DestRect.right - BltInfo->DestRect.left + 1) * 4, TAG_DIB); + if (store == NULL) + { + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + + sx = BltInfo->SourcePoint.x; + /* This sets sy to the top line */ + sy = BltInfo->SourcePoint.y; + + /* This sets sx to the rightmost pixel */ + sx = BltInfo->SourcePoint.x + (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) + { + + /* This sets sx to the rightmost pixel */ + sx = BltInfo->SourcePoint.x + (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + + Index = 0; + + // Read right to left and store + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + store[Index] = DIB_24BPP_GetPixel(BltInfo->SourceSurface, sx, sy); + Index++; + sx--; + } + + Index = 0; + + // Write left to right to pixel + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + DIB_24BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, store[Index])); + Index++; + } + sy++; + } + ExFreePoolWithTag(store, TAG_DIB); + TopToBottomDone = TRUE; + } + + if (bTopToBottom) + { + DPRINT("Flip is bTopToBottom.\n"); + DWORD Index; + + /* Allocate enough pixels for a column in DWORD's */ + DWORD *store = ExAllocatePoolWithTag(NonPagedPool, + (BltInfo->DestRect.bottom - BltInfo->DestRect.top + 1) * 4, TAG_DIB); + if (store == NULL) + { + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + + /* The TopToBottomDone flag indicates that we are flipping for bTopToBottom and bLeftToRight + * and have already completed the bLeftToRight. So we will lose our first flip output + * unless we work with its output which is at the destination site. So in this case + * our new Source becomes the previous outputs Destination. + */ + + if (TopToBottomDone) + { + sx = BltInfo->DestRect.left; + sy = BltInfo->DestRect.top; + + /* This sets sy to the bottom line */ + sy += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } + else + { + sx = BltInfo->SourcePoint.x; + + /* This sets sy to the top line */ + sy = BltInfo->SourcePoint.y; + + /* This sets sy to the bottom line */ + sy = BltInfo->SourcePoint.y + (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } + + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + + /* This sets sy to the bottom line */ + sy = BltInfo->SourcePoint.y + (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + Index = 0; + + /* Read bottom to top and store */ + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) + { + if (TopToBottomDone) + { + store[Index] = DIB_24BPP_GetPixel(BltInfo->DestSurface, sx, sy); + } + else + { + store[Index] = DIB_24BPP_GetPixel(BltInfo->SourceSurface, sx, sy); + } + Index++; + sy--; + } + + Index = 0; + + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) + { + DIB_24BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, store[Index])); + Index++; + } + sx++; + } + ExFreePoolWithTag(store, TAG_DIB); + } + + } } break; case BMF_32BPP: + DPRINT("32BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1; + } DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) @@ -203,16 +454,21 @@ DIB_24BPP_BitBltSrcCopy(PBLTINFO BltInfo) SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 4; + } for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *((PDWORD) SourceBits)); *DestBits = xColor & 0xff; *(PWORD)(DestBits + 1) = (WORD)(xColor >> 8); - SourceBits += 4; + DEC_OR_INC(SourceBits, bLeftToRight, 4); DestBits += 3; } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; @@ -255,7 +511,9 @@ DIB_24BPP_BitBlt(PBLTINFO BltInfo) else { if (BltInfo->Brush) + { Pattern = BltInfo->Brush->iSolidColor; + } } } @@ -301,6 +559,9 @@ DIB_24BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color) { LONG DestY; + /* Make WellOrdered by making top < bottom and left < right */ + RECTL_vMakeWellOrdered(DestRect); + #if defined(_M_IX86) && !defined(_MSC_VER) PBYTE xaddr = (PBYTE)DestSurface->pvScan0 + DestRect->top * DestSurface->lDelta + (DestRect->left << 1) + DestRect->left; PBYTE addr; diff --git a/win32ss/gdi/dib/dib32bpp.c b/win32ss/gdi/dib/dib32bpp.c index 78124b8d49a..1b2d920e96e 100644 --- a/win32ss/gdi/dib/dib32bpp.c +++ b/win32ss/gdi/dib/dib32bpp.c @@ -6,6 +6,7 @@ * PROGRAMMERS: Jason Filby * Thomas Bluemel * Gregor Anich + * Doug Lyons */ #include <win32k.h> @@ -13,6 +14,9 @@ #define NDEBUG #include <debug.h> +#define DEC_OR_INC(var, decTrue, amount) \ + ((var) = (decTrue) ? ((var) - (amount)) : ((var) + (amount))) + VOID DIB_32BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c) { @@ -51,46 +55,137 @@ DIB_32BPP_BitBltSrcCopy(PBLTINFO BltInfo) { LONG i, j, sx, sy, xColor, f1; PBYTE SourceBits, DestBits, SourceLine, DestLine; + PBYTE SourceBitsT, SourceBitsB, DestBitsT, DestBitsB; PBYTE SourceBits_4BPP, SourceLine_4BPP; PDWORD Source32, Dest32; + DWORD Index, DestWidth, DestHeight; + BOOLEAN bTopToBottom, bLeftToRight; + BOOLEAN blDeltaSrcNeg, blDeltaDestNeg; + BOOLEAN blDeltaAdjustDone = FALSE; + + DPRINT("DIB_32BPP_BitBltSrcCopy: SourcePoint (%d, %d), SourceSurface cx/cy (%d/%d), " + "DestSurface cx/cy (%d/%d) DestRect: (%d,%d)-(%d,%d)\n", + BltInfo->SourcePoint.x, BltInfo->SourcePoint.y, + BltInfo->SourceSurface->sizlBitmap.cx, BltInfo->SourceSurface->sizlBitmap.cy, + BltInfo->DestSurface->sizlBitmap.cx, BltInfo->DestSurface->sizlBitmap.cy, + BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom); + + DPRINT("BltInfo->DestSurface->lDelta is '%d' and BltInfo->SourceSurface->lDelta is '%d'.\n", + BltInfo->DestSurface->lDelta, BltInfo->SourceSurface->lDelta); + + DPRINT("iBitmapFormat is %d and width,height is (%d,%d).\n", BltInfo->SourceSurface->iBitmapFormat, + BltInfo->DestRect.right - BltInfo->DestRect.left, BltInfo->DestRect.bottom - BltInfo->DestRect.top); + + DPRINT("BltInfo->SourcePoint.x is '%d' and BltInfo->SourcePoint.y is '%d'.\n", + BltInfo->SourcePoint.x, BltInfo->SourcePoint.y); + + /* Do not deal with negative numbers for these values */ + if ((BltInfo->DestRect.left < 0) || (BltInfo->DestRect.top < 0) || + (BltInfo->DestRect.right < 0) || (BltInfo->DestRect.bottom < 0)) + return FALSE; + + /* Detect negative lDelta's meaning Bottom-Up bitmaps */ + blDeltaSrcNeg = BltInfo->SourceSurface->lDelta < 0; + blDeltaDestNeg = BltInfo->DestSurface->lDelta < 0; + + /* Get back left to right flip here */ + bLeftToRight = BltInfo->DestRect.left > BltInfo->DestRect.right; + + /* Check for top to bottom flip needed. */ + bTopToBottom = BltInfo->DestRect.top > BltInfo->DestRect.bottom; + + DPRINT("bTopToBottom is '%d' and DestSurface->lDelta < 0 is '%d' and SourceSurface->lDelta < 0 is '%d'.\n", + bTopToBottom, BltInfo->DestSurface->lDelta < 0 ? 1 : 0, BltInfo->SourceSurface->lDelta < 0 ? 1 : 0); + + /* Make WellOrdered with top < bottom and left < right */ + RECTL_vMakeWellOrdered(&BltInfo->DestRect); + + DestWidth = BltInfo->DestRect.right - BltInfo->DestRect.left; + DestHeight = BltInfo->DestRect.bottom - BltInfo->DestRect.top; DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + 4 * BltInfo->DestRect.left; + DPRINT("iBitmapFormat is %d and width,height is (%d,%d).\n", BltInfo->SourceSurface->iBitmapFormat, + DestWidth, DestHeight); + switch (BltInfo->SourceSurface->iBitmapFormat) { case BMF_1BPP: + DPRINT("1BPP Case Selected with DestRect Width of '%d'.\n", + DestWidth); + + if (bLeftToRight || bTopToBottom) + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); sx = BltInfo->SourcePoint.x; + + /* This sets sy to the top line */ sy = BltInfo->SourcePoint.y; + if (bTopToBottom) + { + /* This sets sy to the bottom line */ + sy += BltInfo->SourceSurface->lDelta * (DestHeight - 1); + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; - for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) + + if (bLeftToRight) + { + /* This sets the sx to the rightmost pixel */ + sx += (DestWidth - 1); + } + + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { if (DIB_1BPP_GetPixel(BltInfo->SourceSurface, sx, sy) == 0) { DIB_32BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 0)); - } else { + } + else + { DIB_32BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 1)); } - sx++; + + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_4BPP: + DPRINT("4BPP Case Selected with DestRect Width of '%d'.\n", + DestWidth); + + if (bLeftToRight || bTopToBottom) + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); + + /* This sets SourceBits_4BPP to the top line */ SourceBits_4BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + (BltInfo->SourcePoint.x >> 1); + if (bTopToBottom) + { + /* This sets SourceBits_4BPP to the bottom line */ + SourceBits_4BPP += BltInfo->SourceSurface->lDelta * (DestHeight - 1); + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { SourceLine_4BPP = SourceBits_4BPP; sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + /* This sets sx to the rightmost pixel */ + sx += (DestWidth - 1); + } + f1 = sx & 1; for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) @@ -99,66 +194,120 @@ DIB_32BPP_BitBltSrcCopy(PBLTINFO BltInfo) (*SourceLine_4BPP & altnotmask[f1]) >> (4 * (1 - f1))); DIB_32BPP_PutPixel(BltInfo->DestSurface, i, j, xColor); if (f1 == 1) { - SourceLine_4BPP++; + DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1); f1 = 0; } else { f1 = 1; } - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - - SourceBits_4BPP += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceBits_4BPP, bTopToBottom, BltInfo->SourceSurface->lDelta); } break; case BMF_8BPP: - SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; + DPRINT("8BPP Case Selected with DestRect Width of '%d'.\n", + DestWidth); + + if (bLeftToRight || bTopToBottom) + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); + + /* This sets SourceLine to the top line */ + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + BltInfo->SourcePoint.x; DestLine = DestBits; + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->SourceSurface->lDelta * (DestHeight - 1); + } + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets the SourceBits to the rightmost pixel */ + SourceBits += (DestWidth - 1); + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = *SourceBits; *((PDWORD) DestBits) = (DWORD)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor); - SourceBits += 1; + DEC_OR_INC(SourceBits, bLeftToRight, 1); DestBits += 4; } - - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_16BPP: - SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x; + DPRINT("16BPP Case Selected with DestRect Width of '%d'.\n", + DestWidth); + + if (bLeftToRight || bTopToBottom) + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); + + /* This sets SourceLine to the top line */ + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 2 * BltInfo->SourcePoint.x; DestLine = DestBits; + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->SourceSurface->lDelta * (DestHeight - 1); + } + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets the SourceBits to the rightmost pixel */ + SourceBits += (DestWidth - 1) * 2; + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = *((PWORD) SourceBits); *((PDWORD) DestBits) = (DWORD)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor); - SourceBits += 2; + DEC_OR_INC(SourceBits, bLeftToRight, 2); DestBits += 4; } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_24BPP: + DPRINT("24BPP Case Selected with DestRect Width of '%d'.\n", + DestWidth); + + if (bLeftToRight || bTopToBottom) + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); + + /* This sets SourceLine to the top line */ SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->SourceSurface->lDelta * (DestHeight - 1); + } + DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) @@ -166,113 +315,382 @@ DIB_32BPP_BitBltSrcCopy(PBLTINFO BltInfo) SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets the SourceBits to the rightmost pixel */ + SourceBits += (DestWidth - 1) * 3; + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = (*(SourceBits + 2) << 0x10) + (*(SourceBits + 1) << 0x08) + (*(SourceBits)); *((PDWORD)DestBits) = (DWORD)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor); - SourceBits += 3; + DEC_OR_INC(SourceBits, bLeftToRight, 3); DestBits += 4; } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_32BPP: - if (NULL == BltInfo->XlateSourceToDest || - 0 != (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL)) + DPRINT("32BPP Case Selected with SourcePoint (%d,%d) and DestRect Width/height of '%d/%d' DestRect: (%d,%d)-(%d,%d).\n", + BltInfo->SourcePoint.x, BltInfo->SourcePoint.y, DestWidth, DestHeight, + BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom); + + if (bLeftToRight || bTopToBottom) + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); + + /* This handles the negative lDelta's which represent Top-to-Bottom bitmaps */ + if (((blDeltaSrcNeg || blDeltaDestNeg) && !(blDeltaSrcNeg && blDeltaDestNeg)) && bTopToBottom) { + DPRINT("Adjusting for lDelta's here.\n"); if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { - SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + /* SourceBits points to top-left pixel for lDelta < 0 and bottom-left for lDelta > 0 */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { - RtlMoveMemory(DestBits, SourceBits, 4 * (BltInfo->DestRect.right - BltInfo->DestRect.left)); + RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth); SourceBits += BltInfo->SourceSurface->lDelta; DestBits += BltInfo->DestSurface->lDelta; } } else { + /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */ SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y - + BltInfo->DestRect.bottom - - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + + DestHeight - 1) * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; - DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + 4 * BltInfo->DestRect.left; + /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */ + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + + 4 * BltInfo->DestRect.left; for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) { - RtlMoveMemory(DestBits, SourceBits, 4 * (BltInfo->DestRect.right - BltInfo->DestRect.left)); + RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth); SourceBits -= BltInfo->SourceSurface->lDelta; DestBits -= BltInfo->DestSurface->lDelta; } } + blDeltaAdjustDone = TRUE; } - else + + /* This tests for whether we can use simplified/quicker code below. + * It works for increasing source and destination areas only and there is no overlap and no flip. + */ + if ((BltInfo->XlateSourceToDest == NULL || + (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL) != 0) && + (!bTopToBottom && !bLeftToRight)) { + DPRINT("XO_TRIVIAL is TRUE.\n"); + if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { - SourceBits = ((PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x); + /* SourceBits points to top-left pixel for lDelta < 0 and bottom-left for lDelta > 0 */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { - if (BltInfo->DestRect.left < BltInfo->SourcePoint.x) + RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth); + SourceBits += BltInfo->SourceSurface->lDelta; + DestBits += BltInfo->DestSurface->lDelta; + } + } + else + { + /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + ((BltInfo->SourcePoint.y + + DestHeight - 1) * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x; + /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */ + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + + 4 * BltInfo->DestRect.left; + for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) + { + RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth); + SourceBits -= BltInfo->SourceSurface->lDelta; + DestBits -= BltInfo->DestSurface->lDelta; + } + } + } + else + { + DPRINT("XO_TRIVIAL is NOT TRUE.\n"); + + if (!bTopToBottom && !bLeftToRight) + { + if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) + { + SourceBits = ((PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x); + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { - Dest32 = (DWORD *) DestBits; - Source32 = (DWORD *) SourceBits; - for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + if (BltInfo->DestRect.left < BltInfo->SourcePoint.x) { - *Dest32++ = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32++); + Dest32 = (DWORD *) DestBits; + Source32 = (DWORD *) SourceBits; + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + *Dest32++ = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32++); + } } + else + { + Dest32 = (DWORD *) DestBits + (DestWidth - 1); + Source32 = (DWORD *) SourceBits + (DestWidth - 1); + for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + { + *Dest32-- = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32--); + } + } + SourceBits += BltInfo->SourceSurface->lDelta; + DestBits += BltInfo->DestSurface->lDelta; } - else + } + else + { + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + ((BltInfo->SourcePoint.y + + DestHeight - 1) * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x; + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + + 4 * BltInfo->DestRect.left; + for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) { - Dest32 = (DWORD *) DestBits + (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); - Source32 = (DWORD *) SourceBits + (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); - for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + if (BltInfo->DestRect.left < BltInfo->SourcePoint.x) { - *Dest32-- = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32--); + Dest32 = (DWORD *) DestBits; + Source32 = (DWORD *) SourceBits; + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + *Dest32++ = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32++); + } } + else + { + Dest32 = (DWORD *) DestBits + (DestWidth - 1); + Source32 = (DWORD *) SourceBits + (DestWidth - 1); + for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + { + *Dest32-- = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32--); + } + } + SourceBits -= BltInfo->SourceSurface->lDelta; + DestBits -= BltInfo->DestSurface->lDelta; } - SourceBits += BltInfo->SourceSurface->lDelta; - DestBits += BltInfo->DestSurface->lDelta; } } else { - SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; - DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + 4 * BltInfo->DestRect.left; - for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) + /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */ + BOOL TopToBottomDone = FALSE; + + /* No need to flip a LeftToRight bitmap only one pixel wide */ + if ((bLeftToRight) && (DestWidth > 1)) { - if (BltInfo->DestRect.left < BltInfo->SourcePoint.x) + DPRINT("Flip is bLeftToRight.\n"); + + /* Allocate enough pixels for a row in DWORD's */ + DWORD *store = ExAllocatePoolWithTag(NonPagedPool, + (DestWidth + 1) * 4, TAG_DIB); + if (store == NULL) { - Dest32 = (DWORD *) DestBits; - Source32 = (DWORD *) SourceBits; - for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) - { - *Dest32++ = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32++); - } + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + + /* This sets SourceBits to the bottom line */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + ((BltInfo->SourcePoint.y + DestHeight - 1) + * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + + /* This sets DestBits to the bottom line */ + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + + (BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta + + 4 * BltInfo->DestRect.left; + + for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) + { + + /* Set Dest32 to right pixel */ + Dest32 = (DWORD *) DestBits + (DestWidth - 1); + Source32 = (DWORD *) SourceBits; + + Index = 0; + + /* Store pixels from left to right */ + for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + { + store[Index] = *Source32++; + Index++; + } + + Index = 0; + + /* Copy stored dat to pixels from right to left */ + for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + { + *Dest32-- = store[Index]; + Index++; + } + SourceBits -= BltInfo->SourceSurface->lDelta; + DestBits -= BltInfo->DestSurface->lDelta; + } + ExFreePoolWithTag(store, TAG_DIB); + TopToBottomDone = TRUE; + } + + /* Top to Botoom Handling if bitmap more than one pixel high */ + if ((bTopToBottom) && (DestHeight > 1)) + { + /* Note: It is very important that this code remain optimized for time used. + * Otherwise you will have random crashes in ReactOS that are undesirable. + * For an example of this just try executing the code here two times. + */ + + DPRINT("Flip is bTopToBottom.\n"); + + /* Allocate enough pixels for a row in DWORD's */ + DWORD *store = ExAllocatePoolWithTag(NonPagedPool, + (DestWidth + 1) * 4, TAG_DIB); + if (store == NULL) + { + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + + /* This set DestBitsT to the top line */ + DestBitsT = (PBYTE)BltInfo->DestSurface->pvScan0 + + ((BltInfo->DestRect.top) * BltInfo->DestSurface->lDelta) + + 4 * BltInfo->DestRect.left; + + /* This sets DestBitsB to the bottom line */ + DestBitsB = (PBYTE)BltInfo->DestSurface->pvScan0 + + (BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta + + 4 * BltInfo->DestRect.left; + + /* The TopToBottomDone flag indicates that we are flipping for bTopToBottom and bLeftToRight + * and have already completed the bLeftToRight. So we will lose our first flip output + * unless we work with its output which is at the destination site. So in this case + * our new Source becomes the previous outputs Destination. + * Also in we use the same logic when we have corrected for negative lDelta's above + * and already completed a flip from Source to Destination for the first step + */ + + if (TopToBottomDone || blDeltaAdjustDone) + { + /* This sets SourceBitsB to the bottom line */ + SourceBitsB = DestBitsB; + + /* This sets SourceBitsT to the top line */ + SourceBitsT = DestBitsT; } else { - Dest32 = (DWORD *) DestBits + (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); - Source32 = (DWORD *) SourceBits + (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); - for (i = BltInfo->DestRect.right - 1; BltInfo->DestRect.left <= i; i--) + /* This sets SourceBitsB to the bottom line */ + SourceBitsB = (PBYTE)BltInfo->SourceSurface->pvScan0 + + ((BltInfo->SourcePoint.y + DestHeight - 1) + * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + + /* This sets SourceBitsT to the top line */ + SourceBitsT = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + } + + /* Overlaps and Vertical flips do not mix well. So we test for this and handle it + * by using two operations. First we just do a copy of the source to the destination. + * Then we do a flip in place at the destination location and we are done. + */ + if ((BltInfo->SourcePoint.y != BltInfo->DestRect.top) && // The values are not equal and + (abs(BltInfo->SourcePoint.y - BltInfo->DestRect.top) < (DestHeight + 2)) && // they are NOT seperated by > DestHeight + (BltInfo->SourceSurface->pvScan0 == BltInfo->DestSurface->pvScan0)) // and same surface (probably screen) + { + DPRINT("Flips Need Adjustments, so do move here.\n"); + + if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { - *Dest32-- = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *Source32--); + /* SourceBits points to top-left pixel for lDelta < 0 and bottom-left for lDelta > 0 */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x; + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) + { + RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth); + SourceBits += BltInfo->SourceSurface->lDelta; + DestBits += BltInfo->DestSurface->lDelta; + } } + else + { + /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */ + SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + + ((BltInfo->SourcePoint.y + + DestHeight - 1) * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x; + /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */ + DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + + 4 * BltInfo->DestRect.left; + for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) + { + RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth); + SourceBits -= BltInfo->SourceSurface->lDelta; + DestBits -= BltInfo->DestSurface->lDelta; + } + } + + /* This sets SourceBitsB to the bottom line */ + SourceBitsB = DestBitsB; + + /* This sets SourceBitsT to the top line */ + SourceBitsT = DestBitsT; } - SourceBits -= BltInfo->SourceSurface->lDelta; - DestBits -= BltInfo->DestSurface->lDelta; + + /* Vertical Flip code starts here */ + for (j = 0; j < DestHeight / 2 ; j++) + { + /* Store bottom row of Source pixels */ + RtlMoveMemory(store, SourceBitsB, 4 * DestWidth); + + /* Copy top Source row to bottom Destination row overwriting it */ + RtlMoveMemory(DestBitsB, SourceBitsT, 4 * DestWidth); + + /* Copy stored bottom row of Source pixels to Destination top row of pixels */ + RtlMoveMemory(DestBitsT, store, 4 * DestWidth); + + /* Index top rows down and bottom rows up */ + SourceBitsT += BltInfo->SourceSurface->lDelta; + SourceBitsB -= BltInfo->SourceSurface->lDelta; + + DestBitsT += BltInfo->DestSurface->lDelta; + DestBitsB -= BltInfo->DestSurface->lDelta; + } + if (DestHeight % 2) + { + /* If we had an odd number of lines we handle the center one here */ + DPRINT("Handling Top To Bottom with Odd Number of lines.\n"); + RtlMoveMemory(DestBitsB, SourceBitsT, 4 * DestWidth); + } + ExFreePoolWithTag(store, TAG_DIB); } } } break; default: - DPRINT1("DIB_32BPP_Bitblt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat)); + DPRINT1("DIB_32BPP_BitBltSrcCopy: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat)); return FALSE; } @@ -352,7 +770,7 @@ DIB_32BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, register NICEPIXEL32 DstPixel, SrcPixel; UCHAR Alpha, SrcBpp; - DPRINT("DIB_32BPP_AlphaBlend: srcRect: (%d,%d)-(%d,%d), dstRect: (%d,%d)-(%d,%d)\n", + DPRINT("DIB_32BPP_AlphaBlend: SourceRect: (%d,%d)-(%d,%d), DestRect: (%d,%d)-(%d,%d)\n", SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); diff --git a/win32ss/gdi/dib/dib32bppc.c b/win32ss/gdi/dib/dib32bppc.c index fb1c0dc38d6..af2039545fc 100644 --- a/win32ss/gdi/dib/dib32bppc.c +++ b/win32ss/gdi/dib/dib32bppc.c @@ -32,6 +32,9 @@ DIB_32BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color) { ULONG DestY; + /* Make WellOrdered by making top < bottom and left < right */ + RECTL_vMakeWellOrdered(DestRect); + for (DestY = DestRect->top; DestY< DestRect->bottom; DestY++) { DIB_32BPP_HLine (DestSurface, DestRect->left, DestRect->right, DestY, color); diff --git a/win32ss/gdi/dib/dib4bpp.c b/win32ss/gdi/dib/dib4bpp.c index 56c03e50658..69daf319f6e 100644 --- a/win32ss/gdi/dib/dib4bpp.c +++ b/win32ss/gdi/dib/dib4bpp.c @@ -4,14 +4,17 @@ * FILE: win32ss/gdi/dib/dib4bpp.c * PURPOSE: Device Independant Bitmap functions, 4bpp * PROGRAMMERS: Jason Filby + * Doug Lyons */ - #include <win32k.h> #define NDEBUG #include <debug.h> +#define DEC_OR_INC(var, decTrue, amount) \ + ((var) = (decTrue) ? ((var) - (amount)) : ((var) + (amount))) + VOID DIB_4BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c) { @@ -63,6 +66,24 @@ DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo) PBYTE SourceBits_24BPP, SourceLine_24BPP; PBYTE DestBits, DestLine, SourceBits_8BPP, SourceLine_8BPP; PBYTE SourceBits, SourceLine; + BOOLEAN bTopToBottom, bLeftToRight; + + DPRINT("DIB_4BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n", + BltInfo->SourceSurface->sizlBitmap.cx, BltInfo->SourceSurface->sizlBitmap.cy, + BltInfo->DestSurface->sizlBitmap.cx, BltInfo->DestSurface->sizlBitmap.cy, + BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom); + + /* Get back left to right flip here */ + bLeftToRight = (BltInfo->DestRect.left > BltInfo->DestRect.right); + + /* Check for top to bottom flip needed. */ + bTopToBottom = BltInfo->DestRect.top > BltInfo->DestRect.bottom; + + /* Make WellOrdered with top < bottom and left < right */ + RECTL_vMakeWellOrdered(&BltInfo->DestRect); + + DPRINT("BPP is '%d/%d' & BltInfo->SourcePoint.x is '%d' & BltInfo->SourcePoint.y is '%d'.\n", + BltInfo->SourceSurface->iBitmapFormat, BltInfo->SourcePoint.x, BltInfo->SourcePoint.y); DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.left >> 1) + @@ -71,12 +92,30 @@ DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo) switch (BltInfo->SourceSurface->iBitmapFormat) { case BMF_1BPP: + DPRINT("1BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + sx = BltInfo->SourcePoint.x; + + /* This sets sy to the top line */ sy = BltInfo->SourcePoint.y; + if (bTopToBottom) + { + /* This sets sy to the bottom line */ + sy += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + /* This sets the sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { if(DIB_1BPP_GetPixel(BltInfo->SourceSurface, sx, sy) == 0) @@ -87,64 +126,129 @@ DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo) { DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 1)); } - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_4BPP: + DPRINT("4BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets sy to the top line */ sy = BltInfo->SourcePoint.y; + if (bTopToBottom) + { + /* This sets sy to the bottom line */ + sy += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) + * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + if (bLeftToRight) + { + /* This sets the sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { if (NULL != BltInfo->XlateSourceToDest) { - DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy))); + DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, + XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, + DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy))); } else { - DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy)); + DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, + DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy)); } - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_8BPP: - SourceBits_8BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; + DPRINT("8BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + SourceBits_8BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceBits to the bottom line */ + SourceBits_8BPP = (PBYTE)((LONG_PTR)SourceBits_8BPP + + ((BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * + BltInfo->SourceSurface->lDelta)); + } for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { SourceLine_8BPP = SourceBits_8BPP; DestLine = DestBits; + + if (bLeftToRight) + { + /* This sets SourceBits_8BPP to the rightmost pixel */ + SourceBits_8BPP += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + f2 = BltInfo->DestRect.left & 1; for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { *DestLine = (*DestLine & notmask[f2]) | (BYTE)((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *SourceLine_8BPP)) << ((4 * (1 - f2)))); - if(f2 == 1) { DestLine++; f2 = 0; } else { f2 = 1; } - SourceLine_8BPP++; + if (f2 == 1) { DestLine++; f2 = 0; } else { f2 = 1; } + DEC_OR_INC(SourceLine_8BPP, bLeftToRight, 1); } - - SourceBits_8BPP += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceBits_8BPP, bTopToBottom, BltInfo->SourceSurface->lDelta); DestBits += BltInfo->DestSurface->lDelta; } break; case BMF_16BPP: - SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x; + DPRINT("16BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + DPRINT("BMF_16BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 2 * BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * + BltInfo->SourceSurface->lDelta;; + } + DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { SourceBits = SourceLine; + + if (bLeftToRight) + { + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 2; + } + DestBits = DestLine; f2 = BltInfo->DestRect.left & 1; @@ -154,16 +258,32 @@ DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo) *DestBits = (*DestBits & notmask[f2]) | (BYTE)((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor)) << ((4 * (1 - f2)))); if(f2 == 1) { DestBits++; f2 = 0; } else { f2 = 1; } - SourceBits += 2; + + DEC_OR_INC(SourceBits, bLeftToRight, 2); } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_24BPP: - SourceBits_24BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x * 3; + + DPRINT("24BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + SourceBits_24BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + BltInfo->SourcePoint.x * 3; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceBits_24BPP += BltInfo->SourceSurface->lDelta * + (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { @@ -171,6 +291,12 @@ DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo) DestLine = DestBits; f2 = BltInfo->DestRect.left & 1; + if (bLeftToRight) + { + /* This sets the SourceBits_24BPP to the rightmost pixel */ + SourceLine_24BPP += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 3; + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { xColor = (*(SourceLine_24BPP + 2) << 0x10) + @@ -179,22 +305,40 @@ DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo) *DestLine = (*DestLine & notmask[f2]) | (BYTE)((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor)) << ((4 * (1 - f2)))); if(f2 == 1) { DestLine++; f2 = 0; } else { f2 = 1; } - SourceLine_24BPP+=3; + DEC_OR_INC(SourceLine_24BPP, bLeftToRight, 3); } - - SourceBits_24BPP += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceBits_24BPP, bTopToBottom, BltInfo->SourceSurface->lDelta); DestBits += BltInfo->DestSurface->lDelta; } break; case BMF_32BPP: - SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + DPRINT("32BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + + 4 * BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1; + } + DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { SourceBits = SourceLine; DestBits = DestLine; + + if (bLeftToRight) + { + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 4; + } + f2 = BltInfo->DestRect.left & 1; for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) @@ -203,16 +347,18 @@ DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo) *DestBits = (*DestBits & notmask[f2]) | (BYTE)((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor)) << ((4 * (1 - f2)))); if(f2 == 1) { DestBits++; f2 = 0; } else { f2 = 1; } - SourceBits += 4; + + DEC_OR_INC(SourceBits, bLeftToRight, 4); } - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; default: - DbgPrint("DIB_4BPP_Bitblt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat)); + DbgPrint("DIB_4BPP_BitBltSrcCopy: Unhandled Source BPP: %u\n", + BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat)); return FALSE; } return(TRUE); @@ -290,7 +436,8 @@ DIB_4BPP_BitBlt(PBLTINFO BltInfo) if (BltInfo->PatternSurface) { - Pattern = DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY); + Pattern = DIB_GetSourceIndex(BltInfo->PatternSurface, + (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY); } DIB_4BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF); @@ -339,7 +486,8 @@ DIB_4BPP_BitBlt(PBLTINFO BltInfo) } if (BltInfo->PatternSurface) { - Pattern = DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY); + Pattern = DIB_GetSourceIndex(BltInfo->PatternSurface, + (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY); } DIB_4BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF); } @@ -361,6 +509,9 @@ DIB_4BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color) { LONG DestY; + /* Make WellOrdered by making top < bottom and left < right */ + RECTL_vMakeWellOrdered(DestRect); + for (DestY = DestRect->top; DestY < DestRect->bottom; DestY++) { DIB_4BPP_HLine(DestSurface, DestRect->left, DestRect->right, DestY, color); diff --git a/win32ss/gdi/dib/dib8bpp.c b/win32ss/gdi/dib/dib8bpp.c index c30d738b67b..520037bf709 100644 --- a/win32ss/gdi/dib/dib8bpp.c +++ b/win32ss/gdi/dib/dib8bpp.c @@ -6,6 +6,7 @@ * PROGRAMMERS: Jason Filby * Thomas Bluemel * Gregor Anich + * Doug Lyons */ #include <win32k.h> @@ -13,6 +14,9 @@ #define NDEBUG #include <debug.h> +#define DEC_OR_INC(var, decTrue, amount) \ + ((var) = (decTrue) ? ((var) - (amount)) : ((var) + (amount))) + VOID DIB_8BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c) { @@ -57,18 +61,56 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) LONG i, j, sx, sy, xColor, f1; PBYTE SourceBits, DestBits, SourceLine, DestLine; PBYTE SourceBits_4BPP, SourceLine_4BPP; + BOOLEAN bTopToBottom, bLeftToRight; + + DPRINT("DIB_8BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n", + BltInfo->SourceSurface->sizlBitmap.cx, BltInfo->SourceSurface->sizlBitmap.cy, + BltInfo->DestSurface->sizlBitmap.cx, BltInfo->DestSurface->sizlBitmap.cy, + BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom); + + /* Get back left to right flip here */ + bLeftToRight = (BltInfo->DestRect.left > BltInfo->DestRect.right); + + /* Check for top to bottom flip needed. */ + bTopToBottom = BltInfo->DestRect.top > BltInfo->DestRect.bottom; + + DPRINT("bTopToBottom is '%d' and bLeftToRight is '%d'.\n", bTopToBottom, bLeftToRight); + + /* Make WellOrdered by making top < bottom and left < right */ + RECTL_vMakeWellOrdered(&BltInfo->DestRect); + + DPRINT("BPP is '%d' & BltInfo->SourcePoint.x is '%d' & BltInfo->SourcePoint.y is '%d'.\n", + BltInfo->SourceSurface->iBitmapFormat, BltInfo->SourcePoint.x, BltInfo->SourcePoint.y); DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left; switch(BltInfo->SourceSurface->iBitmapFormat) { case BMF_1BPP: + DPRINT("1BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + sx = BltInfo->SourcePoint.x; + + /* This sets sy to the top line */ sy = BltInfo->SourcePoint.y; + if (bTopToBottom) + { + /* This sets sy to the bottom line */ + sy += BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + /* This sets the sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) { if(DIB_1BPP_GetPixel(BltInfo->SourceSurface, sx, sy) == 0) @@ -79,19 +121,36 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) { DIB_8BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 1)); } - sx++; + DEC_OR_INC(sx, bLeftToRight, 1); } - sy++; + DEC_OR_INC(sy, bTopToBottom, 1); } break; case BMF_4BPP: + DPRINT("4BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + /* This sets SourceBits_4BPP to the top line */ SourceBits_4BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + (BltInfo->SourcePoint.x >> 1); + if (bTopToBottom) + { + /* This sets SourceBits_4BPP to the bottom line */ + SourceBits_4BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta; + } + for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++) { SourceLine_4BPP = SourceBits_4BPP; sx = BltInfo->SourcePoint.x; + + if (bLeftToRight) + { + /* This sets sx to the rightmost pixel */ + sx += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + } + f1 = sx & 1; for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++) @@ -99,19 +158,35 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) xColor = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, (*SourceLine_4BPP & altnotmask[f1]) >> (4 * (1 - f1))); DIB_8BPP_PutPixel(BltInfo->DestSurface, i, j, xColor); - if(f1 == 1) { SourceLine_4BPP++; f1 = 0; } else { f1 = 1; } - sx++; - } + if(f1 == 1) + { + DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1); + f1 = 0; + } + else + { + f1 = 1; + } - SourceBits_4BPP += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(sx, bLeftToRight, 1); + } + DEC_OR_INC(SourceBits_4BPP, bTopToBottom, BltInfo->SourceSurface->lDelta); } break; case BMF_8BPP: - if (NULL == BltInfo->XlateSourceToDest || 0 != (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL)) + DPRINT("8BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + + if ((BltInfo->XlateSourceToDest == NULL || + (BltInfo->XlateSourceToDest->flXlate & XO_TRIVIAL) != 0) && + (!bTopToBottom && !bLeftToRight)) { if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { + DPRINT("BltInfo->DestRect.top < BltInfo->SourcePoint.y.\n"); SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { @@ -122,6 +197,7 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) } else { + DPRINT("BltInfo->DestRect.top >= BltInfo->SourcePoint.y.\n"); SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left; for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) @@ -134,8 +210,14 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) } else { + DPRINT("XO_TRIVIAL is NOT TRUE or we have flips.\n"); + + if (!bTopToBottom && !bLeftToRight) + /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */ + { if (BltInfo->DestRect.top < BltInfo->SourcePoint.y) { + DPRINT("Dest.top < SourcePoint.y.\n"); SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) @@ -152,6 +234,7 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) } else { + DPRINT("Dest.top >= SourcePoint.y.\n"); SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x; DestLine = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left; for (j = BltInfo->DestRect.bottom - 1; BltInfo->DestRect.top <= j; j--) @@ -167,56 +250,244 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) } } } + else + { + /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */ + BOOL OneDone = FALSE; + + if (bLeftToRight) + { + DPRINT("Flip is bLeftToRight.\n"); + + /* Allocate enough pixels for a row in BYTE's */ + BYTE *store = ExAllocatePoolWithTag(NonPagedPool, + BltInfo->DestRect.right - BltInfo->DestRect.left + 1, TAG_DIB); + if (store == NULL) + { + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + WORD Index; + + /* This sets SourceLine to the top line */ + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + + (BltInfo->SourcePoint.y * + BltInfo->SourceSurface->lDelta) + + BltInfo->SourcePoint.x; + + /* This set the DestLine to the top line */ + DestLine = (PBYTE)BltInfo->DestSurface->pvScan0 + + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + + BltInfo->DestRect.left; + + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) + { + SourceBits = SourceLine; + DestBits = DestLine; + + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1); + + Index = 0; + + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + store[Index] = (BYTE)XLATEOBJ_iXlate( + BltInfo->XlateSourceToDest, + *SourceBits); + SourceBits--; + Index++; + } + + Index = 0; + + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + *DestBits = store[Index]; + DestBits++; + Index++; + } + + SourceLine += BltInfo->SourceSurface->lDelta; + DestLine += BltInfo->DestSurface->lDelta; + } + ExFreePoolWithTag(store, TAG_DIB); + OneDone = TRUE; + } + + if (bTopToBottom) + { + DPRINT("Flip is bTopToBottom.\n"); + + DWORD Index; + + /* Allocate enough pixels for a column in BYTE's */ + BYTE *store = ExAllocatePoolWithTag(NonPagedPool, + BltInfo->DestRect.bottom - BltInfo->DestRect.top + 1, TAG_DIB); + if (store == NULL) + { + DPRINT1("Storage Allocation Failed.\n"); + return FALSE; + } + + /* The OneDone flag indicates that we are flipping for bTopToBottom and bLeftToRight + * and have already completed the bLeftToRight. So we will lose our first flip output + * unless we work with its output which is at the destination site. So in this case + * our new Source becomes the previous outputs Destination. */ + + if (OneDone) + { + /* This sets SourceLine to the bottom line of our previous destination */ + SourceLine = (PBYTE)BltInfo->DestSurface->pvScan0 + + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left + + (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->DestSurface->lDelta; + } + else + { + /* This sets SourceLine to the bottom line */ + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) + * BltInfo->SourceSurface->lDelta) + + BltInfo->SourcePoint.x; + } + + /* This set the DestLine to the top line */ + DestLine = (PBYTE)BltInfo->DestSurface->pvScan0 + + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + + BltInfo->DestRect.left; + + /* Read columns */ + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) + { + + DestBits = DestLine; + SourceBits = SourceLine; + + Index = 0; + + /* Read up the column and store the pixels */ + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) + { + store[Index] = (BYTE)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *SourceBits); + /* Go up a line */ + SourceBits -= BltInfo->SourceSurface->lDelta; + Index++; + } + + Index = 0; + + /* Get the stored pixel and copy then down the column */ + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) + { + *DestBits = store[Index]; + /* Go down a line */ + DestBits += BltInfo->SourceSurface->lDelta; + Index++; + } + /* Index to next column */ + SourceLine += 1; + DestLine += 1; + } + ExFreePoolWithTag(store, TAG_DIB); + } + + } + } break; case BMF_16BPP: + DPRINT("16BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + + DPRINT("BMF_16BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;; + } DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { SourceBits = SourceLine; + + if (bLeftToRight) + { + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 2; + } DestBits = DestLine; for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = *((PWORD) SourceBits); *DestBits = (BYTE)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor); - SourceBits += 2; + + DEC_OR_INC(SourceBits, bLeftToRight, 2); DestBits += 1; } - - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_24BPP: + DPRINT("24BPP-dstRect: (%d,%d)-(%d,%d) and Width of '%d'.\n", + BltInfo->DestRect.left, BltInfo->DestRect.top, + BltInfo->DestRect.right, BltInfo->DestRect.bottom, + BltInfo->DestRect.right - BltInfo->DestRect.left); + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x; DestLine = DestBits; + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1); + } + for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) { SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets the SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 3; + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = (*(SourceBits + 2) << 0x10) + (*(SourceBits + 1) << 0x08) + (*(SourceBits)); *DestBits = (BYTE)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor); - SourceBits += 3; + DEC_OR_INC(SourceBits, bLeftToRight, 3); DestBits += 1; } - - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; case BMF_32BPP: + DPRINT("32BPP Case Selected with DestRect Width of '%d'.\n", + BltInfo->DestRect.right - BltInfo->DestRect.left); + SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x; + + if (bTopToBottom) + { + /* This sets SourceLine to the bottom line */ + SourceLine += BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1; + } DestLine = DestBits; for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++) @@ -224,15 +495,21 @@ DIB_8BPP_BitBltSrcCopy(PBLTINFO BltInfo) SourceBits = SourceLine; DestBits = DestLine; + if (bLeftToRight) + { + /* This sets SourceBits to the rightmost pixel */ + SourceBits += (BltInfo->DestRect.right - BltInfo->DestRect.left - 1) * 4; + } + for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++) { xColor = *((PDWORD) SourceBits); *DestBits = (BYTE)XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor); - SourceBits += 4; + + DEC_OR_INC(SourceBits, bLeftToRight, 4); DestBits += 1; } - - SourceLine += BltInfo->SourceSurface->lDelta; + DEC_OR_INC(SourceLine, bTopToBottom, BltInfo->SourceSurface->lDelta); DestLine += BltInfo->DestSurface->lDelta; } break; @@ -250,6 +527,10 @@ BOOLEAN DIB_8BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color) { LONG DestY; + + /* Make WellOrdered by making top < bottom and left < right */ + RECTL_vMakeWellOrdered(DestRect); + for (DestY = DestRect->top; DestY< DestRect->bottom; DestY++) { DIB_8BPP_HLine(DestSurface, DestRect->left, DestRect->right, DestY, color); diff --git a/win32ss/gdi/dib/stretchblt.c b/win32ss/gdi/dib/stretchblt.c index c768cf8e34c..718d8183f7a 100644 --- a/win32ss/gdi/dib/stretchblt.c +++ b/win32ss/gdi/dib/stretchblt.c @@ -6,6 +6,7 @@ * PROGRAMMERS: Magnus Olsen * Evgeniy Boltik * Gregor Schneider + * Doug Lyons */ #include <win32k.h> @@ -47,25 +48,46 @@ BOOLEAN DIB_XXBPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, SURFOBJ *Ma BOOL UsesSource = ROP4_USES_SOURCE(ROP); BOOL UsesPattern = ROP4_USES_PATTERN(ROP); + BOOLEAN bTopToBottom, bLeftToRight; ASSERT(IS_VALID_ROP4(ROP)); fnDest_GetPixel = DibFunctionsForBitmapFormat[DestSurf->iBitmapFormat].DIB_GetPixel; fnDest_PutPixel = DibFunctionsForBitmapFormat[DestSurf->iBitmapFormat].DIB_PutPixel; - DPRINT("Dest BPP: %u, dstRect: (%d,%d)-(%d,%d)\n", + DPRINT("Dest BPP: %u, DestRect: (%d,%d)-(%d,%d)\n", BitsPerFormat(DestSurf->iBitmapFormat), DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + DstHeight = DestRect->bottom - DestRect->top; + DstWidth = DestRect->right - DestRect->left; + SrcHeight = SourceRect->bottom - SourceRect->top; + SrcWidth = SourceRect->right - SourceRect->left; + + /* Here we do the tests and set our conditions */ + if (((SrcWidth < 0) && (DstWidth < 0)) || ((SrcWidth >= 0) && (DstWidth >= 0))) + bLeftToRight = FALSE; + else + bLeftToRight = TRUE; + + if (((SrcHeight < 0) && (DstHeight < 0)) || ((SrcHeight >= 0) && (DstHeight >= 0))) + bTopToBottom = FALSE; + else + bTopToBottom = TRUE; + + /* Make Well Ordered to start */ + RECTL_vMakeWellOrdered(DestRect); + if (UsesSource) { SourceCy = SourceSurf->sizlBitmap.cy; fnSource_GetPixel = DibFunctionsForBitmapFormat[SourceSurf->iBitmapFormat].DIB_GetPixel; - DPRINT("Source BPP: %u, srcRect: (%d,%d)-(%d,%d)\n", + DPRINT("Source BPP: %u, SourceRect: (%d,%d)-(%d,%d)\n", BitsPerFormat(SourceSurf->iBitmapFormat), SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom); } if (MaskSurf) { + DPRINT("MaskSurf is not NULL.\n"); fnMask_GetPixel = DibFunctionsForBitmapFormat[MaskSurf->iBitmapFormat].DIB_GetPixel; MaskCy = MaskSurf->sizlBitmap.cy; } @@ -87,9 +109,11 @@ BOOLEAN DIB_XXBPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, SURFOBJ *Ma default: xxBPPMask = 0xFFFFFFFF; } + DPRINT("xxBPPMask is 0x%x.\n", xxBPPMask); if (UsesPattern) { + DPRINT("UsesPattern is not NULL.\n"); if (PatternSurface) { PatternY = (DestRect->top - BrushOrigin->y) % PatternSurface->sizlBitmap.cy; @@ -106,6 +130,12 @@ BOOLEAN DIB_XXBPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, SURFOBJ *Ma } } + if (PatternSurface) + { + DPRINT("PatternSurface is not NULL.\n"); + } + + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); for (DesY = DestRect->top; DesY < DestRect->bottom; DesY++) { @@ -118,7 +148,16 @@ BOOLEAN DIB_XXBPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, SURFOBJ *Ma } } if (UsesSource) - sy = SourceRect->top+(DesY - DestRect->top) * SrcHeight / DstHeight; + { + if (bTopToBottom) + { + sy = SourceRect->bottom-(DesY - DestRect->top) * SrcHeight / DstHeight; // flips about the x-axis + } + else + { + sy = SourceRect->top+(DesY - DestRect->top) * SrcHeight / DstHeight; + } + } for (DesX = DestRect->left; DesX < DestRect->right; DesX++) { @@ -126,7 +165,14 @@ BOOLEAN DIB_XXBPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, SURFOBJ *Ma if (fnMask_GetPixel) { - sx = SourceRect->left+(DesX - DestRect->left) * SrcWidth / DstWidth; + if (bLeftToRight) + { + sx = SourceRect->right - (DesX - DestRect->left) * SrcWidth / DstWidth; // flips about the y-axis + } + else + { + sx = SourceRect->left+(DesX - DestRect->left) * SrcWidth / DstWidth; + } if (sx < 0 || sy < 0 || MaskSurf->sizlBitmap.cx < sx || MaskCy < sy || fnMask_GetPixel(MaskSurf, sx, sy) != 0) @@ -137,7 +183,14 @@ BOOLEAN DIB_XXBPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, SURFOBJ *Ma if (UsesSource && CanDraw) { - sx = SourceRect->left+(DesX - DestRect->left) * SrcWidth / DstWidth; + if (bLeftToRight) + { + sx = SourceRect->right-(DesX - DestRect->left) * SrcWidth / DstWidth; // flips about the y-axis + } + else + { + sx = SourceRect->left + (DesX - DestRect->left) * SrcWidth / DstWidth; + } if (sx >= 0 && sy >= 0 && SourceSurf->sizlBitmap.cx > sx && SourceCy > sy) { diff --git a/win32ss/gdi/eng/bitblt.c b/win32ss/gdi/eng/bitblt.c index 8eea77535bb..59641cd6235 100644 --- a/win32ss/gdi/eng/bitblt.c +++ b/win32ss/gdi/eng/bitblt.c @@ -3,8 +3,13 @@ * PROJECT: ReactOS Win32k subsystem * PURPOSE: GDI BitBlt Functions * FILE: win32ss/gdi/eng/bitblt.c - * PROGRAMER: Jason Filby + * PROGRAMERS: Jason Filby * Timo Kreuzer + * Doug Lyons + * + * WARNING: Modify this file with extreme caution. It is very sensitive to timing changes. + * Adding code can cause the system to show a Fatal Exception Error and fail to boot!. + * This is especially true in CallDibBitBlt, IntEngBitBlt and EngBitBlt (even DPRINT's). */ #include <win32k.h> @@ -255,6 +260,12 @@ CallDibBitBlt(SURFOBJ* OutputObj, psoPattern = NULL; } + /* Make WellOrdered with top < bottom and left < right */ + RECTL_vMakeWellOrdered(&BltInfo.DestRect); + + DPRINT("CallDibBitBlt: BltInfo.DestRect: (%d,%d)-(%d,%d)\n", + BltInfo.DestRect.left, BltInfo.DestRect.top, BltInfo.DestRect.right, BltInfo.DestRect.bottom); + Result = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBlt(&BltInfo); return Result; @@ -344,10 +355,30 @@ EngBitBlt( ULONG Direction; BOOL UsesSource, UsesMask; POINTL AdjustedBrushOrigin; + LONG lTmp; + BOOLEAN bTopToBottom, bLeftToRight; UsesSource = ROP4_USES_SOURCE(rop4); UsesMask = ROP4_USES_MASK(rop4); + if (prclTrg->left > prclTrg->right) + { + bLeftToRight = TRUE; + } + else + { + bLeftToRight = FALSE; + } + + if (prclTrg->top > prclTrg->bottom) + { + bTopToBottom = TRUE; + } + else + { + bTopToBottom = FALSE; + } + if (rop4 == ROP4_NOOP) { /* Copy destination onto itself: nop */ @@ -359,6 +390,12 @@ EngBitBlt( OutputRect = *prclTrg; RECTL_vMakeWellOrdered(&OutputRect); + DPRINT("EngBitBlt: prclTrg: (%d,%d)-(%d,%d)\n", + prclTrg->left, prclTrg->top, prclTrg->right, prclTrg->bottom); + + DPRINT("EngBitBlt: OutputRect: (%d,%d)-(%d,%d)\n", + OutputRect.left, OutputRect.top, OutputRect.right, OutputRect.bottom); + if (UsesSource) { if (!psoSrc || !pptlSrc) @@ -498,6 +535,21 @@ EngBitBlt( switch (clippingType) { case DC_TRIVIAL: + /* Fix up OutputRect here */ + if (bLeftToRight) + { + lTmp = OutputRect.left; + OutputRect.left = OutputRect.right; + OutputRect.right = lTmp; + } + + if (bTopToBottom) + { + lTmp = OutputRect.top; + OutputRect.top = OutputRect.bottom; + OutputRect.bottom = lTmp; + } + Ret = (*BltRectFunc)(OutputObj, InputObj, psoMask, @@ -622,6 +674,8 @@ IntEngBitBlt( RECTL rclSrcClipped; POINTL ptlBrush; PFN_DrvBitBlt pfnBitBlt; + LONG lTmp; + BOOLEAN bTopToBottom, bLeftToRight; /* Sanity checks */ ASSERT(IS_VALID_ROP4(Rop4)); @@ -629,6 +683,9 @@ IntEngBitBlt( psurfTrg = CONTAINING_RECORD(psoTrg, SURFACE, SurfObj); + bLeftToRight = prclTrg->left > prclTrg->right; + bTopToBottom = prclTrg->top > prclTrg->bottom; + /* Get the target rect and make it well ordered */ rclClipped = *prclTrg; RECTL_vMakeWellOrdered(&rclClipped); @@ -721,6 +778,24 @@ IntEngBitBlt( pfnBitBlt = EngBitBlt; } + /* rclClipped needs to be modified in accordance with flips here */ + if (bLeftToRight) + { + lTmp = rclClipped.left; + rclClipped.left = rclClipped.right; + rclClipped.right = lTmp; + } + + if (bTopToBottom) + { + lTmp = rclClipped.top; + rclClipped.top = rclClipped.bottom; + rclClipped.bottom = lTmp; + } + + DPRINT("About to call EngBitBlt: rclClipped: (%d,%d)-(%d,%d)\n", + rclClipped.left, rclClipped.top, rclClipped.right, rclClipped.bottom); + bResult = pfnBitBlt(psoTrg, psoSrc, psoMask, diff --git a/win32ss/gdi/eng/copybits.c b/win32ss/gdi/eng/copybits.c index 0b8824392db..92539da148e 100644 --- a/win32ss/gdi/eng/copybits.c +++ b/win32ss/gdi/eng/copybits.c @@ -3,7 +3,8 @@ * PROJECT: ReactOS kernel * PURPOSE: GDI EngCopyBits Function * FILE: win32ss/gdi/eng/copybits.c - * PROGRAMER: Jason Filby + * PROGRAMERS: Jason Filby + * Doug Lyons */ #include <win32k.h> @@ -32,6 +33,30 @@ EngCopyBits( SURFACE *psurfSource; RECTL rclDest = *DestRect; POINTL ptlSrc = *SourcePoint; + LONG lTmp; + BOOL bTopToBottom; + + DPRINT("Entering EngCopyBits with SourcePoint (%d,%d) and DestRect (%d,%d)-(%d,%d).\n", + SourcePoint->x, SourcePoint->y, DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + + DPRINT("psoSource cx/cy is %d/%d and psoDest cx/cy is %d/%d.\n", + psoSource->sizlBitmap.cx, psoSource->sizlBitmap.cy, psoDest->sizlBitmap.cx, psoDest->sizlBitmap.cy); + + /* Retrieve Top Down/flip here and then make Well-Ordered again */ + if (DestRect->top > DestRect->bottom) + { + bTopToBottom = TRUE; + lTmp = DestRect->top; + DestRect->top = DestRect->bottom; + DestRect->bottom = lTmp; + rclDest = *DestRect; + } + else + { + bTopToBottom = FALSE; + } + + DPRINT("bTopToBottom is '%d'.\n", bTopToBottom); ASSERT(psoDest != NULL && psoSource != NULL && DestRect != NULL && SourcePoint != NULL); @@ -113,24 +138,42 @@ EngCopyBits( switch (clippingType) { case DC_TRIVIAL: + DPRINT("DC_TRIVIAL.\n"); BltInfo.DestRect = *DestRect; BltInfo.SourcePoint = *SourcePoint; + /* Now we set the Dest Rect top and bottom based on Top Down/flip */ + if (bTopToBottom) + { + lTmp = BltInfo.DestRect.top; + BltInfo.DestRect.top = BltInfo.DestRect.bottom; + BltInfo.DestRect.bottom = lTmp; + } + ret = DibFunctionsForBitmapFormat[psoDest->iBitmapFormat].DIB_BitBltSrcCopy(&BltInfo); break; case DC_RECT: + DPRINT("DC_RECT.\n"); // Clip the blt to the clip rectangle RECTL_bIntersectRect(&BltInfo.DestRect, DestRect, &Clip->rclBounds); BltInfo.SourcePoint.x = SourcePoint->x + BltInfo.DestRect.left - DestRect->left; BltInfo.SourcePoint.y = SourcePoint->y + BltInfo.DestRect.top - DestRect->top; + /* Now we set the Dest Rect top and bottom based on Top Down/flip */ + if (bTopToBottom) + { + lTmp = BltInfo.DestRect.top; + BltInfo.DestRect.top = BltInfo.DestRect.bottom; + BltInfo.DestRect.bottom = lTmp; + } + ret = DibFunctionsForBitmapFormat[psoDest->iBitmapFormat].DIB_BitBltSrcCopy(&BltInfo); break; case DC_COMPLEX: - + DPRINT("DC_COMPLEX.\n"); CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_ANY, 0); do @@ -149,6 +192,14 @@ EngCopyBits( BltInfo.SourcePoint.x = SourcePoint->x + BltInfo.DestRect.left - DestRect->left; BltInfo.SourcePoint.y = SourcePoint->y + BltInfo.DestRect.top - DestRect->top; + /* Now we set the Dest Rect top and bottom based on Top Down/flip */ + if (bTopToBottom) + { + lTmp = BltInfo.DestRect.top; + BltInfo.DestRect.top = BltInfo.DestRect.bottom; + BltInfo.DestRect.bottom = lTmp; + } + if (!DibFunctionsForBitmapFormat[psoDest->iBitmapFormat].DIB_BitBltSrcCopy(&BltInfo)) { ret = FALSE; diff --git a/win32ss/gdi/eng/stretchblt.c b/win32ss/gdi/eng/stretchblt.c index 2fb1a9afd2b..3b290e29a8a 100644 --- a/win32ss/gdi/eng/stretchblt.c +++ b/win32ss/gdi/eng/stretchblt.c @@ -3,7 +3,8 @@ * PROJECT: ReactOS Win32k subsystem * PURPOSE: GDI stretch blt functions * FILE: win32ss/gdi/eng/stretchblt.c - * PROGRAMER: Jason Filby + * PROGRAMERS: Jason Filby + * Doug Lyons */ #include <win32k.h> @@ -11,6 +12,21 @@ #define NDEBUG #include <debug.h> +/*************************************************************************************************************************** + We want to receive and send the flip state along to existing functions without changing their parameter lists. + So a way that we can do this is to use the DestRect to carry this information along with it. + Since there are four values, we can use their relative positions (coordinates) to indicate the four flip conditions. + if delta-x == 0 then there can be no Left-to-Right flip. If delta-y == 0 there can be no Top-to-Bottom flip. + So we can set the four flip conditions based on BOOLEAN flags as follows: + + We will use internal bits bTopToBottom and bLeftToRight as follows: + + !bTopToBottom && !bLeftToRight means no flips therefore left < right and top < bottom (normal well-formed rectangle) + bTopToBottom means there is a Top-To-Bottom flip therefore left < right and top > bottom + bLeftToRight means there is a Left-To-Right flip therefore left > right and top < bottom + bLeftToRight && bTopToBottom means both flips therefore left > right and top > bottom +****************************************************************************************************************************/ + typedef BOOLEAN (APIENTRY *PSTRETCHRECTFUNC)(SURFOBJ* OutputObj, SURFOBJ* InputObj, SURFOBJ* Mask, @@ -38,6 +54,11 @@ CallDibStretchBlt(SURFOBJ* psoDest, SURFOBJ* psoPattern; BOOL bResult; + DPRINT("Entering CallDibStretchBlt: psoSource cx/cy (%d/%d), psoDest cx/cy (%d/%d) OutputRect: (%d,%d)-(%d,%d)\n", + psoSource->sizlBitmap.cx, psoSource->sizlBitmap.cy, + psoDest->sizlBitmap.cx, psoDest->sizlBitmap.cy, + OutputRect->left, OutputRect->top, OutputRect->right, OutputRect->bottom); + if (BrushOrigin == NULL) { RealBrushOrigin.x = RealBrushOrigin.y = 0; @@ -115,6 +136,35 @@ EngStretchBltROP( LONG SrcHeight; LONG SrcWidth; + LONG cxSrc, cySrc, cxDest, cyDest; + BOOLEAN bLeftToRight, bTopToBottom; + LONG lTmp; + + DPRINT("Entering EngStretchBltROP: prclSrc: (%d/%d)-(%d/%d) prclDest: (%d,%d)-(%d,%d)\n", + prclSrc->left, prclSrc->top, prclSrc->right, prclSrc->bottom, + prclDest->left, prclDest->top, prclDest->right, prclDest->bottom); + + cxSrc = prclSrc->right - prclSrc->left; + cySrc = prclSrc->bottom - prclSrc->top; + cxDest = prclDest->right - prclDest->left; + cyDest = prclDest->bottom - prclDest->top; + + /* Here we do the tests and set our conditions */ + if (((cxSrc < 0) && (cxDest < 0)) || ((cxSrc >= 0) && (cxDest >= 0))) + bLeftToRight = FALSE; + else + bLeftToRight = TRUE; + + if (((cySrc < 0) && (cyDest < 0)) || ((cySrc >= 0) && (cyDest >= 0))) + bTopToBottom = FALSE; + else + bTopToBottom = TRUE; + + /* Make Well Ordered to start */ + OutputRect = *prclDest; + RECTL_vMakeWellOrdered(&OutputRect); + *prclDest = OutputRect; + if (Rop4 == ROP4_NOOP) { /* Copy destination onto itself: nop */ @@ -237,9 +287,29 @@ EngStretchBltROP( DstWidth = OutputRect.right - OutputRect.left; SrcHeight = InputRect.bottom - InputRect.top; SrcWidth = InputRect.right - InputRect.left; + + DPRINT("bLeftToRight is '%d' and bTopToBottom is '%d'.\n", bLeftToRight, bTopToBottom); + switch (clippingType) { case DC_TRIVIAL: + if (bLeftToRight) + { + lTmp = OutputRect.left; + OutputRect.left = OutputRect.right; + OutputRect.right = lTmp; + } + + if (bTopToBottom) + { + lTmp = OutputRect.top; + OutputRect.top = OutputRect.bottom; + OutputRect.bottom = lTmp; + } + + DPRINT("About to call CallDibStretchBlt: OutputRect: (%d,%d)-(%d,%d)\n", + OutputRect.left, OutputRect.top, OutputRect.right, OutputRect.bottom); + Ret = (*BltRectFunc)(psoOutput, psoInput, Mask, ColorTranslation, &OutputRect, &InputRect, MaskOrigin, pbo, &AdjustedBrushOrigin, Rop4); @@ -256,6 +326,24 @@ EngStretchBltROP( InputToCombinedRect.bottom = InputRect.top + (CombinedRect.bottom - OutputRect.top) * SrcHeight / DstHeight; InputToCombinedRect.left = InputRect.left + (CombinedRect.left - OutputRect.left) * SrcWidth / DstWidth; InputToCombinedRect.right = InputRect.left + (CombinedRect.right - OutputRect.left) * SrcWidth / DstWidth; + + if (bLeftToRight) + { + lTmp = CombinedRect.left; + CombinedRect.left = CombinedRect.right; + CombinedRect.right = lTmp; + } + + if (bTopToBottom) + { + lTmp = CombinedRect.top; + CombinedRect.top = CombinedRect.bottom; + CombinedRect.bottom = lTmp; + } + + DPRINT("About to call CallDibStretchBlt: CombinedRect: (%d,%d)-(%d,%d)\n", + CombinedRect.left, CombinedRect.top, CombinedRect.right, CombinedRect.bottom); + Ret = (*BltRectFunc)(psoOutput, psoInput, Mask, ColorTranslation, &CombinedRect, @@ -301,6 +389,24 @@ EngStretchBltROP( InputToCombinedRect.bottom = InputRect.top + (CombinedRect.bottom - OutputRect.top) * SrcHeight / DstHeight; InputToCombinedRect.left = InputRect.left + (CombinedRect.left - OutputRect.left) * SrcWidth / DstWidth; InputToCombinedRect.right = InputRect.left + (CombinedRect.right - OutputRect.left) * SrcWidth / DstWidth; + + if (bLeftToRight) + { + lTmp = CombinedRect.left; + CombinedRect.left = CombinedRect.right; + CombinedRect.right = lTmp; + } + + if (bTopToBottom) + { + lTmp = CombinedRect.top; + CombinedRect.top = CombinedRect.bottom; + CombinedRect.bottom = lTmp; + } + + DPRINT("About to call CallDibStretchBlt: CombinedRect: (%d,%d)-(%d,%d)\n", + CombinedRect.left, CombinedRect.top, CombinedRect.right, CombinedRect.bottom); + Ret = (*BltRectFunc)(psoOutput, psoInput, Mask, ColorTranslation, &CombinedRect, @@ -382,6 +488,18 @@ IntEngStretchBlt(SURFOBJ *psoDest, RECTL OutputRect; BOOL UsesSource = ROP4_USES_SOURCE(Rop4); LONG InputClWidth, InputClHeight, InputWidth, InputHeight; + LONG lTmp, cxSrc, cySrc, cxDest, cyDest; + BOOLEAN bTopToBottom, bLeftToRight; + INT Case0000, Case0001, Case0010, Case0011; + INT Case0100, Case0101, Case0110, Case0111; + INT Case1000, Case1001, Case1010, Case1011; + INT Case1100, Case1101, Case1110; + + DPRINT("Source cx/cy (%d/%d) and Destination cx/cy (%d/%d).\n", + psoSource->sizlBitmap.cx, psoSource->sizlBitmap.cy, psoDest->sizlBitmap.cx, psoDest->sizlBitmap.cy); + + DPRINT("Source lDelta is '%d' and Destination lDelta is '%d'.\n", + psoSource->lDelta, psoDest->lDelta); ASSERT(psoDest); //ASSERT(psoSource); // FIXME! @@ -390,17 +508,113 @@ IntEngStretchBlt(SURFOBJ *psoDest, //ASSERT(!RECTL_bIsEmptyRect(SourceRect)); // FIXME! /* If no clip object is given, use trivial one */ - if (!ClipRegion) ClipRegion = (CLIPOBJ *)&gxcoTrivial; + if (!ClipRegion) + { + DPRINT("Using trivial clip region.\n"); + ClipRegion = (CLIPOBJ *)&gxcoTrivial; + } + else + { + DPRINT("ClipRegion->rclBounds is (%d,%d)-(%d,%d).\n", + ClipRegion->rclBounds.left, ClipRegion->rclBounds.top, + ClipRegion->rclBounds.right, ClipRegion->rclBounds.bottom); + } psurfDest = CONTAINING_RECORD(psoDest, SURFACE, SurfObj); /* Sanity check */ ASSERT(IS_VALID_ROP4(Rop4)); + cxSrc = SourceRect->right - SourceRect->left; + cySrc = SourceRect->bottom - SourceRect->top; + cxDest = DestRect->right - DestRect->left; + cyDest = DestRect->bottom - DestRect->top; + + Case1110 = ((cxDest > 0) && (cyDest > 0) && (cxSrc > 0) && (cySrc < 0)); + Case1101 = ((cxDest > 0) && (cyDest > 0) && (cxSrc < 0) && (cySrc > 0)); + Case1100 = ((cxDest > 0) && (cyDest > 0) && (cxSrc < 0) && (cySrc < 0)); + Case1011 = ((cxDest > 0) && (cyDest < 0) && (cxSrc > 0) && (cySrc > 0)); + Case1010 = ((cxDest > 0) && (cyDest < 0) && (cxSrc > 0) && (cySrc < 0)); + Case1001 = ((cxDest > 0) && (cyDest < 0) && (cxSrc < 0) && (cySrc > 0)); + Case1000 = ((cxDest > 0) && (cyDest < 0) && (cxSrc < 0) && (cySrc < 0)); + Case0111 = ((cxDest < 0) && (cyDest > 0) && (cxSrc > 0) && (cySrc > 0)); + Case0110 = ((cxDest < 0) && (cyDest > 0) && (cxSrc > 0) && (cySrc < 0)); + Case0101 = ((cxDest < 0) && (cyDest > 0) && (cxSrc < 0) && (cySrc > 0)); + Case0100 = ((cxDest < 0) && (cyDest > 0) && (cxSrc < 0) && (cySrc < 0)); + Case0011 = ((cxDest < 0) && (cyDest < 0) && (cxSrc > 0) && (cySrc > 0)); + Case0010 = ((cxDest < 0) && (cyDest < 0) && (cxSrc > 0) && (cySrc < 0)); + Case0001 = ((cxDest < 0) && (cyDest < 0) && (cxSrc < 0) && (cySrc > 0)); + Case0000 = ((cxDest < 0) && (cyDest < 0) && (cxSrc < 0) && (cySrc < 0)); + + /* Make DestRect & OutputRect Well Ordered to start */ + RECTL_vMakeWellOrdered(DestRect); + OutputRect = *DestRect; + + /* Here we do the tests and set our conditions */ + if (((cxSrc < 0) && (cxDest < 0)) || ((cxSrc >= 0) && (cxDest >= 0))) + bLeftToRight = FALSE; + else + bLeftToRight = TRUE; + + if (((cySrc < 0) && (cyDest < 0)) || ((cySrc >= 0) && (cyDest >= 0))) + bTopToBottom = FALSE; + else + bTopToBottom = TRUE; + + DPRINT("bTopToBottom is '%d' and bLeftToRight is '%d'.\n", bTopToBottom, bLeftToRight); + /* Check if source and dest size are equal */ - if (((DestRect->right - DestRect->left) == (SourceRect->right - SourceRect->left)) && - ((DestRect->bottom - DestRect->top) == (SourceRect->bottom - SourceRect->top))) + if ((abs(DestRect->right - DestRect->left) == abs(SourceRect->right - SourceRect->left)) && + (abs(DestRect->bottom - DestRect->top) == abs(SourceRect->bottom - SourceRect->top))) { + DPRINT("source and dest size are equal.\n"); + + DPRINT("IntEngStretchBlt: dstRect: (%d,%d)-(%d,%d)\n", + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + + if (Case0000 || Case0001 || Case0010 || Case0011) // Destinations X & Y are both negative + { + lTmp = SourceRect->left; + SourceRect->left = SourceRect->right; + SourceRect->right = lTmp; + + lTmp = SourceRect->top; + SourceRect->top = SourceRect->bottom; + SourceRect->bottom = lTmp; + } + + if (Case0100 || Case0101 || Case0110 || Case0111) // Destination X is negative and Y is positive + { + lTmp = SourceRect->left; + SourceRect->left = SourceRect->right; + SourceRect->right = lTmp; + } + + if (Case1000 || Case1001 || Case1010 || Case1011) // Destination X is positive and Y is negative + { + lTmp = SourceRect->top; + SourceRect->top = SourceRect->bottom; + SourceRect->bottom = lTmp; + } + + if (bLeftToRight) + { + lTmp = DestRect->left; + DestRect->left = DestRect->right; + DestRect->right = lTmp; + } + + if (bTopToBottom) + { + lTmp = DestRect->top; + DestRect->top = DestRect->bottom; + DestRect->bottom = lTmp; + } + + DPRINT("Calling IntEngBitBlt: SourceRect (%d,%d)-(%d,%d) DestRect: (%d,%d)-(%d,%d)\n", + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + /* Pass the request to IntEngBitBlt */ return IntEngBitBlt(psoDest, psoSource, @@ -415,6 +629,90 @@ IntEngStretchBlt(SURFOBJ *psoDest, Rop4); } + DPRINT("source and dest size are NOT equal.\n"); + + DPRINT("SourceRect: (%d,%d)-(%d,%d) and DestRect: (%d,%d)-(%d,%d)\n", + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + + /* if cxSrc < 0 then we change the signs for both cxSrc and cxDest and + * we reverse their coordinates, because these outcomes are the same. + */ + if (cxSrc < 0) + { + lTmp = SourceRect->left; + SourceRect->left = SourceRect->right; + SourceRect->right = lTmp; + lTmp = DestRect->left; + DestRect->left = DestRect->right; + DestRect->right = lTmp; + cxSrc = -cxSrc; + cxDest = -cxDest; + } + /* if cySrc < 0 then we change the signs for both cySrc and cyDest and + * we reverse their coordinates, because these outcomes are the same. + */ + if (cySrc < 0) + { + lTmp = DestRect->top; + DestRect->top = DestRect->bottom; + DestRect->bottom = lTmp; + lTmp = SourceRect->top; + SourceRect->top = SourceRect->bottom; + SourceRect->bottom = lTmp; + cySrc = -cySrc; + cyDest = -cyDest; + } + + if (Case0010 || Case0111) // Horizontal Flips + { + DestRect->left--; + } + + if (Case0010 || Case0111 || Case1000 || Case1101) // Horizontal Flips + { + SourceRect->left--; + SourceRect->right--; + } + + if (Case0001 || Case0100 || Case1011 || Case1110) // Vertical Flips + { + SourceRect->top--; + SourceRect->bottom--; + } + + if (Case0011 || Case0110 || Case1001 || Case1100) // Horizontal and Vertical Flips + { + SourceRect->left--; + SourceRect->right--; + + SourceRect->top--; + SourceRect->bottom--; + } + + if (Case0000 || Case1010) // No Flip - Just Copy + { + SourceRect->top++; + SourceRect->bottom++; + + DestRect->top++; + DestRect->bottom++; + } + + if (Case0000 || Case0101) // No Flip - Just Copy + { + SourceRect->left++; + SourceRect->right++; + + DestRect->left++; + DestRect->right++; + + } + + DPRINT("SourceRect: (%d,%d)-(%d,%d) and DestRect: (%d,%d)-(%d,%d)\n", + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + InputClippedRect = *DestRect; if (InputClippedRect.right < InputClippedRect.left) { @@ -429,6 +727,7 @@ IntEngStretchBlt(SURFOBJ *psoDest, if (NULL == psoSource) { + DPRINT("Returning FALSE.\n"); return FALSE; } InputRect = *SourceRect; @@ -436,17 +735,28 @@ IntEngStretchBlt(SURFOBJ *psoDest, if (InputRect.right < InputRect.left || InputRect.bottom < InputRect.top) { + DPRINT("Returning TRUE.\n"); /* Everything clipped away, nothing to do */ return TRUE; } + DPRINT("InputRect: (%d,%d)-(%d,%d) and InputClippedRect: (%d,%d)-(%d,%d)\n", + InputRect.left, InputRect.top, InputRect.right, InputRect.bottom, + InputClippedRect.left, InputClippedRect.top, InputClippedRect.right, InputClippedRect.bottom); + if (ClipRegion->iDComplexity != DC_TRIVIAL) { if (!RECTL_bIntersectRect(&OutputRect, &InputClippedRect, &ClipRegion->rclBounds)) { + DPRINT("Returning TRUE.\n"); return TRUE; } + + DPRINT("InputClippedRect: (%d,%d)-(%d,%d) and OutputRect: (%d,%d)-(%d,%d)\n", + InputClippedRect.left, InputClippedRect.top, InputClippedRect.right, InputClippedRect.bottom, + OutputRect.left, OutputRect.top, OutputRect.right, OutputRect.bottom); + /* Update source rect */ InputClWidth = InputClippedRect.right - InputClippedRect.left; InputClHeight = InputClippedRect.bottom - InputClippedRect.top; @@ -460,9 +770,15 @@ IntEngStretchBlt(SURFOBJ *psoDest, } else { + DPRINT("Complexity = DC_TRIVIAL.\n"); OutputRect = InputClippedRect; } + + DPRINT("InputRect: (%d,%d)-(%d,%d) and OutputRect: (%d,%d)-(%d,%d)\n", + InputRect.left, InputRect.top, InputRect.right, InputRect.bottom, + OutputRect.left, OutputRect.top, OutputRect.right, OutputRect.bottom); + if (pMaskOrigin != NULL) { MaskOrigin.x = pMaskOrigin->x; @@ -480,6 +796,7 @@ IntEngStretchBlt(SURFOBJ *psoDest, /* Call the driver's DrvStretchBlt if available */ if (psurfDest->flags & HOOK_STRETCHBLTROP) { + DPRINT("About to call GDIDEVFUNCS(psoDest).StretchBltROP.\n"); /* Drv->StretchBltROP (look at http://www.osronline.com/ddkx/graphics/ddifncs_0z3b.htm ) */ ret = GDIDEVFUNCS(psoDest).StretchBltROP(psoDest, psoSource, @@ -498,6 +815,25 @@ IntEngStretchBlt(SURFOBJ *psoDest, if (! ret) { + /* set OutputRect to follow flip */ + if (bLeftToRight) + { + lTmp = OutputRect.left; + OutputRect.left = OutputRect.right; + OutputRect.right = lTmp; + } + + if (bTopToBottom) + { + lTmp = OutputRect.top; + OutputRect.top = OutputRect.bottom; + OutputRect.bottom = lTmp; + } + + DPRINT("Calling EngStretchBltROP: InputRect: (%d,%d)-(%d,%d) and OutputRect: (%d,%d)-(%d,%d)\n", + InputRect.left, InputRect.top, InputRect.right, InputRect.bottom, + OutputRect.left, OutputRect.top, OutputRect.right, OutputRect.bottom); + ret = EngStretchBltROP(psoDest, psoSource, MaskSurf, diff --git a/win32ss/gdi/ntgdi/bitblt.c b/win32ss/gdi/ntgdi/bitblt.c index b60ef9047f8..6d113035d90 100644 --- a/win32ss/gdi/ntgdi/bitblt.c +++ b/win32ss/gdi/ntgdi/bitblt.c @@ -7,6 +7,8 @@ */ #include <win32k.h> +#define NDEBUG +#include <debug.h> DBG_DEFAULT_CHANNEL(GdiBlt); BOOL APIENTRY @@ -480,6 +482,29 @@ NtGdiMaskBlt( XlateObj = &exlo.xlo; } + DPRINT("DestRect: (%d,%d)-(%d,%d) and SourcePoint is (%d,%d)\n", + DestRect.left, DestRect.top, DestRect.right, DestRect.bottom, + SourcePoint.x, SourcePoint.y); + + DPRINT("nWidth is '%d' and nHeight is '%d'.\n", nWidth, nHeight); + + /* Fix BitBlt so that it will not flip left to right */ + if ((DestRect.left > DestRect.right) && (nWidth < 0)) + { + SourcePoint.x += nWidth; + nWidth = -nWidth; + } + + /* Fix BitBlt so that it will not flip top to bottom */ + if ((DestRect.top > DestRect.bottom) && (nHeight < 0)) + { + SourcePoint.y += nHeight; + nHeight = -nHeight; + } + + /* Make Well Ordered so that we don't flip either way */ + RECTL_vMakeWellOrdered(&DestRect); + /* Perform the bitblt operation */ Status = IntEngBitBlt(&BitmapDest->SurfObj, BitmapSrc ? &BitmapSrc->SurfObj : NULL, @@ -563,6 +588,7 @@ GreStretchBltMask( BOOL UsesSource; BOOL UsesMask; ROP4 rop4; + BOOL Case0000, Case0101, Case1010, CaseExcept; rop4 = WIN32_ROP4_TO_ENG_ROP4(dwRop4); @@ -615,12 +641,31 @@ GreStretchBltMask( } } + + Case0000 = ((WidthDest < 0) && (HeightDest < 0) && (WidthSrc < 0) && (HeightSrc < 0)); + Case0101 = ((WidthDest < 0) && (HeightDest > 0) && (WidthSrc < 0) && (HeightSrc > 0)); + Case1010 = ((WidthDest > 0) && (HeightDest < 0) && (WidthSrc > 0) && (HeightSrc < 0)); + CaseExcept = (Case0000 || Case0101 || Case1010); + pdcattr = DCDest->pdcattr; DestRect.left = XOriginDest; DestRect.top = YOriginDest; DestRect.right = XOriginDest+WidthDest; DestRect.bottom = YOriginDest+HeightDest; + + /* Account for possible negative span values */ + if ((WidthDest < 0) && !CaseExcept) + { + DestRect.left++; + DestRect.right++; + } + if ((HeightDest < 0) && !CaseExcept) + { + DestRect.top++; + DestRect.bottom++; + } + IntLPtoDP(DCDest, (LPPOINT)&DestRect, 2); DestRect.left += DCDest->ptlDCOrig.x; @@ -638,6 +683,18 @@ GreStretchBltMask( SourceRect.right = XOriginSrc+WidthSrc; SourceRect.bottom = YOriginSrc+HeightSrc; + /* Account for possible negative span values */ + if ((WidthSrc < 0) && !CaseExcept) + { + SourceRect.left++; + SourceRect.right++; + } + if ((HeightSrc < 0) && !CaseExcept) + { + SourceRect.top++; + SourceRect.bottom++; + } + if (UsesSource) { IntLPtoDP(DCSrc, (LPPOINT)&SourceRect, 2); @@ -698,6 +755,10 @@ GreStretchBltMask( MaskPoint.y += DCMask->ptlDCOrig.y; } + DPRINT("Calling IntEngStrethBlt SourceRect: (%d,%d)-(%d,%d) and DestRect: (%d,%d)-(%d,%d).\n", + SourceRect.left, SourceRect.top, SourceRect.right, SourceRect.bottom, + DestRect.left, DestRect.top, DestRect.right, DestRect.bottom); + /* Perform the bitblt operation */ Status = IntEngStretchBlt(&BitmapDest->SurfObj, BitmapSrc ? &BitmapSrc->SurfObj : NULL, diff --git a/win32ss/gdi/ntgdi/dibobj.c b/win32ss/gdi/ntgdi/dibobj.c index 7b8cc330c73..3d88101c8ab 100644 --- a/win32ss/gdi/ntgdi/dibobj.c +++ b/win32ss/gdi/ntgdi/dibobj.c @@ -628,9 +628,17 @@ NtGdiSetDIBitsToDeviceInternal( pDestSurf = &pSurf->SurfObj; /* Copy the bits */ - DPRINT("BitsToDev with dstsurf=(%d|%d) (%d|%d), src=(%d|%d) w=%d h=%d\n", + DPRINT("BitsToDev with rcDest=(%d|%d) (%d|%d), ptSource=(%d|%d) w=%d h=%d\n", rcDest.left, rcDest.top, rcDest.right, rcDest.bottom, ptSource.x, ptSource.y, SourceSize.cx, SourceSize.cy); + + /* This fixes the large Google text on Google.com from being upside down */ + if (rcDest.top > rcDest.bottom) + { + RECTL_vMakeWellOrdered(&rcDest); + ptSource.y -= SourceSize.cy; + } + bResult = IntEngBitBlt(pDestSurf, pSourceSurf, pMaskSurf, @@ -722,7 +730,7 @@ GreGetDIBitsInternal( &size); if(bitmap_type == -1) { - DPRINT("Wrong bitmap format\n"); + DPRINT1("Wrong bitmap format\n"); EngSetLastError(ERROR_INVALID_PARAMETER); ScanLines = 0; goto done;

3 years, 10 months

[reactos] 01/01: [GDI32_APITEST] Add more StretchBlt Regression Tests (#3455)

by Doug Lyons

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=89843bec564368a7e1b8b… commit 89843bec564368a7e1b8b26bf47d09da3a1ad9dc Author: Doug Lyons <douglyons(a)douglyons.com> AuthorDate: Sat Feb 20 17:21:51 2021 -0600 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Feb 21 08:21:51 2021 +0900 [GDI32_APITEST] Add more StretchBlt Regression Tests (#3455) Added tests for many more StretchBlt options. Created StretchBlt regression tests for verifying most flip options. This is preparation for my Pull Request #3458 which will implement the flip functionality for StretchBlt. CORE-16642 --- modules/rostests/apitests/gdi32/StretchBlt.c | 833 +++++++++++++++++++++++++-- 1 file changed, 797 insertions(+), 36 deletions(-) diff --git a/modules/rostests/apitests/gdi32/StretchBlt.c b/modules/rostests/apitests/gdi32/StretchBlt.c index c72f9e220f1..5db1713beb6 100644 --- a/modules/rostests/apitests/gdi32/StretchBlt.c +++ b/modules/rostests/apitests/gdi32/StretchBlt.c @@ -2,8 +2,8 @@ * PROJECT: ReactOS API tests * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) * PURPOSE: Tests for the StretchBlt API - * COPYRIGHT: Copyright 2020 Doug Lyons (douglyons at douglyons dot com) - * Most Code copied and modified from Wine gdi32:bitmap test. + * COPYRIGHT: Copyright 2020, 2021 Doug Lyons (douglyons at douglyons dot com) + * Some Code copied and modified from Wine gdi32:bitmap test. */ #include <stdarg.h> @@ -18,91 +18,852 @@ #include "wingdi.h" #include "winuser.h" #include "wine/test.h" +#include <debug.h> + +/* Notes on using the StretchBlt function's general flip ability. + * + * The critical values for flipping are the signs of the values for DestWidth, DestHeight, SourceWidth and SourceHeight. + * If we assign a '0' to values having a negative sign and a '1' to values having a positive sign these can be CaseWXYZ's. + * Where the W, X, Y, and Z are replaced with the '0's and '1's representing the signs of the values in sequential order. + * + * If we take the normal StretchBlt function's copy/scaling with no flips, the generalized code can be represented as follows: + * + * StretchBlt(DestDC, DestX, DestY, (DestWidth), (DestHeight), + * SourceDC, SourceX, SourceY, (SourceWidth), (SourceHeight), SRCCOPY); // Case1111 (15) (all positive signs) + * + * For Horizontal flipping then the generalized form on the Destination side can be represented as follows: + * + * StretchBlt(DestDC, DestX + DestWidth - 1, DestY, -DestWidth, DestHeight, + * SourceDC, SourceX, SourceY, SourceWidth, SourceHeight, SRCCOPY); // Case 0111 (7) + * + * and for Horizontal flipping the generalized form on the Source side can be represented as follows: + * + * StretchBlt(DestDC, DestX, DestY, DestWidth, DestHeight, + * SourceDC, SourceX + SourceWidth - 1, SourceY, -SourceWidth, SourceHeight, SRCCOPY); // Case 1101 (13) + * + * I believe that the "- 1" is used because we are moving from the rightmost position back to the 0th position. + * + * But there are three "special" cases where no flip is done (there is a copy/scale only) and the "-1" is not used. + * These are as follows: + * 1) + * StretchBlt(DestDC, DestX + DestWidth, DestY, -DestWidth, DestHeight, // Both Widths negative + * SourceDC, SourceX + SourceWidth, SourceY, -SourceWidth, SourceHeight, SRCCOPY); // Case0101 (5) + * 2) + * StretchBlt(DestDC, DestX, DestY + DestHeight, DestWidth, -DestHeight, // Both heights negative + * SourceDC, SourceX, SourceY + SourceHeight, SourceWidth, -SourceHeight, SRCCOPY); // Case1010 (10) + * 3) + * StretchBlt(DestDC, DestX + DestWidth, DestY + DestHeight, -DestWidth, -DestHeight, // widths AND heights neg + * SourceDC, SourceX + SourceWidth, SourceY + SourceHeight, -SourceWidth, -SourceHeight, SRCCOPY); // Case0000 (0) + * + * I suspect that these are like this because of legacy reasons when StretchBlt did not support so many flip options. + * + * For Vertical flipping the generalized form on the Destination side can be represented as follows: + * + * StretchBlt(DestDC, DestX, DestY + DestHeight - 1, DestWidth, -DestHeight, + * SourceDC, SourceX, SourceY, SourceWidth, SourceHeight, SRCCOPY); // Case1011 (11) + * + * and for Vertical on the Source Side as folows: + * + * StretchBlt(DestDC, DestX, DestY, DestWidth, -DestHeight, + * SourceDC, SourceX, SourceY + SourceHeight - 1, SourceWidth, -SourceHeight, SRCCOPY); // Case 1010 (10) + */ + +static inline int get_dib_stride( int width, int bpp ) +{ + return ((width * bpp + 31) >> 3) & ~3; +} + +static inline int get_dib_image_size( const BITMAPINFO *info ) +{ + return get_dib_stride( info->bmiHeader.biWidth, info->bmiHeader.biBitCount ) + * abs( info->bmiHeader.biHeight ); +} + +static void check_StretchBlt_stretch(HDC hdcDst, HDC hdcSrc, BITMAPINFO *dst_info, UINT32 *dstBuffer, UINT32 *srcBuffer, + int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, + int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, + UINT32 *expected, int line) +{ + int dst_size = get_dib_image_size( dst_info ); + + memset(dstBuffer, 0, dst_size); + StretchBlt(hdcDst, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, + hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, SRCCOPY); + ok(memcmp(dstBuffer, expected, dst_size) == 0, + "StretchBlt \nexp { %08X, %08X, %08X, %08X } \ngot { %08X, %08X, %08X, %08X } \n" + "destination { %d, %d, %d, %d } source { %d, %d, %d, %d } from line %d\n", + expected[0], expected[1], expected[2], expected[3], + dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3], + nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, + nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, line); +} + +static void test_StretchBlt_stretch(HDC hdcDst, HDC hdcSrc, BITMAPINFO *dst_info, UINT32 *dstBuffer, UINT32 *srcBuffer, + int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, + int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, + UINT32 *expected, int line, BOOL SrcTopDown, BOOL DstTopDown ) +{ + int dst_size = get_dib_image_size( dst_info ); + + memset(dstBuffer, 0, dst_size); + StretchBlt(hdcDst, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, + hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, SRCCOPY); + ok(memcmp(dstBuffer, expected, dst_size) == 0, + "Case%c%c%c%c %s - %s \nexp { %08X, %08X, %08X, %08X } \ngot { %08X, %08X, %08X, %08X }\n" + "destination { %d, %d, %d, %d } source { %d, %d, %d, %d } from line %d\n", + (nWidthDest < 0) ? '0' : '1', (nHeightDest < 0) ? '0' : '1', + (nWidthSrc < 0) ? '0' : '1', (nHeightSrc < 0) ? '0' : '1', + SrcTopDown ? "SrcTopDown" : "SrcBottomUp", DstTopDown ? "DstTopDown" : "DstBottomUp", + expected[0], expected[1], expected[2], expected[3], + dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3], + nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, + nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, line); +} static void test_StretchBlt(void) { HBITMAP bmpDst, bmpSrc; - HDC hdcDst, hdcSrc; + HBITMAP oldDst, oldSrc; + HDC hdcScreen, hdcDst, hdcSrc; UINT32 *dstBuffer, *srcBuffer; BITMAPINFO biDst, biSrc; UINT32 expected[256]; + RGBQUAD colors[2]; memset(&biDst, 0, sizeof(BITMAPINFO)); - biDst.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); - biDst.bmiHeader.biWidth = 2; - biDst.bmiHeader.biHeight = 2; // Set our Height to positive so we are bottom-up + biDst.bmiHeader.biWidth = 16; + biDst.bmiHeader.biHeight = -16; biDst.bmiHeader.biPlanes = 1; - biDst.bmiHeader.biBitCount = 32; // Set our BitCount to 32 which is Full Color + biDst.bmiHeader.biBitCount = 32; biDst.bmiHeader.biCompression = BI_RGB; + memcpy(&biSrc, &biDst, sizeof(BITMAPINFO)); + + hdcScreen = CreateCompatibleDC(NULL); + hdcDst = CreateCompatibleDC(hdcScreen); + hdcSrc = CreateCompatibleDC(hdcDst); + + bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0); + oldDst = SelectObject(hdcDst, bmpDst); + + bmpSrc = CreateDIBSection(hdcScreen, &biSrc, DIB_RGB_COLORS, (void**)&srcBuffer, NULL, 0); + oldSrc = SelectObject(hdcSrc, bmpSrc); + + /* Top-down to top-down tests */ + srcBuffer[0] = 0xCAFED00D, srcBuffer[1] = 0xFEEDFACE; + srcBuffer[16] = 0xFEDCBA98, srcBuffer[17] = 0x76543210; + + memset( expected, 0, get_dib_image_size( &biDst ) ); + expected[0] = 0xCAFED00D, expected[1] = 0xFEEDFACE; + expected[16] = 0xFEDCBA98, expected[17] = 0x76543210; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 0, 2, 2, expected, __LINE__); + + expected[0] = 0xCAFED00D, expected[1] = 0x00000000; + expected[16] = 0x00000000, expected[17] = 0x00000000; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 1, 1, 0, 0, 1, 1, expected, __LINE__); + + expected[0] = 0xCAFED00D, expected[1] = 0xCAFED00D; + expected[16] = 0xCAFED00D, expected[17] = 0xCAFED00D; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 0, 1, 1, expected, __LINE__); + + /* This is an example of the dst width (height) == 1 exception, explored below */ + expected[0] = 0xCAFED00D, expected[1] = 0x00000000; + expected[16] = 0x00000000, expected[17] = 0x00000000; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 1, 1, 0, 0, 2, 2, expected, __LINE__); + + expected[0] = 0xCAFED00D, expected[1] = 0x00000000; + expected[16] = 0x00000000, expected[17] = 0x00000000; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, -2, -2, 1, 1, -2, -2, expected, __LINE__); + + expected[0] = 0x00000000, expected[1] = 0x00000000; + expected[16] = 0x00000000, expected[17] = 0xCAFED00D, expected[18] = 0xFEEDFACE; + expected[32] = 0x00000000, expected[33] = 0xFEDCBA98, expected[34] = 0x76543210; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, 2, 2, 0, 0, 2, 2, expected, __LINE__); + + /* when dst width is 1 merge src width - 1 pixels */ + memset( srcBuffer, 0, get_dib_image_size( &biSrc ) ); + srcBuffer[0] = 0x0000ff00, srcBuffer[1] = 0x0000f0f0, srcBuffer[2] = 0x0000cccc, srcBuffer[3] = 0x0000aaaa; + srcBuffer[16] = 0xFEDCBA98, srcBuffer[17] = 0x76543210; + + memset( expected, 0, get_dib_image_size( &biDst ) ); + expected[0] = srcBuffer[0]; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 1, 1, 0, 0, 2, 1, expected, __LINE__); + + /* similarly in the vertical direction */ + memset( expected, 0, get_dib_image_size( &biDst ) ); + expected[0] = srcBuffer[0]; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 1, 1, 0, 0, 1, 2, expected, __LINE__); + + /* check that it's the dst size in device units that needs to be 1 */ + SetMapMode( hdcDst, MM_ISOTROPIC ); + SetWindowExtEx( hdcDst, 200, 200, NULL ); + SetViewportExtEx( hdcDst, 100, 100, NULL ); + + SetMapMode( hdcDst, MM_TEXT ); + + SelectObject(hdcDst, oldDst); + DeleteObject(bmpDst); + + /* Top-down to bottom-up tests */ + memset( srcBuffer, 0, get_dib_image_size( &biSrc ) ); + srcBuffer[0] = 0xCAFED00D, srcBuffer[1] = 0xFEEDFACE; + srcBuffer[16] = 0xFEDCBA98, srcBuffer[17] = 0x76543210; + + biDst.bmiHeader.biHeight = 16; + bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0); + oldDst = SelectObject(hdcDst, bmpDst); + + memset( expected, 0, get_dib_image_size( &biDst ) ); + + expected[224] = 0xFEDCBA98, expected[225] = 0x76543210; + expected[240] = 0xCAFED00D, expected[241] = 0xFEEDFACE; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 0, 2, 2, expected, __LINE__); + + SelectObject(hdcSrc, oldSrc); + DeleteObject(bmpSrc); + + /* Bottom-up to bottom-up tests */ + biSrc.bmiHeader.biHeight = 16; + bmpSrc = CreateDIBSection(hdcScreen, &biSrc, DIB_RGB_COLORS, (void**)&srcBuffer, NULL, 0); + srcBuffer[224] = 0xCAFED00D, srcBuffer[225] = 0xFEEDFACE; + srcBuffer[240] = 0xFEDCBA98, srcBuffer[241] = 0x76543210; + oldSrc = SelectObject(hdcSrc, bmpSrc); + + memset( expected, 0, get_dib_image_size( &biDst ) ); + + expected[224] = 0xCAFED00D, expected[225] = 0xFEEDFACE; + expected[240] = 0xFEDCBA98, expected[241] = 0x76543210; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 0, 2, 2, expected, __LINE__); + + SelectObject(hdcDst, oldDst); + DeleteObject(bmpDst); + + /* Bottom-up to top-down tests */ + biDst.bmiHeader.biHeight = -16; + bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0); + oldDst = SelectObject(hdcDst, bmpDst); - memcpy(&biSrc, &biDst, sizeof(BITMAPINFO)); // Put same Destination params into the Source + memset( expected, 0, get_dib_image_size( &biDst ) ); + expected[0] = 0xFEDCBA98, expected[1] = 0x76543210; + expected[16] = 0xCAFED00D, expected[17] = 0xFEEDFACE; + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 0, 2, 2, expected, __LINE__); - hdcDst = CreateCompatibleDC(0); - hdcSrc = CreateCompatibleDC(0); + SelectObject(hdcSrc, oldSrc); + DeleteObject(bmpSrc); + + biSrc.bmiHeader.biHeight = -2; + biSrc.bmiHeader.biBitCount = 24; + bmpSrc = CreateDIBSection(hdcScreen, &biSrc, DIB_RGB_COLORS, (void**)&srcBuffer, NULL, 0); + oldSrc = SelectObject(hdcSrc, bmpSrc); + + memset( expected, 0, get_dib_image_size( &biDst ) ); + expected[0] = 0xFEEDFACE, expected[1] = 0xCAFED00D; + expected[2] = 0x76543210, expected[3] = 0xFEDCBA98; + memcpy(dstBuffer, expected, 4 * sizeof(*dstBuffer)); + StretchBlt(hdcSrc, 0, 0, 4, 1, hdcDst, 0, 0, 4, 1, SRCCOPY ); + memset(dstBuffer, 0x55, 4 * sizeof(*dstBuffer)); + StretchBlt(hdcDst, 0, 0, 4, 1, hdcSrc, 0, 0, 4, 1, SRCCOPY ); + expected[0] = 0x00EDFACE, expected[1] = 0x00FED00D; + expected[2] = 0x00543210, expected[3] = 0x00DCBA98; + ok(!memcmp(dstBuffer, expected, 16), + "StretchBlt expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X }\n", + expected[0], expected[1], expected[2], expected[3], + dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3] ); + + expected[0] = 0xFEEDFACE, expected[1] = 0xCAFED00D; + expected[2] = 0x76543210, expected[3] = 0xFEDCBA98; + memcpy(srcBuffer, expected, 4 * sizeof(*dstBuffer)); + memset(dstBuffer, 0x55, 4 * sizeof(*dstBuffer)); + StretchBlt(hdcDst, 0, 0, 4, 1, hdcSrc, 0, 0, 4, 1, SRCCOPY ); + expected[0] = 0x00EDFACE, expected[1] = 0x00D00DFE; + expected[2] = 0x0010CAFE, expected[3] = 0x00765432; + ok(!memcmp(dstBuffer, expected, 16), + "StretchBlt expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X }\n", + expected[0], expected[1], expected[2], expected[3], + dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3] ); + + SelectObject(hdcSrc, oldSrc); + DeleteObject(bmpSrc); + + biSrc.bmiHeader.biBitCount = 1; + bmpSrc = CreateDIBSection(hdcScreen, &biSrc, DIB_RGB_COLORS, (void**)&srcBuffer, NULL, 0); + oldSrc = SelectObject(hdcSrc, bmpSrc); + *((DWORD *)colors + 0) = 0x123456; + *((DWORD *)colors + 1) = 0x335577; + SetDIBColorTable( hdcSrc, 0, 2, colors ); + srcBuffer[0] = 0x55555555; + memset(dstBuffer, 0xcc, 4 * sizeof(*dstBuffer)); + SetTextColor( hdcDst, 0 ); + SetBkColor( hdcDst, 0 ); + StretchBlt(hdcDst, 0, 0, 4, 1, hdcSrc, 0, 0, 4, 1, SRCCOPY ); + expected[0] = expected[2] = 0x00123456; + expected[1] = expected[3] = 0x00335577; + ok(!memcmp(dstBuffer, expected, 16), + "StretchBlt expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X }\n", + expected[0], expected[1], expected[2], expected[3], + dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3] ); + + SelectObject(hdcSrc, oldSrc); + DeleteObject(bmpSrc); + + bmpSrc = CreateBitmap( 16, 16, 1, 1, 0 ); + oldSrc = SelectObject(hdcSrc, bmpSrc); + SetPixel( hdcSrc, 0, 0, 0 ); + SetPixel( hdcSrc, 1, 0, 0xffffff ); + SetPixel( hdcSrc, 2, 0, 0xffffff ); + SetPixel( hdcSrc, 3, 0, 0 ); + memset(dstBuffer, 0xcc, 4 * sizeof(*dstBuffer)); + SetTextColor(hdcDst, RGB(0x22, 0x44, 0x66)); + SetBkColor(hdcDst, RGB(0x65, 0x43, 0x21)); + StretchBlt(hdcDst, 0, 0, 4, 1, hdcSrc, 0, 0, 4, 1, SRCCOPY ); + expected[0] = expected[3] = 0x00224466; + expected[1] = expected[2] = 0x00654321; + ok(!memcmp(dstBuffer, expected, 16), + "StretchBlt expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X }\n", + expected[0], expected[1], expected[2], expected[3], + dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3] ); + + SelectObject(hdcSrc, oldSrc); + DeleteObject(bmpSrc); + + SelectObject(hdcSrc, oldSrc); + DeleteObject(bmpSrc); + SelectObject(hdcDst, oldDst); + DeleteObject(bmpDst); + + memset(&biDst, 0, sizeof(BITMAPINFO)); // Clear our Bitmap to to all zeroes + + biDst.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); // Set our Size to the header size + biDst.bmiHeader.biWidth = 2; // Set our Width to 2 (left-to-right) + biDst.bmiHeader.biHeight = -2; // Set our Height to -2 that's negative for top-down + biDst.bmiHeader.biPlanes = 1; // Set out planes to 1 (1 required by Windows) + biDst.bmiHeader.biBitCount = 32; // Set out BitCount to 32 (Full Color) + biDst.bmiHeader.biCompression = BI_RGB; // Set our Compression to BI_RBG (uncompressed) + + memcpy(&biSrc, &biDst, sizeof(BITMAPINFO)); // Put same Destination params into the Source bmpSrc = CreateDIBSection(hdcSrc, &biSrc, DIB_RGB_COLORS, (void**)&srcBuffer, NULL, 0); - SelectObject(hdcSrc, bmpSrc); + oldSrc = SelectObject(hdcSrc, bmpSrc); bmpDst = CreateDIBSection(hdcDst, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0); - SelectObject(hdcDst, bmpDst); + oldDst = SelectObject(hdcDst, bmpDst); + + srcBuffer[0] = 0x000000FF; // BLUE + srcBuffer[1] = 0x0000FF00; // GREEN + srcBuffer[2] = 0x00FF0000; // RED + srcBuffer[3] = 0xFF000000; // ALPHA (Opacity) + + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; - srcBuffer[0] = 0x000000FF; // BLUE - stored beginning bottom left - srcBuffer[1] = 0x0000FF00; // GREEN - srcBuffer[2] = 0x00FF0000; // RED - srcBuffer[3] = 0xFF000000; // BLACK - 0xFF for alpha channel is easy to recognize when printed in hex format + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 0, 2, 2, expected, __LINE__); // Case 1111 (15) - No flip. Just copy. + + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 1, 2, -2, expected, __LINE__); // Case 1110 (14) - Vertical flip. - /* Flip Left to Right on Source */ - StretchBlt(hdcDst, 0, 0, 2, 2, hdcSrc, 1, 0, -2, 2, SRCCOPY); expected[0] = 0x0000FF00; expected[1] = 0x000000FF; expected[2] = 0xFF000000; expected[3] = 0x00FF0000; - ok(expected[1] == dstBuffer[1], "StretchBlt expected { %08X } got { %08X }\n", - expected[1], dstBuffer[1]); + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 1, 0, -2, 2, expected, __LINE__); // Case 1101 (13) - Horizontal flip. + + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; - ok(expected[3] == dstBuffer[3], "StretchBlt expected { %08X } got { %08X }\n", - expected[3], dstBuffer[3]); + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 1, 1, -2, -2, expected, __LINE__); // Case 1100 (12) - Both flip. - /* Flip Top to Bottom on Source */ - StretchBlt(hdcDst, 0, 0, 2, 2, hdcSrc, 0, 1, 2, -2, SRCCOPY); expected[0] = 0x00FF0000; expected[1] = 0xFF000000; expected[2] = 0x000000FF; expected[3] = 0x0000FF00; - ok(expected[0] == dstBuffer[0], "StretchBlt expected { %08X } got { %08X }\n", - expected[0], dstBuffer[0]); + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 1, 2, -2, 0, 0, 2, 2, expected, __LINE__); // Case 1011 (11) - Vertical Flip. + + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; - ok(expected[1] == dstBuffer[1], "StretchBlt expected { %08X } got { %08X }\n", - expected[1], dstBuffer[1]); + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 2, 2, -2, 0, 2, 2, -2, expected, __LINE__); // Case 1010 (10) - No Flip. Special Case. - /* Flip Left to Right and Top to Bottom on Source */ - StretchBlt(hdcDst, 0, 0, 2, 2, hdcSrc, 1, 1, -2, -2, SRCCOPY); expected[0] = 0xFF000000; expected[1] = 0x00FF0000; expected[2] = 0x0000FF00; expected[3] = 0x000000FF; - ok(expected[1] == dstBuffer[1], "StretchBlt expected { %08X } got { %08X }\n", - expected[1], dstBuffer[1]); + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 1, 2, -2, 1, 0, -2, 2, expected, __LINE__); // Case 1001 (9) - Both Flip. + + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 1, 2, -2, 1, 1, -2, -2, expected, __LINE__); // Case 1000 (8) - Horizontal Flip. + + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 0, -2, 2, 0, 0, 2, 2, expected, __LINE__); // Case 0111 (7) - Horizontal Flip. - /* Flip Left to Right and Top to Bottom on both Source and Destination */ - StretchBlt(hdcDst, 1, 1, -2, -2, hdcSrc, 1, 1, -2, -2, SRCCOPY); expected[0] = 0xFF000000; expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 0, -2, 2, 0, 1, 2, -2, expected, __LINE__); // Case 0110 (6) - Both Flip. + + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 2, 0, -2, 2, 2, 0, -2, 2, expected, __LINE__); // Case 0101 (5) - No Flip. Special Case. + + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 0, -2, 2, 1, 1, -2, -2, expected, __LINE__); // Case 0100 (4) - Vertical Flip. + + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; expected[3] = 0x000000FF; - ok(expected[1] == dstBuffer[1], "StretchBlt expected { %08X } got { %08X }\n", - expected[1], dstBuffer[1]); + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, -2, -2, 0, 0, 2, 2, expected, __LINE__); // Case 0011 (3) - Both Flip. + + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, -2, -2, 0, 1, 2, -2, expected, __LINE__); // Case 0010 (2) - Horizontal Flip. + + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, -2, -2, 1, 0, -2, 2, expected, __LINE__); // Case 0001 (1) - Vertical Flip. + + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + + check_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 2, 2, -2, -2, 2, 2, -2, -2, expected, __LINE__); // Case 0000 (0) - No Flip. Special Case. DeleteDC(hdcSrc); + + SelectObject(hdcDst, oldDst); + DeleteObject(bmpDst); DeleteDC(hdcDst); + + DeleteDC(hdcScreen); } +static void test_StretchBlt_TopDownOptions(BOOL SrcTopDown, BOOL DstTopDown) +{ + HBITMAP bmpDst, bmpSrc; + HBITMAP oldDst, oldSrc; + HDC hdcScreen, hdcDst, hdcSrc; + UINT32 *dstBuffer, *srcBuffer; + BITMAPINFO biDst, biSrc; + UINT32 expected[256]; + + memset(&biDst, 0, sizeof(BITMAPINFO)); + + biDst.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + biDst.bmiHeader.biWidth = 2; + biDst.bmiHeader.biHeight = 2; + biDst.bmiHeader.biPlanes = 1; + biDst.bmiHeader.biBitCount = 32; + biDst.bmiHeader.biCompression = BI_RGB; + memcpy(&biSrc, &biDst, sizeof(BITMAPINFO)); + + if (!SrcTopDown && !DstTopDown) + { + biSrc.bmiHeader.biHeight = -2; // Converts Source bitmap to top down + biDst.bmiHeader.biHeight = -2; // Converts Destination bitmap to top down + } + + if (SrcTopDown) + { + biSrc.bmiHeader.biHeight = -2; // Converts Source bitmap to top down + } + + if (DstTopDown) + { + biDst.bmiHeader.biHeight = -2; // Converts Destination bitmap to top down + } + + hdcScreen = CreateCompatibleDC(NULL); + hdcDst = CreateCompatibleDC(hdcScreen); + hdcSrc = CreateCompatibleDC(hdcDst); + + bmpSrc = CreateDIBSection(hdcScreen, &biSrc, DIB_RGB_COLORS, (void**)&srcBuffer, NULL, 0); + oldSrc = SelectObject(hdcSrc, bmpSrc); + bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0); + oldDst = SelectObject(hdcDst, bmpDst); + + srcBuffer[0] = 0x000000FF; // BLUE + srcBuffer[1] = 0x0000FF00; // GREEN + srcBuffer[2] = 0x00FF0000; // RED + srcBuffer[3] = 0xFF000000; // ALPHA (Opacity) + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + } + else + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 0, 2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1111 (15) - No flip. Just copy. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + else + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 0, 1, 2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1110 (14) - Vertical flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + else + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 1, 0, -2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1101 (13) - Horizontal flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + else + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 0, 2, 2, 1, 1, -2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1100 (12) - Both flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + else + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 1, 2, -2, 0, 0, 2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1011 (11) - Vertical Flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + } + else + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 2, 2, -2, 0, 2, 2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1010 (10) - No Flip. Special Case. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + else + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 1, 2, -2, 1, 0, -2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1001 (9) - Both Flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + else + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 0, 1, 2, -2, 1, 1, -2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 1000 (8) - Horizontal Flip + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + else + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 0, -2, 2, 0, 0, 2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0111 (7) - Horizontal Flip + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + else + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 0, -2, 2, 0, 1, 2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0110 (6) - Both Flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + } + else + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 2, 0, -2, 2, 2, 0, -2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0101 (5) - No Flip. Special Case. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + else + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 0, -2, 2, 1, 1, -2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0100 (4) - Vertical Flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + else + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, -2, -2, 0, 0, 2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0011 (3) - Both Flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0xFF000000; + expected[1] = 0x00FF0000; + expected[2] = 0x0000FF00; + expected[3] = 0x000000FF; + } + else + { + expected[0] = 0x0000FF00; + expected[1] = 0x000000FF; + expected[2] = 0xFF000000; + expected[3] = 0x00FF0000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, -2, -2, 0, 1, 2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0010 (2) - Horizontal Flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + else + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 1, 1, -2, -2, 1, 0, -2, 2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0001 (1) - Vertical Flip. + + if ((SrcTopDown || DstTopDown) && !(SrcTopDown && DstTopDown)) + { + expected[0] = 0x00FF0000; + expected[1] = 0xFF000000; + expected[2] = 0x000000FF; + expected[3] = 0x0000FF00; + + } + else + { + expected[0] = 0x000000FF; + expected[1] = 0x0000FF00; + expected[2] = 0x00FF0000; + expected[3] = 0xFF000000; + } + + test_StretchBlt_stretch(hdcDst, hdcSrc, &biDst, dstBuffer, srcBuffer, + 2, 2, -2, -2, 2, 2, -2, -2, expected, __LINE__, SrcTopDown, DstTopDown); // Case 0000 (0) - No Flip. Special Case. + + SelectObject(hdcSrc, oldSrc); + DeleteObject(bmpSrc); + DeleteDC(hdcSrc); + + SelectObject(hdcDst, oldDst); + DeleteObject(bmpDst); + DeleteDC(hdcDst); + + DeleteDC(hdcScreen); +} START_TEST(StretchBlt) { + trace("\n\n## Start of generalized StretchBlt tests.\n\n"); test_StretchBlt(); + + trace("\n\n## Start of source top-down and destination top-down tests.\n\n"); + test_StretchBlt_TopDownOptions(TRUE, TRUE); + + trace("\n\n## Start of source top-down and destination bottom-up tests.\n\n"); + test_StretchBlt_TopDownOptions(TRUE, FALSE); + + trace("\n\n## Start of source bottom-up and destination top-down tests.\n\n"); + test_StretchBlt_TopDownOptions(FALSE, TRUE); + + trace("\n\n## Start of source bottom-up and destination bottom-up tests.\n\n"); + test_StretchBlt_TopDownOptions(FALSE, FALSE); }

3 years, 10 months

[reactos] 01/01: [KERNEL32] Align the PROCESS_PRIORITY_CLASS variable in GetPriorityClass on a 4-byte boundary.

by Colin Finck

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=fd8080b0942e88502ca17… commit fd8080b0942e88502ca1735a0590f31e6d072e32 Author: Colin Finck <colin(a)reactos.org> AuthorDate: Sat Feb 20 17:13:38 2021 +0100 Commit: Colin Finck <colin(a)reactos.org> CommitDate: Sat Feb 20 17:13:38 2021 +0100 [KERNEL32] Align the PROCESS_PRIORITY_CLASS variable in GetPriorityClass on a 4-byte boundary. Fixes CORE-16757. This is required for NtQueryInformationProcess as proven by my test application in the bug report. --- dll/win32/kernel32/client/proc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dll/win32/kernel32/client/proc.c b/dll/win32/kernel32/client/proc.c index e107c19b029..3b7d6f05ec5 100644 --- a/dll/win32/kernel32/client/proc.c +++ b/dll/win32/kernel32/client/proc.c @@ -1658,7 +1658,7 @@ WINAPI GetPriorityClass(IN HANDLE hProcess) { NTSTATUS Status; - PROCESS_PRIORITY_CLASS PriorityClass; + PROCESS_PRIORITY_CLASS DECLSPEC_ALIGN(4) PriorityClass; /* Query the kernel */ Status = NtQueryInformationProcess(hProcess,

3 years, 10 months

[reactos] 01/01: [LSASRV] Add start code for the netlogon service

by Eric Kohl

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ea26bef01de20d5c140a4… commit ea26bef01de20d5c140a426397627089892356a0 Author: Eric Kohl <eric.kohl(a)reactos.org> AuthorDate: Fri Feb 19 21:53:00 2021 +0100 Commit: Eric Kohl <eric.kohl(a)reactos.org> CommitDate: Fri Feb 19 21:53:00 2021 +0100 [LSASRV] Add start code for the netlogon service --- boot/bootdata/hivesys.inf | 12 ++++++------ dll/win32/lsasrv/service.c | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 6 deletions(-) diff --git a/boot/bootdata/hivesys.inf b/boot/bootdata/hivesys.inf index 586b4746633..7dc2c1141fd 100644 --- a/boot/bootdata/hivesys.inf +++ b/boot/bootdata/hivesys.inf @@ -1677,12 +1677,12 @@ HKLM,"SYSTEM\CurrentControlSet\Services\Ndis","Start",0x00010001,0x00000000 HKLM,"SYSTEM\CurrentControlSet\Services\Ndis","Type",0x00010001,0x00000001 ; NetLogon -;HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","DisplayName",0x00000000,%NETLOGON_SERVICE% -;HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","Description",0x00000000,%NETLOGON_SERVICE_DESCRIPTION% -;HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","ErrorControl",0x00010001,0x00000001 -;HKLM,"SYSTEM\CurrentControlSet\Services\Netlogon","ImagePath",0x00020000,"%SystemRoot%\system32\lsass.exe" -;HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","Start",0x00010001,0x00000003 -;HKLM,"SYSTEM\CurrentControlSet\Services\Netlogon","Type",0x00010001,0x00000020 +HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","DisplayName",0x00000000,%NETLOGON_SERVICE% +HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","Description",0x00000000,%NETLOGON_SERVICE_DESCRIPTION% +HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","ErrorControl",0x00010001,0x00000001 +HKLM,"SYSTEM\CurrentControlSet\Services\Netlogon","ImagePath",0x00020000,"%SystemRoot%\system32\lsass.exe" +HKLM,"SYSTEM\CurrentControlSet\Services\NetLogon","Start",0x00010001,0x00000003 +HKLM,"SYSTEM\CurrentControlSet\Services\Netlogon","Type",0x00010001,0x00000020 ; NTFS filesystem driver HKLM,"SYSTEM\CurrentControlSet\Services\Ntfs","ErrorControl",0x00010001,0x00000000 diff --git a/dll/win32/lsasrv/service.c b/dll/win32/lsasrv/service.c index 9c207811135..95fe262c7b2 100644 --- a/dll/win32/lsasrv/service.c +++ b/dll/win32/lsasrv/service.c @@ -11,12 +11,16 @@ #include "lsasrv.h" #include <winsvc.h> +typedef VOID (WINAPI *PNETLOGONMAIN)(INT ArgCount, PWSTR *ArgVector); + VOID WINAPI I_ScIsSecurityProcess(VOID); +static VOID WINAPI NetlogonServiceMain(DWORD dwArgc, PWSTR *pszArgv); static VOID WINAPI SamSsServiceMain(DWORD dwArgc, PWSTR *pszArgv); SERVICE_TABLE_ENTRYW ServiceTable[] = { + {L"NETLOGON", NetlogonServiceMain}, {L"SAMSS", SamSsServiceMain}, {NULL, NULL} }; @@ -24,6 +28,39 @@ SERVICE_TABLE_ENTRYW ServiceTable[] = /* FUNCTIONS ***************************************************************/ +static +VOID +WINAPI +NetlogonServiceMain( + _In_ DWORD dwArgc, + _In_ PWSTR *pszArgv) +{ + HINSTANCE hNetlogon = NULL; + PNETLOGONMAIN pNetlogonMain = NULL; + + TRACE("NetlogonServiceMain(%lu %p)\n", dwArgc, pszArgv); + + hNetlogon = LoadLibraryW(L"Netlogon.dll"); + if (hNetlogon == NULL) + { + ERR("LoadLibrary() failed!\n"); + return; + } + + pNetlogonMain = (PNETLOGONMAIN)GetProcAddress(hNetlogon, "NlNetlogonMain"); + if (pNetlogonMain == NULL) + { + ERR("GetProcAddress(NlNetlogonMain) failed!\n"); + FreeLibrary(hNetlogon); + return; + } + + TRACE("NlNetlogonMain %p\n", pNetlogonMain); + + pNetlogonMain(dwArgc, pszArgv); +} + + static VOID WINAPI

3 years, 10 months

[reactos] 01/01: [NTOS:CC] Keep a reference on the shared cache map of the file when we are in lazy write

by Jérôme Gardou

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2a962eaf8c514a7b7a12b… commit 2a962eaf8c514a7b7a12bb121457c5bcbbd404fd Author: Jérôme Gardou <jerome.gardou(a)reactos.org> AuthorDate: Fri Feb 19 15:47:05 2021 +0100 Commit: Jérôme Gardou <jerome.gardou(a)reactos.org> CommitDate: Fri Feb 19 15:48:31 2021 +0100 [NTOS:CC] Keep a reference on the shared cache map of the file when we are in lazy write This should fix "Leaking VACB" debug prints --- ntoskrnl/cc/view.c | 226 ++++++++++++++++++++++++++--------------------------- 1 file changed, 111 insertions(+), 115 deletions(-) diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index c9a13047447..6481c340fe0 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -200,6 +200,107 @@ quit: return Status; } +static +NTSTATUS +CcRosDeleteFileCache ( + PFILE_OBJECT FileObject, + PROS_SHARED_CACHE_MAP SharedCacheMap, + PKIRQL OldIrql) +/* + * FUNCTION: Releases the shared cache map associated with a file object + */ +{ + PLIST_ENTRY current_entry; + + ASSERT(SharedCacheMap); + ASSERT(SharedCacheMap == FileObject->SectionObjectPointer->SharedCacheMap); + ASSERT(SharedCacheMap->OpenCount == 0); + + /* Remove all VACBs from the global lists */ + KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock); + current_entry = SharedCacheMap->CacheMapVacbListHead.Flink; + while (current_entry != &SharedCacheMap->CacheMapVacbListHead) + { + PROS_VACB Vacb = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry); + + RemoveEntryList(&Vacb->VacbLruListEntry); + InitializeListHead(&Vacb->VacbLruListEntry); + + if (Vacb->Dirty) + { + CcRosUnmarkDirtyVacb(Vacb, FALSE); + /* Mark it as dirty again so we know that we have to flush before freeing it */ + Vacb->Dirty = TRUE; + } + + current_entry = current_entry->Flink; + } + + /* Make sure there is no trace anymore of this map */ + FileObject->SectionObjectPointer->SharedCacheMap = NULL; + RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks); + + KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock); + KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql); + + /* Now that we're out of the locks, free everything for real */ + while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead)) + { + PROS_VACB Vacb = CONTAINING_RECORD(RemoveHeadList(&SharedCacheMap->CacheMapVacbListHead), ROS_VACB, CacheMapVacbListEntry); + ULONG RefCount; + + InitializeListHead(&Vacb->CacheMapVacbListEntry); + + /* Flush to disk, if needed */ + if (Vacb->Dirty) + { + IO_STATUS_BLOCK Iosb; + NTSTATUS Status; + + Status = MmFlushSegment(FileObject->SectionObjectPointer, &Vacb->FileOffset, VACB_MAPPING_GRANULARITY, &Iosb); + if (!NT_SUCCESS(Status)) + { + /* Complain. There's not much we can do */ + DPRINT1("Failed to flush VACB to disk while deleting the cache entry. Status: 0x%08x\n", Status); + } + Vacb->Dirty = FALSE; + } + + RefCount = CcRosVacbDecRefCount(Vacb); +#if DBG // CORE-14578 + if (RefCount != 0) + { + DPRINT1("Leaking VACB %p attached to %p (%I64d)\n", Vacb, FileObject, Vacb->FileOffset.QuadPart); + DPRINT1("There are: %d references left\n", RefCount); + DPRINT1("Map: %d\n", Vacb->MappedCount); + DPRINT1("Dirty: %d\n", Vacb->Dirty); + if (FileObject->FileName.Length != 0) + { + DPRINT1("File was: %wZ\n", &FileObject->FileName); + } + else + { + DPRINT1("No name for the file\n"); + } + } +#else + (void)RefCount; +#endif + } + + /* Release the references we own */ + if(SharedCacheMap->Section) + ObDereferenceObject(SharedCacheMap->Section); + ObDereferenceObject(SharedCacheMap->FileObject); + + ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap); + + /* Acquire the lock again for our caller */ + *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); + + return STATUS_SUCCESS; +} + NTSTATUS CcRosFlushDirtyPages ( ULONG Target, @@ -273,6 +374,9 @@ CcRosFlushDirtyPages ( SharedCacheMap->Flags |= SHARED_CACHE_MAP_IN_LAZYWRITE; + /* Keep a ref on the shared cache map */ + SharedCacheMap->OpenCount++; + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); Locked = SharedCacheMap->Callbacks->AcquireForLazyWrite(SharedCacheMap->LazyWriteContext, Wait); @@ -283,6 +387,10 @@ CcRosFlushDirtyPages ( CcRosVacbDecRefCount(current); OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE; + + if (--SharedCacheMap->OpenCount == 0) + CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql); + continue; } @@ -300,6 +408,9 @@ CcRosFlushDirtyPages ( SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE; + if (--SharedCacheMap->OpenCount == 0) + CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql); + if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE) && (Status != STATUS_MEDIA_WRITE_PROTECTED)) { @@ -1014,121 +1125,6 @@ quit: } } -NTSTATUS -CcRosDeleteFileCache ( - PFILE_OBJECT FileObject, - PROS_SHARED_CACHE_MAP SharedCacheMap, - PKIRQL OldIrql) -/* - * FUNCTION: Releases the shared cache map associated with a file object - */ -{ - PLIST_ENTRY current_entry; - - ASSERT(SharedCacheMap); - ASSERT(SharedCacheMap == FileObject->SectionObjectPointer->SharedCacheMap); - ASSERT(SharedCacheMap->OpenCount == 0); - - /* Remove all VACBs from the global lists */ - KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock); - current_entry = SharedCacheMap->CacheMapVacbListHead.Flink; - while (current_entry != &SharedCacheMap->CacheMapVacbListHead) - { - PROS_VACB Vacb = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry); - - RemoveEntryList(&Vacb->VacbLruListEntry); - InitializeListHead(&Vacb->VacbLruListEntry); - - if (Vacb->Dirty) - { - CcRosUnmarkDirtyVacb(Vacb, FALSE); - /* Mark it as dirty again so we know that we have to flush before freeing it */ - Vacb->Dirty = TRUE; - } - - current_entry = current_entry->Flink; - } - - /* Make sure there is no trace anymore of this map */ - FileObject->SectionObjectPointer->SharedCacheMap = NULL; - RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks); - - KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock); - KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql); - - /* Now that we're out of the locks, free everything for real */ - while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead)) - { - PROS_VACB Vacb = CONTAINING_RECORD(RemoveHeadList(&SharedCacheMap->CacheMapVacbListHead), ROS_VACB, CacheMapVacbListEntry); - ULONG RefCount; - - InitializeListHead(&Vacb->CacheMapVacbListEntry); - - /* Flush to disk, if needed */ - if (Vacb->Dirty) - { - IO_STATUS_BLOCK Iosb; - NTSTATUS Status; - - Status = MmFlushSegment(FileObject->SectionObjectPointer, &Vacb->FileOffset, VACB_MAPPING_GRANULARITY, &Iosb); - if (!NT_SUCCESS(Status)) - { - /* Complain. There's not much we can do */ - DPRINT1("Failed to flush VACB to disk while deleting the cache entry. Status: 0x%08x\n", Status); - } - Vacb->Dirty = FALSE; - } - - RefCount = CcRosVacbDecRefCount(Vacb); -#if DBG // CORE-14578 - if (RefCount != 0) - { - DPRINT1("Leaking VACB %p attached to %p (%I64d)\n", Vacb, FileObject, Vacb->FileOffset.QuadPart); - DPRINT1("There are: %d references left\n", RefCount); - DPRINT1("Map: %d\n", Vacb->MappedCount); - DPRINT1("Dirty: %d\n", Vacb->Dirty); - if (FileObject->FileName.Length != 0) - { - DPRINT1("File was: %wZ\n", &FileObject->FileName); - } - else - { - DPRINT1("No name for the file\n"); - } - } -#else - (void)RefCount; -#endif - } - - /* Release the references we own */ - if(SharedCacheMap->Section) - ObDereferenceObject(SharedCacheMap->Section); - ObDereferenceObject(SharedCacheMap->FileObject); - - ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap); - - /* Acquire the lock again for our caller */ - *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); - - return STATUS_SUCCESS; -} - -VOID -CcRosReferenceCache ( - PFILE_OBJECT FileObject) -{ - PROS_SHARED_CACHE_MAP SharedCacheMap; - KIRQL OldIrql; - - OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); - SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; - ASSERT(SharedCacheMap); - ASSERT(SharedCacheMap->OpenCount != 0); - SharedCacheMap->OpenCount++; - KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); -} - NTSTATUS CcRosReleaseFileCache ( PFILE_OBJECT FileObject)

3 years, 10 months

[reactos] 01/01: [NTOS:WMI] Be consistent about potential NULL pointer use

by Jérôme Gardou

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d18634c026eeba286699b… commit d18634c026eeba286699b35a1e10d58c0b0ba4bf Author: Jérôme Gardou <jerome.gardou(a)reactos.org> AuthorDate: Thu Feb 18 10:24:53 2021 +0100 Commit: Jérôme Gardou <jerome.gardou(a)reactos.org> CommitDate: Thu Feb 18 10:24:53 2021 +0100 [NTOS:WMI] Be consistent about potential NULL pointer use --- ntoskrnl/wmi/wmi.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/ntoskrnl/wmi/wmi.c b/ntoskrnl/wmi/wmi.c index 7d6d2bb21a8..1b6a70e923f 100644 --- a/ntoskrnl/wmi/wmi.c +++ b/ntoskrnl/wmi/wmi.c @@ -108,21 +108,26 @@ NTSTATUS NTAPI IoWMIWriteEvent(_Inout_ PVOID WnodeEventItem) { - DPRINT1("IoWMIWriteEvent() called for WnodeEventItem %p (Flags = 0x%08lx), returning success\n", - WnodeEventItem, ((PWNODE_HEADER)WnodeEventItem)->Flags); + PWNODE_HEADER Header = WnodeEventItem; - if (((PWNODE_HEADER)WnodeEventItem)->Flags & WNODE_FLAG_TRACED_GUID) + if(!Header) { - DPRINT("IoWMIWriteEvent(): Flags has WNODE_FLAG_TRACED_GUID\n"); + DPRINT1("Got NULL Item!\n"); + return STATUS_INVALID_PARAMETER; + } - // Never free WnodeEventItem in this case. + DPRINT1("IoWMIWriteEvent() called for WnodeEventItem %p (Flags = 0x%08lx), returning success\n", + WnodeEventItem, Header->Flags); + if (Header->Flags & WNODE_FLAG_TRACED_GUID) + { + // Never free WnodeEventItem in this case. + DPRINT("IoWMIWriteEvent(): Flags has WNODE_FLAG_TRACED_GUID\n"); return STATUS_SUCCESS; } /* Free the buffer if we are returning success */ - if (WnodeEventItem != NULL) - ExFreePool(WnodeEventItem); + ExFreePool(WnodeEventItem); return STATUS_SUCCESS; } @@ -402,7 +407,7 @@ WmiStartTrace(IN OUT PWMI_LOGGER_INFORMATION LoggerInfo) UNIMPLEMENTED; return STATUS_NOT_IMPLEMENTED; } - + NTSTATUS NTAPI WmiStopTrace(IN PWMI_LOGGER_INFORMATION LoggerInfo)

3 years, 10 months

[reactos] 02/02: [NTOS:WMI] IoWMIWriteEvent(): Add WNODE_FLAG_TRACED_GUID case

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=17a9041da14ca47494ff0… commit 17a9041da14ca47494ff02d0fe49fe315a8e6a5d Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Wed Sep 9 03:46:56 2020 +0200 Commit: Jérôme Gardou <zefklop(a)users.noreply.github.com> CommitDate: Wed Feb 17 18:59:09 2021 +0100 [NTOS:WMI] IoWMIWriteEvent(): Add WNODE_FLAG_TRACED_GUID case Addendum to d5f8964 (r23040). CORE-17384 --- ntoskrnl/wmi/wmi.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/ntoskrnl/wmi/wmi.c b/ntoskrnl/wmi/wmi.c index b27e134f811..7d6d2bb21a8 100644 --- a/ntoskrnl/wmi/wmi.c +++ b/ntoskrnl/wmi/wmi.c @@ -111,6 +111,15 @@ IoWMIWriteEvent(_Inout_ PVOID WnodeEventItem) DPRINT1("IoWMIWriteEvent() called for WnodeEventItem %p (Flags = 0x%08lx), returning success\n", WnodeEventItem, ((PWNODE_HEADER)WnodeEventItem)->Flags); + if (((PWNODE_HEADER)WnodeEventItem)->Flags & WNODE_FLAG_TRACED_GUID) + { + DPRINT("IoWMIWriteEvent(): Flags has WNODE_FLAG_TRACED_GUID\n"); + + // Never free WnodeEventItem in this case. + + return STATUS_SUCCESS; + } + /* Free the buffer if we are returning success */ if (WnodeEventItem != NULL) ExFreePool(WnodeEventItem);

3 years, 10 months

[reactos] 01/02: [NTOS:WMI] IoWMIWriteEvent(): Fix annotation, Extend DPRINT1()

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=495e22e0d5b38ee0bcd16… commit 495e22e0d5b38ee0bcd16b3556c272604795dd09 Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Wed Sep 9 03:46:56 2020 +0200 Commit: Jérôme Gardou <zefklop(a)users.noreply.github.com> CommitDate: Wed Feb 17 18:59:09 2021 +0100 [NTOS:WMI] IoWMIWriteEvent(): Fix annotation, Extend DPRINT1() CORE-17384 --- ntoskrnl/wmi/wmi.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ntoskrnl/wmi/wmi.c b/ntoskrnl/wmi/wmi.c index 58547b6d419..b27e134f811 100644 --- a/ntoskrnl/wmi/wmi.c +++ b/ntoskrnl/wmi/wmi.c @@ -106,10 +106,10 @@ IoWMISuggestInstanceName(IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL, */ NTSTATUS NTAPI -IoWMIWriteEvent(IN PVOID WnodeEventItem) +IoWMIWriteEvent(_Inout_ PVOID WnodeEventItem) { - DPRINT1("IoWMIWriteEvent() called for WnodeEventItem %p, returning success\n", - WnodeEventItem); + DPRINT1("IoWMIWriteEvent() called for WnodeEventItem %p (Flags = 0x%08lx), returning success\n", + WnodeEventItem, ((PWNODE_HEADER)WnodeEventItem)->Flags); /* Free the buffer if we are returning success */ if (WnodeEventItem != NULL)

3 years, 10 months

← Newer
1
2
3
4
5
6
7
...
44
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs February 2021