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]
