* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: dib1bpp.c,v 1.27 2004/05/10 17:07:17 weiden Exp $ */
+/* $Id$ */
#include <w32k.h>
+#define NDEBUG
+#include <debug.h>
+
VOID
DIB_1BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
{
- PBYTE addr = SurfObj->pvScan0 + y * SurfObj->lDelta + (x >> 3);
+ PBYTE addr = (PBYTE)SurfObj->pvScan0 + y * SurfObj->lDelta + (x >> 3);
if (0 == (c & 0x01))
*addr &= ~MASK1BPP(x);
ULONG
DIB_1BPP_GetPixel(SURFOBJ *SurfObj, LONG x, LONG y)
{
- PBYTE addr = SurfObj->pvScan0 + y * SurfObj->lDelta + (x >> 3);
+ PBYTE addr = (PBYTE)SurfObj->pvScan0 + y * SurfObj->lDelta + (x >> 3);
return (*addr & MASK1BPP(x) ? 1 : 0);
}
// which direction are we going?
int xinc;
int yinc;
+ int ySrcDelta, yDstDelta;
// following 4 variables are used for the y-sweep
int dy; // dest y
dy2 = DestRect->bottom - 1;
sy1 = SourcePoint->y;
yinc = 1;
+ ySrcDelta = SourceSurf->lDelta;
+ yDstDelta = DestSurf->lDelta;
}
else
{
dy2 = DestRect->top;
sy1 = SourcePoint->y + dy1 - dy2;
yinc = -1;
+ ySrcDelta = -SourceSurf->lDelta;
+ yDstDelta = -DestSurf->lDelta;
}
if ( DestRect->left <= SourcePoint->x )
{
if ( dy == dy2 )
break;
dy += yinc;
- pd += yinc * DestSurf->lDelta;
- ps += yinc * SourceSurf->lDelta;
+ pd += yDstDelta;
+ ps += ySrcDelta;
}
}
else if ( !(0xFF00 & (srcmask<<shift) ) ) // check if ps[0] not needed...
if ( dy == dy2 )
break;
dy += yinc;
- pd += yinc * DestSurf->lDelta;
- ps += yinc * SourceSurf->lDelta;
+ pd += yDstDelta;
+ ps += ySrcDelta;
}
}
else if ( !(0xFF & (srcmask<<shift) ) ) // check if ps[1] not needed...
if ( dy == dy2 )
break;
dy += yinc;
- pd += yinc * DestSurf->lDelta;
- ps += yinc * SourceSurf->lDelta;
+ pd += yDstDelta;
+ ps += ySrcDelta;
}
}
else // both ps[0] and ps[1] are needed
if ( dy == dy2 )
break;
dy += yinc;
- pd += yinc * DestSurf->lDelta;
- ps += yinc * SourceSurf->lDelta;
+ pd += yDstDelta;
+ ps += ySrcDelta;
}
}
}
BOOLEAN
-DIB_1BPP_BitBltSrcCopy(
- SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
- SURFGDI *DestGDI, SURFGDI *SourceGDI,
- PRECTL DestRect, POINTL *SourcePoint,
- XLATEOBJ *ColorTranslation)
+DIB_1BPP_BitBltSrcCopy(PBLTINFO BltInfo)
{
- LONG i, j, sx, sy = SourcePoint->y;
+ LONG i, j, sx, sy = BltInfo->SourcePoint.y;
- switch ( SourceGDI->BitsPerPixel )
+ switch ( BltInfo->SourceSurface->iBitmapFormat )
{
- case 1:
- DIB_1BPP_BitBltSrcCopy_From1BPP ( DestSurf, SourceSurf, DestRect, SourcePoint );
+ case BMF_1BPP:
+ DIB_1BPP_BitBltSrcCopy_From1BPP ( BltInfo->DestSurface, BltInfo->SourceSurface, &BltInfo->DestRect, &BltInfo->SourcePoint );
break;
- case 4:
- for (j=DestRect->top; j<DestRect->bottom; j++)
+ case BMF_4BPP:
+ for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
{
- sx = SourcePoint->x;
- for (i=DestRect->left; i<DestRect->right; i++)
+ sx = BltInfo->SourcePoint.x;
+ for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
{
- if(XLATEOBJ_iXlate(ColorTranslation, DIB_4BPP_GetPixel(SourceSurf, sx, sy)) == 0)
+ if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
{
- DIB_1BPP_PutPixel(DestSurf, i, j, 0);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
} else {
- DIB_1BPP_PutPixel(DestSurf, i, j, 1);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
}
sx++;
}
}
break;
- case 8:
- for (j=DestRect->top; j<DestRect->bottom; j++)
+ case BMF_8BPP:
+ for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
{
- sx = SourcePoint->x;
- for (i=DestRect->left; i<DestRect->right; i++)
+ sx = BltInfo->SourcePoint.x;
+ for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
{
- if(XLATEOBJ_iXlate(ColorTranslation, DIB_8BPP_GetPixel(SourceSurf, sx, sy)) == 0)
+ if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_8BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
{
- DIB_1BPP_PutPixel(DestSurf, i, j, 0);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
} else {
- DIB_1BPP_PutPixel(DestSurf, i, j, 1);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
}
sx++;
}
}
break;
- case 16:
- for (j=DestRect->top; j<DestRect->bottom; j++)
+ case BMF_16BPP:
+ for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
{
- sx = SourcePoint->x;
- for (i=DestRect->left; i<DestRect->right; i++)
+ sx = BltInfo->SourcePoint.x;
+ for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
{
- if(XLATEOBJ_iXlate(ColorTranslation, DIB_16BPP_GetPixel(SourceSurf, sx, sy)) == 0)
+ if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_16BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
{
- DIB_1BPP_PutPixel(DestSurf, i, j, 0);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
} else {
- DIB_1BPP_PutPixel(DestSurf, i, j, 1);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
}
sx++;
}
}
break;
- case 24:
- for (j=DestRect->top; j<DestRect->bottom; j++)
+ case BMF_24BPP:
+ for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
{
- sx = SourcePoint->x;
- for (i=DestRect->left; i<DestRect->right; i++)
+ sx = BltInfo->SourcePoint.x;
+ for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
{
- if(XLATEOBJ_iXlate(ColorTranslation, DIB_24BPP_GetPixel(SourceSurf, sx, sy)) == 0)
+ if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_24BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
{
- DIB_1BPP_PutPixel(DestSurf, i, j, 0);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
} else {
- DIB_1BPP_PutPixel(DestSurf, i, j, 1);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
}
sx++;
}
}
break;
- case 32:
- for (j=DestRect->top; j<DestRect->bottom; j++)
+ case BMF_32BPP:
+ for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
{
- sx = SourcePoint->x;
- for (i=DestRect->left; i<DestRect->right; i++)
+ sx = BltInfo->SourcePoint.x;
+ for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
{
- if(XLATEOBJ_iXlate(ColorTranslation, DIB_32BPP_GetPixel(SourceSurf, sx, sy)) == 0)
+ if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_32BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
{
- DIB_1BPP_PutPixel(DestSurf, i, j, 0);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
} else {
- DIB_1BPP_PutPixel(DestSurf, i, j, 1);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
}
sx++;
}
break;
default:
- DbgPrint("DIB_1BPP_BitBlt: Unhandled Source BPP: %u\n", SourceGDI->BitsPerPixel);
+ DbgPrint("DIB_1BPP_BitBlt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
return FALSE;
}
}
BOOLEAN
-DIB_1BPP_BitBlt(
- SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
- SURFGDI *DestGDI, SURFGDI *SourceGDI,
- PRECTL DestRect, POINTL *SourcePoint,
- BRUSHOBJ *Brush, POINTL BrushOrigin,
- XLATEOBJ *ColorTranslation, ULONG Rop4)
+DIB_1BPP_BitBlt(PBLTINFO BltInfo)
{
- ULONG X, Y, SourceX, SourceY, k;
- ULONG Dest, Source, Pattern = 0;
+ ULONG DestX, DestY;
+ ULONG SourceX, SourceY;
+ ULONG PatternY = 0;
+ ULONG Dest, Source = 0, Pattern = 0;
+ ULONG Index;
+ BOOLEAN UsesSource;
+ BOOLEAN UsesPattern;
PULONG DestBits;
- BOOL UsesSource;
- BOOL UsesPattern;
ULONG RoundedRight;
- BYTE NoBits;
- /* Pattern brushes */
- PGDIBRUSHOBJ GdiBrush;
- HBITMAP PatternSurface = NULL;
- SURFOBJ *PatternObj;
- ULONG PatternWidth, PatternHeight;
-
- if (Rop4 == SRCCOPY)
- {
- return DIB_1BPP_BitBltSrcCopy(
- DestSurf,
- SourceSurf,
- DestGDI,
- SourceGDI,
- DestRect,
- SourcePoint,
- ColorTranslation);
- }
+/* BYTE NoBits;*/
- UsesSource = ((Rop4 & 0xCC0000) >> 2) != (Rop4 & 0x330000);
- UsesPattern = (((Rop4 & 0xF00000) >> 4) != (Rop4 & 0x0F0000)) && Brush;
+ UsesSource = ROP4_USES_SOURCE(BltInfo->Rop4);
+ UsesPattern = ROP4_USES_PATTERN(BltInfo->Rop4);
+
+ RoundedRight = BltInfo->DestRect.right -
+ ((BltInfo->DestRect.right - BltInfo->DestRect.left) & 31);
+ SourceY = BltInfo->SourcePoint.y;
if (UsesPattern)
{
- if (Brush->iSolidColor == 0xFFFFFFFF)
+ if (BltInfo->PatternSurface)
{
- PBITMAPOBJ PatternBitmap;
-
- GdiBrush = CONTAINING_RECORD(
- Brush,
- GDIBRUSHOBJ,
- BrushObject);
-
- PatternBitmap = BITMAPOBJ_LockBitmap(GdiBrush->hbmPattern);
- PatternSurface = BitmapToSurf(PatternBitmap, NULL);
- BITMAPOBJ_UnlockBitmap(GdiBrush->hbmPattern);
-
- PatternObj = (SURFOBJ*)AccessUserObject((ULONG)PatternSurface);
- PatternWidth = PatternObj->sizlBitmap.cx;
- PatternHeight = PatternObj->sizlBitmap.cy;
-
- UsesPattern = TRUE;
+ PatternY = (BltInfo->DestRect.top + BltInfo->BrushOrigin.y) %
+ BltInfo->PatternSurface->sizlBitmap.cy;
}
else
{
- UsesPattern = FALSE;
- Pattern = Brush->iSolidColor;
+ /* FIXME: Shouldn't it be expanded? */
+ Pattern = BltInfo->Brush->iSolidColor;
}
}
- RoundedRight = DestRect->right - ((DestRect->right - DestRect->left) & 31);
- SourceY = SourcePoint->y;
-
- for (Y = DestRect->top; Y < DestRect->bottom; Y++)
+ for (DestY = BltInfo->DestRect.top; DestY < BltInfo->DestRect.bottom; DestY++)
{
- ULONG PatternY;
-
- SourceX = SourcePoint->x;
+ DestX = BltInfo->DestRect.left;
+ SourceX = BltInfo->SourcePoint.x;
DestBits = (PULONG)(
- DestSurf->pvScan0 +
- (DestRect->left >> 3) +
- Y * DestSurf->lDelta);
-
- if(UsesPattern)
- PatternY = (Y + BrushOrigin.y) % PatternHeight;
+ (PBYTE)BltInfo->DestSurface->pvScan0 +
+ (BltInfo->DestRect.left >> 3) +
+ DestY * BltInfo->DestSurface->lDelta);
- X = DestRect->left;
- if (X & 31)
+ if (DestX & 31)
{
+#if 0
/* FIXME: This case is completely untested!!! */
-
+
Dest = *((PBYTE)DestBits);
- NoBits = 31 - (X & 31);
+ NoBits = 31 - (DestX & 31);
if (UsesSource)
{
Source = 0;
- for (k = 31 - NoBits; k < NoBits; k++)
- Source |= (DIB_GetSource(SourceSurf, SourceGDI, SourceX + k, SourceY, ColorTranslation) << (31 - k));
+ /* FIXME: This is incorrect! */
+ for (Index = 31 - NoBits; Index >= 0; Index++)
+ Source |= (DIB_GetSource(SourceSurf, SourceX + Index, SourceY, ColorTranslation) << (31 - Index));
}
- if (UsesPattern)
+ if (BltInfo->PatternSurface)
{
Pattern = 0;
- for (k = 31 - NoBits; k < NoBits; k++)
- Pattern |= (DIB_1BPP_GetPixel(PatternObj, (X + BrushOrigin.x + k) % PatternWidth, PatternY) << (31 - k));
+ for (k = 31 - NoBits; k >= 0; k++)
+ Pattern |= (DIB_GetSource(PatternObj, (X + BrushOrigin.x + k) % PatternWidth, PatternY, BltInfo->XlatePatternToDest) << (31 - k));
}
- Dest = DIB_DoRop(Rop4, Dest, Source, Pattern);
+ Dest = DIB_DoRop(Rop4, Dest, Source, Pattern);
Dest &= ~((1 << (31 - NoBits)) - 1);
Dest |= *((PBYTE)DestBits) & ((1 << (31 - NoBits)) - 1);
*DestBits = Dest;
-
- X += NoBits;
+
+ DestX += NoBits;
SourceX += NoBits;
+#endif
}
- for (; X < RoundedRight; X += 32, DestBits++, SourceX++)
+ for (; DestX < RoundedRight; DestX += 32, DestBits++, SourceX++)
{
Dest = *DestBits;
if (UsesSource)
{
Source = 0;
- for (k = 0; k < 8; k++)
+ for (Index = 0; Index < 8; Index++)
{
- Source |= (DIB_GetSource(SourceSurf, SourceGDI, SourceX + k, SourceY, ColorTranslation) << (7 - k));
- Source |= (DIB_GetSource(SourceSurf, SourceGDI, SourceX + k + 8, SourceY, ColorTranslation) << (8 + (7 - k)));
- Source |= (DIB_GetSource(SourceSurf, SourceGDI, SourceX + k + 16, SourceY, ColorTranslation) << (16 + (7 - k)));
- Source |= (DIB_GetSource(SourceSurf, SourceGDI, SourceX + k + 24, SourceY, ColorTranslation) << (24 + (7 - k)));
+ Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index, SourceY, BltInfo->XlateSourceToDest) << (7 - Index);
+ Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 8, SourceY, BltInfo->XlateSourceToDest) << (8 + (7 - Index));
+ Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 16, SourceY, BltInfo->XlateSourceToDest) << (16 + (7 - Index));
+ Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 24, SourceY, BltInfo->XlateSourceToDest) << (24 + (7 - Index));
}
}
- if (UsesPattern)
+ if (BltInfo->PatternSurface)
{
Pattern = 0;
- for (k = 0; k < 8; k++)
+ for (Index = 0; Index < 8; Index++)
{
- Pattern |= (DIB_1BPP_GetPixel(PatternObj, (X + BrushOrigin.x + k) % PatternWidth, PatternY) << (7 - k));
- Pattern |= (DIB_1BPP_GetPixel(PatternObj, (X + BrushOrigin.x + k + 8) % PatternWidth, PatternY) << (8 + (7 - k)));
- Pattern |= (DIB_1BPP_GetPixel(PatternObj, (X + BrushOrigin.x + k + 16) % PatternWidth, PatternY) << (16 + (7 - k)));
- Pattern |= (DIB_1BPP_GetPixel(PatternObj, (X + BrushOrigin.x + k + 24) % PatternWidth, PatternY) << (24 + (7 - k)));
+ Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (7 - Index);
+ Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 8) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (8 + (7 - Index));
+ Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 16) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (16 + (7 - Index));
+ Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 24) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (24 + (7 - Index));
}
}
- *DestBits = DIB_DoRop(Rop4, Dest, Source, Pattern);
+ *DestBits = DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern);
}
- if (X < DestRect->right)
+ if (DestX < BltInfo->DestRect.right)
{
// Dest = *DestBits;
- for (; X < DestRect->right; X++, SourceX++)
+ for (; DestX < BltInfo->DestRect.right; DestX++, SourceX++)
{
// Dest = *DestBits;
- Dest = DIB_1BPP_GetPixel(DestSurf, X, Y);
+ Dest = DIB_1BPP_GetPixel(BltInfo->DestSurface, DestX, DestY);
if (UsesSource)
{
- Source = DIB_GetSource(SourceSurf, SourceGDI, SourceX, SourceY, ColorTranslation);
+ Source = DIB_GetSource(BltInfo->SourceSurface, SourceX, SourceY, BltInfo->XlateSourceToDest);
}
- if (UsesPattern)
+ if (BltInfo->PatternSurface)
{
- Pattern = DIB_1BPP_GetPixel(PatternObj, (X + BrushOrigin.x) % PatternWidth, PatternY);
+ Pattern = DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest);
}
- DIB_1BPP_PutPixel(DestSurf, X, Y, DIB_DoRop(Rop4, Dest, Source, Pattern) & 0xF);
+ DIB_1BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF);
// Dest >>= 1;
}
}
SourceY++;
+ if (BltInfo->PatternSurface)
+ {
+ PatternY++;
+ PatternY %= BltInfo->PatternSurface->sizlBitmap.cy;
+ }
}
- if (PatternSurface != NULL)
- EngDeleteSurface((HSURF)PatternSurface);
-
return TRUE;
}
-BOOLEAN
-DIB_1BPP_StretchBlt (
- SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
- SURFGDI *DestGDI, SURFGDI *SourceGDI,
- RECTL* DestRect, RECTL *SourceRect,
- POINTL* MaskOrigin, POINTL BrushOrigin,
- XLATEOBJ *ColorTranslation, ULONG Mode)
+/* BitBlt Optimize */
+BOOLEAN
+DIB_1BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color)
{
- DbgPrint("DIB_1BPP_StretchBlt: Source BPP: %u\n", SourceGDI->BitsPerPixel);
- return FALSE;
+ ULONG DestY;
+
+ for (DestY = DestRect->top; DestY< DestRect->bottom; DestY++)
+ {
+ DIB_1BPP_HLine(DestSurface, DestRect->left, DestRect->right, DestY, color);
+ }
+
+return TRUE;
}
-BOOLEAN
+//NOTE: If you change something here, please do the same in other dibXXbpp.c files!
+BOOLEAN DIB_1BPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+ RECTL* DestRect, RECTL *SourceRect,
+ POINTL* MaskOrigin, POINTL BrushOrigin,
+ CLIPOBJ *ClipRegion, XLATEOBJ *ColorTranslation,
+ ULONG Mode)
+{
+ LONG SrcSizeY;
+ LONG SrcSizeX;
+ LONG DesSizeY;
+ LONG DesSizeX;
+ LONG sx;
+ LONG sy;
+ LONG DesX;
+ LONG DesY;
+ LONG color;
+
+ SrcSizeY = SourceRect->bottom - SourceRect->top;
+ SrcSizeX = SourceRect->right - SourceRect->left;
+
+ DesSizeY = DestRect->bottom - DestRect->top;
+ DesSizeX = DestRect->right - DestRect->left;
+
+ switch(SourceSurf->iBitmapFormat)
+ {
+ case BMF_1BPP:
+ /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
+ /* This is a reference implementation, it hasn't been optimized for speed */
+
+ for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
+ {
+ sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
+
+ for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
+ {
+ sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
+
+ color = DIB_1BPP_GetPixel(SourceSurf, sx, sy);
+ DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, 0));
+ }
+ }
+
+ break;
+
+ case BMF_4BPP:
+ /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
+ /* This is a reference implementation, it hasn't been optimized for speed */
+
+ for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
+ {
+ sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
+
+ for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
+ {
+ sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
+ color = DIB_4BPP_GetPixel(SourceSurf, sx, sy);
+ DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
+ }
+ }
+ break;
+
+ case BMF_8BPP:
+ /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
+ /* This is a reference implementation, it hasn't been optimized for speed */
+
+ for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
+ {
+ sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
+
+ for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
+ {
+ sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
+ color = DIB_8BPP_GetPixel(SourceSurf, sx, sy);
+ DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
+ }
+ }
+ break;
+
+ case BMF_16BPP:
+ /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
+ /* This is a reference implementation, it hasn't been optimized for speed */
+
+ for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
+ {
+ sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
+
+ for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
+ {
+ sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
+ color = DIB_16BPP_GetPixel(SourceSurf, sx, sy);
+ DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
+ }
+ }
+ break;
+
+ case BMF_24BPP:
+ /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
+ /* This is a reference implementation, it hasn't been optimized for speed */
+
+ for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
+ {
+ sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
+
+ for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
+ {
+ sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
+ color = DIB_24BPP_GetPixel(SourceSurf, sx, sy);
+ DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
+ }
+ }
+ break;
+
+ case BMF_32BPP:
+ /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
+ /* This is a reference implementation, it hasn't been optimized for speed */
+
+ for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
+ {
+ sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
+
+ for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
+ {
+ sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
+ color = DIB_32BPP_GetPixel(SourceSurf, sx, sy);
+ DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
+ }
+ }
+ break;
+
+ default:
+ //DPRINT1("DIB_1BPP_StretchBlt: Unhandled Source BPP: %u\n", BitsPerFormat(SourceSurf->iBitmapFormat));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+BOOLEAN
DIB_1BPP_TransparentBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
- PSURFGDI DestGDI, PSURFGDI SourceGDI,
RECTL* DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation, ULONG iTransColor)
{
return FALSE;
}
+BOOLEAN
+DIB_1BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect,
+ RECTL* SourceRect, CLIPOBJ* ClipRegion,
+ XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj)
+{
+ UNIMPLEMENTED;
+ return FALSE;
+}
+
/* EOF */
projects / reactos.git / blobdiff