dib1bpp.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

			}
			sy++;
		}
		break;

	default:
		DbgPrint("DIB_1BPP_BitBlt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
		return FALSE;
	}

	return TRUE;
}

BOOLEAN
DIB_1BPP_BitBlt(PBLTINFO BltInfo)
{
   ULONG DestX, DestY;
   ULONG SourceX, SourceY;
   ULONG PatternY = 0;
   ULONG Dest, Source = 0, Pattern = 0;
   ULONG Index;
   BOOLEAN UsesSource;
   BOOLEAN UsesPattern;
   PULONG DestBits;
   ULONG RoundedRight;
/*   BYTE NoBits;*/

   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 (BltInfo->PatternSurface)
      {
         PatternY = (BltInfo->DestRect.top + BltInfo->BrushOrigin.y) %
                    BltInfo->PatternSurface->sizlBitmap.cy;
      }
      else
      {
         /* FIXME: Shouldn't it be expanded? */
         Pattern = BltInfo->Brush->iSolidColor;
      }
   }

   for (DestY = BltInfo->DestRect.top; DestY < BltInfo->DestRect.bottom; DestY++)
   {
      DestX = BltInfo->DestRect.left;
      SourceX = BltInfo->SourcePoint.x;
      DestBits = (PULONG)(
         (PBYTE)BltInfo->DestSurface->pvScan0 +
         (BltInfo->DestRect.left >> 3) +
         DestY * BltInfo->DestSurface->lDelta);

      if (DestX & 31)
      {
#if 0
         /* FIXME: This case is completely untested!!! */

         Dest = *((PBYTE)DestBits);
         NoBits = 31 - (DestX & 31);

         if (UsesSource)
         {
            Source = 0;
            /* FIXME: This is incorrect! */
            for (Index = 31 - NoBits; Index >= 0; Index++)
               Source |= (DIB_GetSource(SourceSurf, SourceX + Index, SourceY, ColorTranslation) << (31 - Index));
         }

         if (BltInfo->PatternSurface)
         {
            Pattern = 0;
            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 &= ~((1 << (31 - NoBits)) - 1);
         Dest |= *((PBYTE)DestBits) & ((1 << (31 - NoBits)) - 1);

         *DestBits = Dest;

         DestX += NoBits;
         SourceX += NoBits;
#endif
      }

      for (; DestX < RoundedRight; DestX += 32, DestBits++, SourceX++)
      {
         Dest = *DestBits;

         if (UsesSource)
         {
            Source = 0;
            for (Index = 0; Index < 8; Index++)
            {
               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 (BltInfo->PatternSurface)
         {
            Pattern = 0;
            for (Index = 0; Index < 8; Index++)
            {
               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(BltInfo->Rop4, Dest, Source, Pattern);
      }

      if (DestX < BltInfo->DestRect.right)
      {
//         Dest = *DestBits;
         for (; DestX < BltInfo->DestRect.right; DestX++, SourceX++)
         {
//            Dest = *DestBits;
            Dest = DIB_1BPP_GetPixel(BltInfo->DestSurface, DestX, DestY);

            if (UsesSource)
            {
               Source = DIB_GetSource(BltInfo->SourceSurface, SourceX, SourceY, BltInfo->XlateSourceToDest);
            }

            if (BltInfo->PatternSurface)
            {
               Pattern = DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest);
            }

            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;
      }
   }

   return TRUE;
}

/* BitBlt Optimize */
BOOLEAN 
DIB_1BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color)
{
  ULONG DestY;	

	 for (DestY = DestRect->top; DestY< DestRect->bottom; DestY++)
	{			 				
		DIB_1BPP_HLine(DestSurface, DestRect->left, DestRect->right, DestY, color);			  				
	}

return TRUE;
}

//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, color));                  
            }
       }		

	  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,
                        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 */