[blight] 19008: Implement (Int)EngAlphaBlend and 8, 16, 24 and 32 bpp DIB AlphaBlend functions. AlphaBlend() should work now.
Implement (Int)EngAlphaBlend and 8, 16, 24 and 32 bpp DIB AlphaBlend functions. AlphaBlend() should work now. Modified: trunk/reactos/subsys/win32k/dib/dib.c Modified: trunk/reactos/subsys/win32k/dib/dib.h Modified: trunk/reactos/subsys/win32k/dib/dib16bpp.c Modified: trunk/reactos/subsys/win32k/dib/dib1bpp.c Modified: trunk/reactos/subsys/win32k/dib/dib24bpp.c Modified: trunk/reactos/subsys/win32k/dib/dib32bpp.c Modified: trunk/reactos/subsys/win32k/dib/dib4bpp.c Modified: trunk/reactos/subsys/win32k/dib/dib8bpp.c Modified: trunk/reactos/subsys/win32k/eng/bitblt.c Modified: trunk/reactos/subsys/win32k/eng/xlate.c Modified: trunk/reactos/subsys/win32k/include/inteng.h Modified: trunk/reactos/subsys/win32k/objects/bitmaps.c Modified: trunk/reactos/subsys/win32k/stubs/xpstubs.c _____
Modified: trunk/reactos/subsys/win32k/dib/dib.c --- trunk/reactos/subsys/win32k/dib/dib.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -33,63 +33,68 @@
/* 0 */ { Dummy_PutPixel, Dummy_GetPixel, Dummy_HLine, Dummy_VLine, - Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt + Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, + Dummy_ColorFill, Dummy_AlphaBlend }, /* BMF_1BPP */ { DIB_1BPP_PutPixel, DIB_1BPP_GetPixel, DIB_1BPP_HLine, DIB_1BPP_VLine, DIB_1BPP_BitBlt, DIB_1BPP_BitBltSrcCopy, DIB_1BPP_StretchBlt, - DIB_1BPP_TransparentBlt, DIB_1BPP_ColorFill + DIB_1BPP_TransparentBlt, DIB_1BPP_ColorFill, DIB_1BPP_AlphaBlend }, /* BMF_4BPP */ { DIB_4BPP_PutPixel, DIB_4BPP_GetPixel, DIB_4BPP_HLine, DIB_4BPP_VLine, DIB_4BPP_BitBlt, DIB_4BPP_BitBltSrcCopy, DIB_4BPP_StretchBlt, - DIB_4BPP_TransparentBlt, DIB_4BPP_ColorFill + DIB_4BPP_TransparentBlt, DIB_4BPP_ColorFill, DIB_4BPP_AlphaBlend }, /* BMF_8BPP */ { DIB_8BPP_PutPixel, DIB_8BPP_GetPixel, DIB_8BPP_HLine, DIB_8BPP_VLine, DIB_8BPP_BitBlt, DIB_8BPP_BitBltSrcCopy, DIB_8BPP_StretchBlt, - DIB_8BPP_TransparentBlt, DIB_8BPP_ColorFill + DIB_8BPP_TransparentBlt, DIB_8BPP_ColorFill, DIB_8BPP_AlphaBlend }, /* BMF_16BPP */ { DIB_16BPP_PutPixel, DIB_16BPP_GetPixel, DIB_16BPP_HLine, DIB_16BPP_VLine, DIB_16BPP_BitBlt, DIB_16BPP_BitBltSrcCopy, DIB_16BPP_StretchBlt, - DIB_16BPP_TransparentBlt, DIB_16BPP_ColorFill + DIB_16BPP_TransparentBlt, DIB_16BPP_ColorFill, DIB_16BPP_AlphaBlend }, /* BMF_24BPP */ { DIB_24BPP_PutPixel, DIB_24BPP_GetPixel, DIB_24BPP_HLine, DIB_24BPP_VLine, DIB_24BPP_BitBlt, DIB_24BPP_BitBltSrcCopy, DIB_24BPP_StretchBlt, - DIB_24BPP_TransparentBlt, DIB_24BPP_ColorFill + DIB_24BPP_TransparentBlt, DIB_24BPP_ColorFill, DIB_24BPP_AlphaBlend }, /* BMF_32BPP */ { DIB_32BPP_PutPixel, DIB_32BPP_GetPixel, DIB_32BPP_HLine, DIB_32BPP_VLine, DIB_32BPP_BitBlt, DIB_32BPP_BitBltSrcCopy, DIB_32BPP_StretchBlt, - DIB_32BPP_TransparentBlt, DIB_32BPP_ColorFill + DIB_32BPP_TransparentBlt, DIB_32BPP_ColorFill, DIB_32BPP_AlphaBlend }, /* BMF_4RLE */ { Dummy_PutPixel, Dummy_GetPixel, Dummy_HLine, Dummy_VLine, - Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, Dummy_ColorFill + Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, + Dummy_ColorFill, Dummy_AlphaBlend }, /* BMF_8RLE */ { Dummy_PutPixel, Dummy_GetPixel, Dummy_HLine, Dummy_VLine, - Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, Dummy_ColorFill + Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, + Dummy_ColorFill, Dummy_AlphaBlend }, /* BMF_JPEG */ { Dummy_PutPixel, Dummy_GetPixel, Dummy_HLine, Dummy_VLine, - Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, Dummy_ColorFill + Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, + Dummy_ColorFill, Dummy_AlphaBlend }, /* BMF_PNG */ { Dummy_PutPixel, Dummy_GetPixel, Dummy_HLine, Dummy_VLine, - Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, Dummy_ColorFill + Dummy_BitBlt, Dummy_BitBlt, Dummy_StretchBlt, Dummy_TransparentBlt, + Dummy_ColorFill, Dummy_AlphaBlend } };
@@ -240,4 +245,12 @@ }
+BOOLEAN +Dummy_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, + RECTL* SourceRect, CLIPOBJ* ClipRegion, + XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj) +{ + return FALSE; +} + /* EOF */ _____
Modified: trunk/reactos/subsys/win32k/dib/dib.h --- trunk/reactos/subsys/win32k/dib/dib.h 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib.h 2005-11-04 23:37:06 UTC (rev 19008) @@ -44,6 +44,7 @@
typedef BOOLEAN (*PFN_DIB_StretchBlt)(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLI POBJ*,XLATEOBJ*,ULONG); typedef BOOLEAN (*PFN_DIB_TransparentBlt)(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULO NG); typedef BOOLEAN (*PFN_DIB_ColorFill)(SURFOBJ*, RECTL*, ULONG); +typedef BOOLEAN (*PFN_DIB_AlphaBlend)(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
typedef struct { @@ -56,6 +57,7 @@ PFN_DIB_StretchBlt DIB_StretchBlt; PFN_DIB_TransparentBlt DIB_TransparentBlt; PFN_DIB_ColorFill DIB_ColorFill; + PFN_DIB_AlphaBlend DIB_AlphaBlend; } DIB_FUNCTIONS;
extern DIB_FUNCTIONS DibFunctionsForBitmapFormat[]; @@ -68,6 +70,7 @@ BOOLEAN Dummy_StretchBlt(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLIPOBJ* ,XLATEOBJ*,ULONG); BOOLEAN Dummy_TransparentBlt(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULONG); BOOLEAN Dummy_ColorFill(SURFOBJ*, RECTL*, ULONG); +BOOLEAN Dummy_AlphaBlend(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
VOID DIB_1BPP_PutPixel(SURFOBJ*,LONG,LONG,ULONG); ULONG DIB_1BPP_GetPixel(SURFOBJ*,LONG,LONG); @@ -78,6 +81,7 @@ BOOLEAN DIB_1BPP_StretchBlt(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLIPO BJ*,XLATEOBJ*,ULONG); BOOLEAN DIB_1BPP_TransparentBlt(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULONG ); BOOLEAN DIB_1BPP_ColorFill(SURFOBJ*, RECTL*, ULONG); +BOOLEAN DIB_1BPP_AlphaBlend(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
VOID DIB_4BPP_PutPixel(SURFOBJ*,LONG,LONG,ULONG); ULONG DIB_4BPP_GetPixel(SURFOBJ*,LONG,LONG); @@ -88,6 +92,7 @@ BOOLEAN DIB_4BPP_StretchBlt(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLIPO BJ*,XLATEOBJ*,ULONG); BOOLEAN DIB_4BPP_TransparentBlt(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULONG ); BOOLEAN DIB_4BPP_ColorFill(SURFOBJ*, RECTL*, ULONG); +BOOLEAN DIB_4BPP_AlphaBlend(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
VOID DIB_8BPP_PutPixel(SURFOBJ*,LONG,LONG,ULONG); ULONG DIB_8BPP_GetPixel(SURFOBJ*,LONG,LONG); @@ -98,6 +103,7 @@ BOOLEAN DIB_8BPP_StretchBlt(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLIPO BJ*,XLATEOBJ*,ULONG); BOOLEAN DIB_8BPP_TransparentBlt(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULONG ); BOOLEAN DIB_8BPP_ColorFill(SURFOBJ*, RECTL*, ULONG); +BOOLEAN DIB_8BPP_AlphaBlend(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
VOID DIB_16BPP_PutPixel(SURFOBJ*,LONG,LONG,ULONG); ULONG DIB_16BPP_GetPixel(SURFOBJ*,LONG,LONG); @@ -108,6 +114,7 @@ BOOLEAN DIB_16BPP_StretchBlt(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLIP OBJ*,XLATEOBJ*,ULONG); BOOLEAN DIB_16BPP_TransparentBlt(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULON G); BOOLEAN DIB_16BPP_ColorFill(SURFOBJ*, RECTL*, ULONG); +BOOLEAN DIB_16BPP_AlphaBlend(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
VOID DIB_24BPP_PutPixel(SURFOBJ*,LONG,LONG,ULONG); ULONG DIB_24BPP_GetPixel(SURFOBJ*,LONG,LONG); @@ -118,6 +125,7 @@ BOOLEAN DIB_24BPP_StretchBlt(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLIP OBJ*,XLATEOBJ*,ULONG); BOOLEAN DIB_24BPP_TransparentBlt(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULON G); BOOLEAN DIB_24BPP_ColorFill(SURFOBJ*, RECTL*, ULONG); +BOOLEAN DIB_24BPP_AlphaBlend(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
VOID DIB_32BPP_PutPixel(SURFOBJ*,LONG,LONG,ULONG); ULONG DIB_32BPP_GetPixel(SURFOBJ*,LONG,LONG); @@ -128,6 +136,7 @@ BOOLEAN DIB_32BPP_StretchBlt(SURFOBJ*,SURFOBJ*,RECTL*,RECTL*,POINTL*,POINTL,CLIP OBJ*,XLATEOBJ*,ULONG); BOOLEAN DIB_32BPP_TransparentBlt(SURFOBJ*,SURFOBJ*,RECTL*,POINTL*,XLATEOBJ*,ULON G); BOOLEAN DIB_32BPP_ColorFill(SURFOBJ*, RECTL*, ULONG); +BOOLEAN DIB_32BPP_AlphaBlend(SURFOBJ*, SURFOBJ*, RECTL*, RECTL*, CLIPOBJ*, XLATEOBJ*, BLENDOBJ*);
extern unsigned char notmask[2]; extern unsigned char altnotmask[2]; _____
Modified: trunk/reactos/subsys/win32k/dib/dib16bpp.c --- trunk/reactos/subsys/win32k/dib/dib16bpp.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib16bpp.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -1358,4 +1358,123 @@
return TRUE; }
+typedef union { + ULONG ul; + struct { + UCHAR red; + UCHAR green; + UCHAR blue; + UCHAR alpha; + } col; +} NICEPIXEL32; + +typedef union { + USHORT us; + struct { + USHORT red:5, + green:6, + blue:5; + } col; +} NICEPIXEL16; + +STATIC inline UCHAR +Clamp5(ULONG val) +{ + return (val > 31) ? 31 : val; +} + +STATIC inline UCHAR +Clamp6(ULONG val) +{ + return (val > 63) ? 63 : val; +} + +BOOLEAN +DIB_16BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, + RECTL* SourceRect, CLIPOBJ* ClipRegion, + XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj) +{ + INT Rows, Cols, SrcX, SrcY; + register PUSHORT Dst; + ULONG DstDelta; + BLENDFUNCTION BlendFunc; + register NICEPIXEL16 DstPixel; + register NICEPIXEL32 SrcPixel; + UCHAR Alpha, SrcBpp; + + DPRINT("DIB_16BPP_AlphaBlend: srcRect: (%d,%d)-(%d,%d), dstRect: (%d,%d)-(%d,%d)\n", + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + + ASSERT(DestRect->bottom - DestRect->top == SourceRect->bottom - SourceRect->top && + DestRect->right - DestRect->left == SourceRect->right - SourceRect->left); + + BlendFunc = BlendObj->BlendFunction; + if (BlendFunc.BlendOp != AC_SRC_OVER) + { + DPRINT1("BlendOp != AC_SRC_OVER\n"); + return FALSE; + } + if (BlendFunc.BlendFlags != 0) + { + DPRINT1("BlendFlags != 0\n"); + return FALSE; + } + if ((BlendFunc.AlphaFormat & ~AC_SRC_ALPHA) != 0) + { + DPRINT1("Unsupported AlphaFormat (0x%x)\n", BlendFunc.AlphaFormat); + return FALSE; + } + if ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0 && + BitsPerFormat(Source->iBitmapFormat) != 32) + { + DPRINT1("Source bitmap must be 32bpp when AC_SRC_ALPHA is set\n"); + return FALSE; + } + + Dst = (PUSHORT)((ULONG_PTR)Dest->pvScan0 + (DestRect->top * Dest->lDelta) + + (DestRect->left << 1)); + DstDelta = Dest->lDelta - ((DestRect->right - DestRect->left) << 1); + SrcBpp = BitsPerFormat(Source->iBitmapFormat); + + Rows = DestRect->bottom - DestRect->top; + SrcY = SourceRect->top; + while (--Rows >= 0) + { + Cols = DestRect->right - DestRect->left; + SrcX = SourceRect->left; + while (--Cols >= 0) + { + if (SrcBpp <= 16) + { + DstPixel.us = DIB_GetSource(Source, SrcX++, SrcY, ColorTranslation); + SrcPixel.col.red = (DstPixel.col.red << 3) | (DstPixel.col.red >> 2); + SrcPixel.col.green = (DstPixel.col.green << 2) | (DstPixel.col.green >> 4); + SrcPixel.col.blue = (DstPixel.col.blue << 3) | (DstPixel.col.blue >> 2); + } + else + { + SrcPixel.ul = DIB_GetSourceIndex(Source, SrcX++, SrcY); + } + SrcPixel.col.red = SrcPixel.col.red * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.green = SrcPixel.col.green * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.blue = SrcPixel.col.blue * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.alpha = (SrcBpp == 32) ? (SrcPixel.col.alpha * BlendFunc.SourceConstantAlpha / 255) : BlendFunc.SourceConstantAlpha; + + Alpha = ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0) ? + SrcPixel.col.alpha : BlendFunc.SourceConstantAlpha; + + DstPixel.us = *Dst; + DstPixel.col.red = Clamp5(DstPixel.col.red * (255 - Alpha) / 255 + (SrcPixel.col.red >> 3)); + DstPixel.col.green = Clamp6(DstPixel.col.green * (255 - Alpha) / 255 + (SrcPixel.col.green >> 2)); + DstPixel.col.blue = Clamp5(DstPixel.col.blue * (255 - Alpha) / 255 + (SrcPixel.col.blue >> 3)); + *Dst++ = DstPixel.us; + } + Dst = (PUSHORT)((ULONG_PTR)Dst + DstDelta); + SrcY++; + } + + return TRUE; +} + /* EOF */ _____
Modified: trunk/reactos/subsys/win32k/dib/dib1bpp.c --- trunk/reactos/subsys/win32k/dib/dib1bpp.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib1bpp.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -1303,4 +1303,13 @@
return FALSE; }
+BOOLEAN +DIB_1BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, + RECTL* SourceRect, CLIPOBJ* ClipRegion, + XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj) +{ + UNIMPLEMENTED; + return FALSE; +} + /* EOF */ _____
Modified: trunk/reactos/subsys/win32k/dib/dib24bpp.c --- trunk/reactos/subsys/win32k/dib/dib24bpp.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib24bpp.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -1331,4 +1331,98 @@
return TRUE; }
+typedef union { + ULONG ul; + struct { + UCHAR red; + UCHAR green; + UCHAR blue; + UCHAR alpha; + } col; +} NICEPIXEL32; + +STATIC inline UCHAR +Clamp8(ULONG val) +{ + return (val > 255) ? 255 : val; +} + +BOOLEAN +DIB_24BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, + RECTL* SourceRect, CLIPOBJ* ClipRegion, + XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj) +{ + INT Rows, Cols, SrcX, SrcY; + register PUCHAR Dst; + ULONG DstDelta; + BLENDFUNCTION BlendFunc; + register NICEPIXEL32 DstPixel, SrcPixel; + UCHAR Alpha, SrcBpp; + + DPRINT("DIB_24BPP_AlphaBlend: srcRect: (%d,%d)-(%d,%d), dstRect: (%d,%d)-(%d,%d)\n", + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + + ASSERT(DestRect->bottom - DestRect->top == SourceRect->bottom - SourceRect->top && + DestRect->right - DestRect->left == SourceRect->right - SourceRect->left); + + BlendFunc = BlendObj->BlendFunction; + if (BlendFunc.BlendOp != AC_SRC_OVER) + { + DPRINT1("BlendOp != AC_SRC_OVER\n"); + return FALSE; + } + if (BlendFunc.BlendFlags != 0) + { + DPRINT1("BlendFlags != 0\n"); + return FALSE; + } + if ((BlendFunc.AlphaFormat & ~AC_SRC_ALPHA) != 0) + { + DPRINT1("Unsupported AlphaFormat (0x%x)\n", BlendFunc.AlphaFormat); + return FALSE; + } + if ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0 && + BitsPerFormat(Source->iBitmapFormat) != 32) + { + DPRINT1("Source bitmap must be 32bpp when AC_SRC_ALPHA is set\n"); + return FALSE; + } + + Dst = (PUCHAR)((ULONG_PTR)Dest->pvScan0 + (DestRect->top * Dest->lDelta) + + (DestRect->left * 3)); + DstDelta = Dest->lDelta - ((DestRect->right - DestRect->left) * 3); + SrcBpp = BitsPerFormat(Source->iBitmapFormat); + + Rows = DestRect->bottom - DestRect->top; + SrcY = SourceRect->top; + while (--Rows >= 0) + { + Cols = DestRect->right - DestRect->left; + SrcX = SourceRect->left; + while (--Cols >= 0) + { + SrcPixel.ul = DIB_GetSource(Source, SrcX++, SrcY, ColorTranslation); + SrcPixel.col.red = SrcPixel.col.red * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.green = SrcPixel.col.green * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.blue = SrcPixel.col.blue * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.alpha = (SrcBpp == 32) ? (SrcPixel.col.alpha * BlendFunc.SourceConstantAlpha / 255) : BlendFunc.SourceConstantAlpha; + + Alpha = ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0) ? + SrcPixel.col.alpha : BlendFunc.SourceConstantAlpha; + + DstPixel.ul = *Dst; + DstPixel.col.red = Clamp8(DstPixel.col.red * (255 - Alpha) / 255 + SrcPixel.col.red); + DstPixel.col.green = Clamp8(DstPixel.col.green * (255 - Alpha) / 255 + SrcPixel.col.green); + DstPixel.col.blue = Clamp8(DstPixel.col.blue * (255 - Alpha) / 255 + SrcPixel.col.blue); + *Dst = DstPixel.ul; + Dst = (PUCHAR)((ULONG_PTR)Dst + 3); + } + Dst = (PUCHAR)((ULONG_PTR)Dst + DstDelta); + SrcY++; + } + + return TRUE; +} + /* EOF */ _____
Modified: trunk/reactos/subsys/win32k/dib/dib32bpp.c --- trunk/reactos/subsys/win32k/dib/dib32bpp.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib32bpp.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -1256,4 +1256,98 @@
return TRUE; }
+typedef union { + ULONG ul; + struct { + UCHAR red; + UCHAR green; + UCHAR blue; + UCHAR alpha; + } col; +} NICEPIXEL32; + +STATIC inline UCHAR +Clamp8(ULONG val) +{ + return (val > 255) ? 255 : val; +} + +BOOLEAN +DIB_32BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, + RECTL* SourceRect, CLIPOBJ* ClipRegion, + XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj) +{ + INT Rows, Cols, SrcX, SrcY; + register PULONG Dst; + ULONG DstDelta; + BLENDFUNCTION BlendFunc; + register NICEPIXEL32 DstPixel, SrcPixel; + UCHAR Alpha, SrcBpp; + + DPRINT("DIB_32BPP_AlphaBlend: srcRect: (%d,%d)-(%d,%d), dstRect: (%d,%d)-(%d,%d)\n", + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + + ASSERT(DestRect->bottom - DestRect->top == SourceRect->bottom - SourceRect->top && + DestRect->right - DestRect->left == SourceRect->right - SourceRect->left); + + BlendFunc = BlendObj->BlendFunction; + if (BlendFunc.BlendOp != AC_SRC_OVER) + { + DPRINT1("BlendOp != AC_SRC_OVER\n"); + return FALSE; + } + if (BlendFunc.BlendFlags != 0) + { + DPRINT1("BlendFlags != 0\n"); + return FALSE; + } + if ((BlendFunc.AlphaFormat & ~AC_SRC_ALPHA) != 0) + { + DPRINT1("Unsupported AlphaFormat (0x%x)\n", BlendFunc.AlphaFormat); + return FALSE; + } + if ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0 && + BitsPerFormat(Source->iBitmapFormat) != 32) + { + DPRINT1("Source bitmap must be 32bpp when AC_SRC_ALPHA is set\n"); + return FALSE; + } + + Dst = (PULONG)((ULONG_PTR)Dest->pvScan0 + (DestRect->top * Dest->lDelta) + + (DestRect->left << 2)); + DstDelta = Dest->lDelta - ((DestRect->right - DestRect->left) << 2); + SrcBpp = BitsPerFormat(Source->iBitmapFormat); + + Rows = DestRect->bottom - DestRect->top; + SrcY = SourceRect->top; + while (--Rows >= 0) + { + Cols = DestRect->right - DestRect->left; + SrcX = SourceRect->left; + while (--Cols >= 0) + { + SrcPixel.ul = DIB_GetSource(Source, SrcX++, SrcY, ColorTranslation); + SrcPixel.col.red = SrcPixel.col.red * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.green = SrcPixel.col.green * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.blue = SrcPixel.col.blue * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.alpha = (SrcBpp == 32) ? (SrcPixel.col.alpha * BlendFunc.SourceConstantAlpha / 255) : BlendFunc.SourceConstantAlpha; + + Alpha = ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0) ? + SrcPixel.col.alpha : BlendFunc.SourceConstantAlpha; + + DstPixel.ul = *Dst; + DstPixel.col.red = Clamp8(DstPixel.col.red * (255 - Alpha) / 255 + SrcPixel.col.red); + DstPixel.col.green = Clamp8(DstPixel.col.green * (255 - Alpha) / 255 + SrcPixel.col.green); + DstPixel.col.blue = Clamp8(DstPixel.col.blue * (255 - Alpha) / 255 + SrcPixel.col.blue); + DstPixel.col.alpha = Clamp8(DstPixel.col.alpha * (255 - Alpha) / 255 + SrcPixel.col.alpha); + *Dst++ = DstPixel.ul; + } + Dst = (PULONG)((ULONG_PTR)Dst + DstDelta); + SrcY++; + } + + return TRUE; +} + /* EOF */ _____
Modified: trunk/reactos/subsys/win32k/dib/dib4bpp.c --- trunk/reactos/subsys/win32k/dib/dib4bpp.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib4bpp.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -1189,4 +1189,13 @@
return FALSE; }
+BOOLEAN +DIB_4BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, + RECTL* SourceRect, CLIPOBJ* ClipRegion, + XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj) +{ + UNIMPLEMENTED; + return FALSE; +} + /* EOF */ _____
Modified: trunk/reactos/subsys/win32k/dib/dib8bpp.c --- trunk/reactos/subsys/win32k/dib/dib8bpp.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/dib/dib8bpp.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -1217,4 +1217,162 @@
return TRUE; }
+typedef union { + ULONG ul; + struct { + UCHAR red; + UCHAR green; + UCHAR blue; + UCHAR alpha; + } col; +} NICEPIXEL32; + +typedef union { + USHORT us; + struct { + USHORT red:5, + green:6, + blue:5; + } col; +} NICEPIXEL16; + +STATIC inline UCHAR +Clamp8(ULONG val) +{ + return (val > 255) ? 255 : val; +} + +BOOLEAN +DIB_8BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect, + RECTL* SourceRect, CLIPOBJ* ClipRegion, + XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj) +{ + INT Rows, Cols, SrcX, SrcY; + register PUCHAR Dst; + ULONG DstDelta; + BLENDFUNCTION BlendFunc; + register NICEPIXEL32 DstPixel; + register NICEPIXEL32 SrcPixel; + register NICEPIXEL16 SrcPixel16; + UCHAR Alpha, SrcBpp; + HPALETTE SrcPalette, DstPalette; + XLATEOBJ *SrcTo32Xlate, *DstTo32Xlate, *DstFrom32Xlate; + + DPRINT("DIB_8BPP_AlphaBlend: srcRect: (%d,%d)-(%d,%d), dstRect: (%d,%d)-(%d,%d)\n", + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom, + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + + ASSERT(DestRect->bottom - DestRect->top == SourceRect->bottom - SourceRect->top && + DestRect->right - DestRect->left == SourceRect->right - SourceRect->left); + + BlendFunc = BlendObj->BlendFunction; + if (BlendFunc.BlendOp != AC_SRC_OVER) + { + DPRINT1("BlendOp != AC_SRC_OVER\n"); + return FALSE; + } + if (BlendFunc.BlendFlags != 0) + { + DPRINT1("BlendFlags != 0\n"); + return FALSE; + } + if ((BlendFunc.AlphaFormat & ~AC_SRC_ALPHA) != 0) + { + DPRINT1("Unsupported AlphaFormat (0x%x)\n", BlendFunc.AlphaFormat); + return FALSE; + } + if ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0 && + BitsPerFormat(Source->iBitmapFormat) != 32) + { + DPRINT1("Source bitmap must be 32bpp when AC_SRC_ALPHA is set\n"); + return FALSE; + } + + SrcBpp = BitsPerFormat(Source->iBitmapFormat); + SrcPalette = IntEngGetXlatePalette(ColorTranslation, XO_SRCPALETTE); + if (SrcPalette != 0) + { + SrcTo32Xlate = IntEngCreateXlate(PAL_RGB, 0, NULL, SrcPalette); + if (SrcTo32Xlate == NULL) + { + DPRINT1("IntEngCreateXlate failed\n"); + return FALSE; + } + } + else + { + SrcTo32Xlate = NULL; + ASSERT(SrcBpp >= 16); + } + + DstPalette = IntEngGetXlatePalette(ColorTranslation, XO_DESTPALETTE); + DstTo32Xlate = IntEngCreateXlate(PAL_RGB, 0, NULL, DstPalette); + DstFrom32Xlate = IntEngCreateXlate(0, PAL_RGB, DstPalette, NULL); + if (DstTo32Xlate == NULL || DstFrom32Xlate == NULL) + { + if (SrcTo32Xlate != NULL) + EngDeleteXlate(SrcTo32Xlate); + if (DstTo32Xlate != NULL) + EngDeleteXlate(DstTo32Xlate); + if (DstFrom32Xlate != NULL) + EngDeleteXlate(DstFrom32Xlate); + DPRINT1("IntEngCreateXlate failed\n"); + return FALSE; + } + + Dst = (PUCHAR)((ULONG_PTR)Dest->pvScan0 + (DestRect->top * Dest->lDelta) + + DestRect->left); + DstDelta = Dest->lDelta - (DestRect->right - DestRect->left); + + Rows = DestRect->bottom - DestRect->top; + SrcY = SourceRect->top; + while (--Rows >= 0) + { + Cols = DestRect->right - DestRect->left; + SrcX = SourceRect->left; + while (--Cols >= 0) + { + if (SrcTo32Xlate != NULL) + { + SrcPixel.ul = DIB_GetSource(Source, SrcX++, SrcY, SrcTo32Xlate); + } + else if (SrcBpp <= 16) + { + SrcPixel16.us = DIB_GetSource(Source, SrcX++, SrcY, ColorTranslation); + SrcPixel.col.red = (SrcPixel16.col.red << 3) | (SrcPixel16.col.red >> 2); + SrcPixel.col.green = (SrcPixel16.col.green << 2) | (SrcPixel16.col.green >> 4); + SrcPixel.col.blue = (SrcPixel16.col.blue << 3) | (SrcPixel16.col.blue >> 2); + } + else + { + SrcPixel.ul = DIB_GetSourceIndex(Source, SrcX++, SrcY); + } + SrcPixel.col.red = SrcPixel.col.red * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.green = SrcPixel.col.green * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.blue = SrcPixel.col.blue * BlendFunc.SourceConstantAlpha / 255; + SrcPixel.col.alpha = (SrcBpp == 32) ? (SrcPixel.col.alpha * BlendFunc.SourceConstantAlpha / 255) : BlendFunc.SourceConstantAlpha; + + Alpha = ((BlendFunc.AlphaFormat & AC_SRC_ALPHA) != 0) ? + SrcPixel.col.alpha : BlendFunc.SourceConstantAlpha; + + DstPixel.ul = XLATEOBJ_iXlate(DstTo32Xlate, *Dst); + DstPixel.col.red = Clamp8(DstPixel.col.red * (255 - Alpha) / 255 + SrcPixel.col.red); + DstPixel.col.green = Clamp8(DstPixel.col.green * (255 - Alpha) / 255 + SrcPixel.col.green); + DstPixel.col.blue = Clamp8(DstPixel.col.blue * (255 - Alpha) / 255 + SrcPixel.col.blue); + *Dst++ = XLATEOBJ_iXlate(DstFrom32Xlate, DstPixel.ul); + } + Dst = (PUCHAR)((ULONG_PTR)Dst + DstDelta); + SrcY++; + } + + if (SrcTo32Xlate != NULL) + EngDeleteXlate(SrcTo32Xlate); + if (DstTo32Xlate != NULL) + EngDeleteXlate(DstTo32Xlate); + if (DstFrom32Xlate != NULL) + EngDeleteXlate(DstFrom32Xlate); + + return TRUE; +} + /* EOF */ _____
Modified: trunk/reactos/subsys/win32k/eng/bitblt.c --- trunk/reactos/subsys/win32k/eng/bitblt.c 2005-11-04 23:25:03 UTC (rev 19007) +++ trunk/reactos/subsys/win32k/eng/bitblt.c 2005-11-04 23:37:06 UTC (rev 19008) @@ -889,60 +889,320 @@
return ret; }
+BOOL +STDCALL +EngAlphaBlend(IN SURFOBJ *Dest, + IN SURFOBJ *Source, + IN CLIPOBJ *ClipRegion, + IN XLATEOBJ *ColorTranslation, + IN PRECTL DestRect, + IN PRECTL SourceRect, + IN BLENDOBJ *BlendObj) +{ + RECTL SourceStretchedRect; + SIZEL SourceStretchedSize; + HBITMAP SourceStretchedBitmap = 0; + SURFOBJ* SourceStretchedObj = NULL; + RECTL InputRect; + RECTL OutputRect; + RECTL ClipRect; + RECTL CombinedRect; + RECTL Rect; + POINTL Translate; + INTENG_ENTER_LEAVE EnterLeaveSource; + INTENG_ENTER_LEAVE EnterLeaveDest; + SURFOBJ* InputObj; + SURFOBJ* OutputObj; + LONG Width; + LONG ClippingType; + RECT_ENUM RectEnum; + BOOL EnumMore; + INT i; + BOOLEAN Ret; + + DPRINT("EngAlphaBlend(Dest:0x%p, Source:0x%p, ClipRegion:0x%p, ColorTranslation:0x%p,\n", Dest, Source, ClipRegion, ColorTranslation); + DPRINT(" DestRect:{0x%x, 0x%x, 0x%x, 0x%x}, SourceRect:{0x%x, 0x%x, 0x%x, 0x%x},\n", + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom, + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom); + DPRINT(" BlendObj:{0x%x, 0x%x, 0x%x, 0x%x}\n", BlendObj->BlendFunction.BlendOp, + BlendObj->BlendFunction.BlendFlags, BlendObj->BlendFunction.SourceConstantAlpha, + BlendObj->BlendFunction.AlphaFormat); + + /* Validate input */ + if (DestRect->left >= DestRect->right || DestRect->top >= DestRect->bottom) + { + DPRINT1("Empty destination rectangle!\n"); + return FALSE; + } + if (SourceRect->left >= SourceRect->right || SourceRect->top >= SourceRect->bottom) + { + DPRINT1("Empty source rectangle!\n"); + return FALSE; + } + if (Dest == Source && + !(DestRect->left >= SourceRect->right || SourceRect->left >= DestRect->right || + DestRect->top >= SourceRect->bottom || SourceRect->top >= DestRect->bottom)) + { + DPRINT1("Source and destination rectangles overlap!\n"); + return FALSE; + } + + if (BlendObj->BlendFunction.BlendOp != AC_SRC_OVER) + { + DPRINT1("BlendOp != AC_SRC_OVER (0x%x)\n", BlendObj->BlendFunction.BlendOp); + return FALSE; + } + if (BlendObj->BlendFunction.BlendFlags != 0) + { + DPRINT1("BlendFlags != 0 (0x%x)\n", BlendObj->BlendFunction.BlendFlags); + return FALSE; + } + if ((BlendObj->BlendFunction.AlphaFormat & ~AC_SRC_ALPHA) != 0) + { + DPRINT1("Unsupported AlphaFormat (0x%x)\n", BlendObj->BlendFunction.AlphaFormat); + return FALSE; + } + + /* Check if there is anything to draw */ + if (ClipRegion != NULL && + (ClipRegion->rclBounds.left >= ClipRegion->rclBounds.right || + ClipRegion->rclBounds.top >= ClipRegion->rclBounds.bottom)) + { + /* Nothing to do */ + return TRUE; + } + + /* Stretch source if needed */ + if (DestRect->right - DestRect->left != SourceRect->right - SourceRect->left || + DestRect->bottom - DestRect->top != SourceRect->bottom - SourceRect->top) + { + SourceStretchedSize.cx = DestRect->right - DestRect->left; + SourceStretchedSize.cy = DestRect->bottom - DestRect->top; + Width = DIB_GetDIBWidthBytes(SourceStretchedSize.cx, BitsPerFormat(Source->iBitmapFormat)); + /* FIXME: Maybe it is a good idea to use EngCreateDeviceBitmap and IntEngStretchBlt + if possible to get a HW accelerated stretch. */ + SourceStretchedBitmap = EngCreateBitmap(SourceStretchedSize, Width, Source->iBitmapFormat, + BMF_TOPDOWN | BMF_NOZEROINIT, NULL); + if (SourceStretchedBitmap == 0) + { + DPRINT1("EngCreateBitmap failed!\n"); + return FALSE; + } + SourceStretchedObj = EngLockSurface((HSURF)SourceStretchedBitmap); + if (SourceStretchedObj == NULL) + { + DPRINT1("EngLockSurface failed!\n"); + EngDeleteSurface((HSURF)SourceStretchedBitmap); + return FALSE; + } + + SourceStretchedRect.left = 0; + SourceStretchedRect.right = SourceStretchedSize.cx; + SourceStretchedRect.top = 0; + SourceStretchedRect.bottom = SourceStretchedSize.cy; + /* FIXME: IntEngStretchBlt isn't used here atm because it results in a + try to acquire an already acquired mutex (lock the already locked source surface) */ + /*if (!IntEngStretchBlt(SourceStretchedObj, Source, NULL, NULL, + NULL, &SourceStretchedRect, SourceRect, NULL, + NULL, NULL, COLORONCOLOR))*/ + if (!EngStretchBlt(SourceStretchedObj, Source, NULL, NULL, NULL, + NULL, NULL, &SourceStretchedRect, SourceRect, + NULL, COLORONCOLOR)) + { + DPRINT1("EngStretchBlt failed!\n"); + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); + EngDeleteSurface((HSURF)SourceStretchedBitmap); + return FALSE; + } + SourceRect = &SourceStretchedRect; + Source = SourceStretchedObj; + } + + /* Now call the DIB function */ + InputRect.left = SourceRect->left; + InputRect.right = SourceRect->right; + InputRect.top = SourceRect->top; + InputRect.bottom = SourceRect->bottom; + if (!IntEngEnter(&EnterLeaveSource, Source, &InputRect, TRUE, &Translate, &InputObj)) + { + if (SourceStretchedObj != NULL) + { + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); + } + if (SourceStretchedBitmap != 0) + { + EngDeleteSurface((HSURF)SourceStretchedBitmap); + } + return FALSE; + } + InputRect.left = SourceRect->left + Translate.x; + InputRect.right = SourceRect->right + Translate.x; + InputRect.top = SourceRect->top + Translate.y; + InputRect.bottom = SourceRect->bottom + Translate.y; + + OutputRect.left = DestRect->left; + OutputRect.right = DestRect->right; + OutputRect.top = DestRect->top; + OutputRect.bottom = DestRect->bottom; + if (!IntEngEnter(&EnterLeaveDest, Dest, &OutputRect, FALSE, &Translate, &OutputObj)) + { + IntEngLeave(&EnterLeaveSource); + if (SourceStretchedObj != NULL) + { + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); + } + if (SourceStretchedBitmap != 0) + { + EngDeleteSurface((HSURF)SourceStretchedBitmap); + } + return FALSE; + } + OutputRect.left = DestRect->left + Translate.x; + OutputRect.right = DestRect->right + Translate.x; + OutputRect.top = DestRect->top + Translate.y; + OutputRect.bottom = DestRect->bottom + Translate.y; + + Ret = FALSE; + ClippingType = (ClipRegion == NULL) ? DC_TRIVIAL : ClipRegion->iDComplexity; + switch(ClippingType) + { + case DC_TRIVIAL: + Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( + OutputObj, InputObj, &OutputRect, &InputRect, ClipRegion, ColorTranslation, BlendObj); + break; + + case DC_RECT: + ClipRect.left = ClipRegion->rclBounds.left + Translate.x; + ClipRect.right = ClipRegion->rclBounds.right + Translate.x; + ClipRect.top = ClipRegion->rclBounds.top + Translate.y; + ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + { + Rect.left = InputRect.left + CombinedRect.left - OutputRect.left; + Rect.right = InputRect.right + CombinedRect.right - OutputRect.right; + Rect.top = InputRect.top + CombinedRect.top - OutputRect.top; + Rect.bottom = InputRect.bottom + CombinedRect.bottom - OutputRect.bottom; + Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( + OutputObj, InputObj, &CombinedRect, &Rect, ClipRegion, ColorTranslation, BlendObj); + } + break; + + case DC_COMPLEX: + Ret = TRUE; + CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, CD_ANY, 0); + do + { + EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), + (PVOID) &RectEnum); + + for (i = 0; i < RectEnum.c; i++) + { + ClipRect.left = RectEnum.arcl[i].left + Translate.x; + ClipRect.right = RectEnum.arcl[i].right + Translate.x; + ClipRect.top = RectEnum.arcl[i].top + Translate.y; + ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + { + Rect.left = InputRect.left + CombinedRect.left - OutputRect.left; + Rect.right = InputRect.right + CombinedRect.right - OutputRect.right; + Rect.top = InputRect.top + CombinedRect.top - OutputRect.top; + Rect.bottom = InputRect.bottom + CombinedRect.bottom - OutputRect.bottom; + Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( + OutputObj, InputObj, &CombinedRect, &Rect, ClipRegion, ColorTranslation, BlendObj) && Ret; + } + } + } + while(EnumMore); + break; + + default: + UNIMPLEMENTED; + ASSERT(FALSE); + break; + } + + IntEngLeave(&EnterLeaveDest); + IntEngLeave(&EnterLeaveSource); + + if (SourceStretchedObj != NULL) + { + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); + } + if (SourceStretchedBitmap != 0) + { + EngDeleteSurface((HSURF)SourceStretchedBitmap); + } + + return Ret; +} + BOOL STDCALL IntEngAlphaBlend(IN SURFOBJ *Dest, IN SURFOBJ *Source, - IN CLIPOBJ *Clip, + IN CLIPOBJ *ClipRegion, IN XLATEOBJ *ColorTranslation, IN PRECTL DestRect, IN PRECTL SourceRect, IN BLENDOBJ *BlendObj) { - BOOL ret = FALSE; - BITMAPOBJ *DestObj; - BITMAPOBJ *SourceObj; + BOOL ret = FALSE; + BITMAPOBJ *DestObj; + BITMAPOBJ *SourceObj;
- ASSERT(Dest); - DestObj = CONTAINING_RECORD(Dest, BITMAPOBJ, SurfObj); - ASSERT(DestObj); + ASSERT(Dest); + DestObj = CONTAINING_RECORD(Dest, BITMAPOBJ, SurfObj); + ASSERT(DestObj);
- ASSERT(Source); - SourceObj = CONTAINING_RECORD(Source, BITMAPOBJ, SurfObj); - ASSERT(SourceObj); + ASSERT(Source); + SourceObj = CONTAINING_RECORD(Source, BITMAPOBJ, SurfObj); + ASSERT(SourceObj);
[truncated at 1000 lines; 164 more skipped]
-
blight＠svn.reactos.com