reactos/subsystems/win32/win32k/dib/dib1bpp.c

   1 /*
   2  *  ReactOS W32 Subsystem
   3  *  Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$ */
  20 #include <w32k.h>
  21
  22 #define NDEBUG
  23 #include <debug.h>
  24
  25 VOID
  26 DIB_1BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
  27 {
  28   PBYTE addr = (PBYTE)SurfObj->pvScan0 + y * SurfObj->lDelta + (x >> 3);
  29
  30   if (0 == (c & 0x01))
  31     *addr &= ~MASK1BPP(x);
  32   else
  33     *addr |= MASK1BPP(x);
  34 }
  35
  36 ULONG
  37 DIB_1BPP_GetPixel(SURFOBJ *SurfObj, LONG x, LONG y)
  38 {
  39   PBYTE addr = (PBYTE)SurfObj->pvScan0 + y * SurfObj->lDelta + (x >> 3);
  40
  41   return (*addr & MASK1BPP(x) ? 1 : 0);
  42 }
  43
  44 VOID
  45 DIB_1BPP_HLine(SURFOBJ *SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
  46 {
  47   while(x1 < x2) {
  48     DIB_1BPP_PutPixel(SurfObj, x1, y, c);
  49     x1++;
  50   }
  51 }
  52
  53 VOID
  54 DIB_1BPP_VLine(SURFOBJ *SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
  55 {
  56   while(y1 < y2) {
  57     DIB_1BPP_PutPixel(SurfObj, x, y1, c);
  58     y1++;
  59   }
  60 }
  61
  62 static
  63 void
  64 DIB_1BPP_BitBltSrcCopy_From1BPP (
  65         SURFOBJ* DestSurf, SURFOBJ* SourceSurf,
  66         PRECTL DestRect, POINTL *SourcePoint )
  67 {
  68         // the 'window' in this sense is the x-position that corresponds
  69         // to the left-edge of the 8-pixel byte we are currently working with.
  70         // dwx is current x-window, dwx2 is the 'last' window we need to process
  71         int dwx, dwx2; // destination window x-position
  72         int swx; // source window y-position
  73
  74         // left and right edges of source and dest rectangles
  75         int dl = DestRect->left; // dest left
  76         int dr = DestRect->right-1; // dest right (inclusive)
  77         int sl = SourcePoint->x; // source left
  78         int sr = sl + dr - dl; // source right (inclusive)
  79
  80         // which direction are we going?
  81         int xinc;
  82         int yinc;
  83         int ySrcDelta, yDstDelta;
  84
  85         // following 4 variables are used for the y-sweep
  86         int dy; // dest y
  87         int dy1; // dest y start
  88         int dy2; // dest y end
  89         int sy1; // src y start
  90
  91     int dx;
  92         int shift;
  93         BYTE srcmask, dstmask;
  94
  95         // 'd' and 's' are the dest & src buffer pointers that I use on my x-sweep
  96         // 'pd' and 'ps' are the dest & src buffer pointers used on the inner y-sweep
  97         PBYTE d, pd; // dest ptrs
  98         PBYTE s, ps; // src ptrs
  99
 100         shift = (dl-sl)&7;
 101
 102         if ( DestRect->top <= SourcePoint->y )
 103         {
 104                 // moving up ( scan top -> bottom )
 105                 dy1 = DestRect->top;
 106                 dy2 = DestRect->bottom - 1;
 107                 sy1 = SourcePoint->y;
 108                 yinc = 1;
 109                 ySrcDelta = SourceSurf->lDelta;
 110                 yDstDelta = DestSurf->lDelta;
 111         }
 112         else
 113         {
 114                 // moving down ( scan bottom -> top )
 115                 dy1 = DestRect->bottom - 1;
 116                 dy2 = DestRect->top;
 117                 sy1 = SourcePoint->y + dy1 - dy2;
 118                 yinc = -1;
 119                 ySrcDelta = -SourceSurf->lDelta;
 120                 yDstDelta = -DestSurf->lDelta;
 121         }
 122         if ( DestRect->left <= SourcePoint->x )
 123         {
 124                 // moving left ( scan left->right )
 125                 dwx = dl&~7;
 126                 swx = (sl-(dl&7))&~7;
 127                 dwx2 = dr&~7;
 128                 xinc = 1;
 129         }
 130         else
 131         {
 132                 // moving right ( scan right->left )
 133                 dwx = dr&~7;
 134                 swx = (sr-(dr&7))&~7; //(sr-7)&~7; // we need the left edge of this block... thus the -7
 135                 dwx2 = dl&~7;
 136                 xinc = -1;
 137         }
 138         d = &(((PBYTE)DestSurf->pvScan0)[dy1*DestSurf->lDelta + (dwx>>3)]);
 139         s = &(((PBYTE)SourceSurf->pvScan0)[sy1*SourceSurf->lDelta + (swx>>3)]);
 140         for ( ;; )
 141         {
 142                 dy = dy1;
 143                 pd = d;
 144                 ps = s;
 145                 srcmask = 0xff;
 146                 dx = dwx; /* dest x for this pass */
 147                 if ( dwx < dl )
 148                 {
 149                         int diff = dl-dwx;
 150                         srcmask &= (1<<(8-diff))-1;
 151                         dx = dl;
 152                 }
 153                 if ( dwx+7 > dr )
 154                 {
 155                         int diff = dr-dwx+1;
 156                         srcmask &= ~((1<<(8-diff))-1);
 157                 }
 158                 dstmask = ~srcmask;
 159
 160                 // we unfortunately *must* have 5 different versions of the inner
 161                 // loop to be certain we don't try to read from memory that is not
 162                 // needed and may in fact be invalid
 163                 if ( !shift )
 164                 {
 165                         for ( ;; )
 166                         {
 167                                 *pd = (BYTE)((*pd & dstmask) | (*ps & srcmask));
 168
 169                                 // this *must* be here, because we could be going up *or* down...
 170                                 if ( dy == dy2 )
 171                                         break;
 172                                 dy += yinc;
 173                                 pd += yDstDelta;
 174                                 ps += ySrcDelta;
 175                         }
 176                 }
 177                 else if ( !(0xFF00 & (srcmask<<shift) ) ) // check if ps[0] not needed...
 178                 {
 179                         for ( ;; )
 180                         {
 181                                 *pd = (BYTE)((*pd & dstmask)
 182                                         | ( ( ps[1] >> shift ) & srcmask ));
 183
 184                                 // this *must* be here, because we could be going up *or* down...
 185                                 if ( dy == dy2 )
 186                                         break;
 187                                 dy += yinc;
 188                                 pd += yDstDelta;
 189                                 ps += ySrcDelta;
 190                         }
 191                 }
 192                 else if ( !(0xFF & (srcmask<<shift) ) ) // check if ps[1] not needed...
 193                 {
 194                         for ( ;; )
 195                         {
 196                                 *pd = (*pd & dstmask)
 197                                         | ( ( ps[0] << ( 8 - shift ) ) & srcmask );
 198
 199                                 // this *must* be here, because we could be going up *or* down...
 200                                 if ( dy == dy2 )
 201                                         break;
 202                                 dy += yinc;
 203                                 pd += yDstDelta;
 204                                 ps += ySrcDelta;
 205                         }
 206                 }
 207                 else // both ps[0] and ps[1] are needed
 208                 {
 209                         for ( ;; )
 210                         {
 211                                 *pd = (*pd & dstmask)
 212                                         | ( ( ( (ps[1])|(ps[0]<<8) ) >> shift ) & srcmask );
 213
 214                                 // this *must* be here, because we could be going up *or* down...
 215                                 if ( dy == dy2 )
 216                                         break;
 217                                 dy += yinc;
 218                                 pd += yDstDelta;
 219                                 ps += ySrcDelta;
 220                         }
 221                 }
 222
 223                 // this *must* be here, because we could be going right *or* left...
 224                 if ( dwx == dwx2 )
 225                         break;
 226                 d += xinc;
 227                 s += xinc;
 228                 dwx += xinc<<3;
 229                 swx += xinc<<3;
 230         }
 231 }
 232
 233 BOOLEAN
 234 DIB_1BPP_BitBltSrcCopy(PBLTINFO BltInfo)
 235 {
 236         LONG i, j, sx, sy = BltInfo->SourcePoint.y;
 237
 238         switch ( BltInfo->SourceSurface->iBitmapFormat )
 239         {
 240         case BMF_1BPP:
 241                 DIB_1BPP_BitBltSrcCopy_From1BPP ( BltInfo->DestSurface, BltInfo->SourceSurface, &BltInfo->DestRect, &BltInfo->SourcePoint );
 242                 break;
 243
 244         case BMF_4BPP:
 245                 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
 246                 {
 247                         sx = BltInfo->SourcePoint.x;
 248                         for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
 249                         {
 250                                 if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
 251                                 {
 252                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
 253                                 } else {
 254                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
 255                                 }
 256                                 sx++;
 257                         }
 258                         sy++;
 259                 }
 260                 break;
 261
 262         case BMF_8BPP:
 263                 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
 264                 {
 265                         sx = BltInfo->SourcePoint.x;
 266                         for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
 267                         {
 268                                 if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_8BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
 269                                 {
 270                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
 271                                 } else {
 272                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
 273                                 }
 274                                 sx++;
 275                         }
 276                         sy++;
 277                 }
 278                 break;
 279
 280         case BMF_16BPP:
 281                 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
 282                 {
 283                         sx = BltInfo->SourcePoint.x;
 284                         for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
 285                         {
 286                                 if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_16BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
 287                                 {
 288                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
 289                                 } else {
 290                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
 291                                 }
 292                                 sx++;
 293                         }
 294                         sy++;
 295                 }
 296                 break;
 297
 298         case BMF_24BPP:
 299                 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
 300                 {
 301                         sx = BltInfo->SourcePoint.x;
 302                         for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
 303                         {
 304                                 if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_24BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
 305                                 {
 306                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
 307                                 } else {
 308                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
 309                                 }
 310                                 sx++;
 311                         }
 312                         sy++;
 313                 }
 314                 break;
 315
 316         case BMF_32BPP:
 317                 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
 318                 {
 319                         sx = BltInfo->SourcePoint.x;
 320                         for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
 321                         {
 322                                 if(XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_32BPP_GetPixel(BltInfo->SourceSurface, sx, sy)) == 0)
 323                                 {
 324                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 0);
 325                                 } else {
 326                                         DIB_1BPP_PutPixel(BltInfo->DestSurface, i, j, 1);
 327                                 }
 328                                 sx++;
 329                         }
 330                         sy++;
 331                 }
 332                 break;
 333
 334         default:
 335                 DbgPrint("DIB_1BPP_BitBlt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
 336                 return FALSE;
 337         }
 338
 339         return TRUE;
 340 }
 341
 342 BOOLEAN
 343 DIB_1BPP_BitBlt(PBLTINFO BltInfo)
 344 {
 345    ULONG DestX, DestY;
 346    ULONG SourceX, SourceY;
 347    ULONG PatternY = 0;
 348    ULONG Dest, Source = 0, Pattern = 0;
 349    ULONG Index;
 350    BOOLEAN UsesSource;
 351    BOOLEAN UsesPattern;
 352    PULONG DestBits;
 353    ULONG RoundedRight;
 354 /*   BYTE NoBits;*/
 355
 356    UsesSource = ROP4_USES_SOURCE(BltInfo->Rop4);
 357    UsesPattern = ROP4_USES_PATTERN(BltInfo->Rop4);
 358
 359    RoundedRight = BltInfo->DestRect.right -
 360                   ((BltInfo->DestRect.right - BltInfo->DestRect.left) & 31);
 361    SourceY = BltInfo->SourcePoint.y;
 362
 363    if (UsesPattern)
 364    {
 365       if (BltInfo->PatternSurface)
 366       {
 367          PatternY = (BltInfo->DestRect.top + BltInfo->BrushOrigin.y) %
 368                     BltInfo->PatternSurface->sizlBitmap.cy;
 369       }
 370       else
 371       {
 372          /* FIXME: Shouldn't it be expanded? */
 373          Pattern = BltInfo->Brush->iSolidColor;
 374       }
 375    }
 376
 377    for (DestY = BltInfo->DestRect.top; DestY < BltInfo->DestRect.bottom; DestY++)
 378    {
 379       DestX = BltInfo->DestRect.left;
 380       SourceX = BltInfo->SourcePoint.x;
 381       DestBits = (PULONG)(
 382          (PBYTE)BltInfo->DestSurface->pvScan0 +
 383          (BltInfo->DestRect.left >> 3) +
 384          DestY * BltInfo->DestSurface->lDelta);
 385
 386       if (DestX & 31)
 387       {
 388 #if 0
 389          /* FIXME: This case is completely untested!!! */
 390
 391          Dest = *((PBYTE)DestBits);
 392          NoBits = 31 - (DestX & 31);
 393
 394          if (UsesSource)
 395          {
 396             Source = 0;
 397             /* FIXME: This is incorrect! */
 398             for (Index = 31 - NoBits; Index >= 0; Index++)
 399                Source |= (DIB_GetSource(SourceSurf, SourceX + Index, SourceY, ColorTranslation) << (31 - Index));
 400          }
 401
 402          if (BltInfo->PatternSurface)
 403          {
 404             Pattern = 0;
 405             for (k = 31 - NoBits; k >= 0; k++)
 406                Pattern |= (DIB_GetSource(PatternObj, (X + BrushOrigin.x + k) % PatternWidth, PatternY, BltInfo->XlatePatternToDest) << (31 - k));
 407          }
 408
 409          Dest = DIB_DoRop(Rop4, Dest, Source, Pattern);
 410          Dest &= ~((1 << (31 - NoBits)) - 1);
 411          Dest |= *((PBYTE)DestBits) & ((1 << (31 - NoBits)) - 1);
 412
 413          *DestBits = Dest;
 414
 415          DestX += NoBits;
 416          SourceX += NoBits;
 417 #endif
 418       }
 419
 420       for (; DestX < RoundedRight; DestX += 32, DestBits++, SourceX++)
 421       {
 422          Dest = *DestBits;
 423
 424          if (UsesSource)
 425          {
 426             Source = 0;
 427             for (Index = 0; Index < 8; Index++)
 428             {
 429                Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index, SourceY, BltInfo->XlateSourceToDest) << (7 - Index);
 430                Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 8, SourceY, BltInfo->XlateSourceToDest) << (8 + (7 - Index));
 431                Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 16, SourceY, BltInfo->XlateSourceToDest) << (16 + (7 - Index));
 432                Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 24, SourceY, BltInfo->XlateSourceToDest) << (24 + (7 - Index));
 433             }
 434          }
 435
 436          if (BltInfo->PatternSurface)
 437          {
 438             Pattern = 0;
 439             for (Index = 0; Index < 8; Index++)
 440             {
 441                Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (7 - Index);
 442                Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 8) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (8 + (7 - Index));
 443                Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 16) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (16 + (7 - Index));
 444                Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 24) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << (24 + (7 - Index));
 445             }
 446          }
 447
 448          *DestBits = DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern);
 449       }
 450
 451       if (DestX < BltInfo->DestRect.right)
 452       {
 453 //         Dest = *DestBits;
 454          for (; DestX < BltInfo->DestRect.right; DestX++, SourceX++)
 455          {
 456 //            Dest = *DestBits;
 457             Dest = DIB_1BPP_GetPixel(BltInfo->DestSurface, DestX, DestY);
 458
 459             if (UsesSource)
 460             {
 461                Source = DIB_GetSource(BltInfo->SourceSurface, SourceX, SourceY, BltInfo->XlateSourceToDest);
 462             }
 463
 464             if (BltInfo->PatternSurface)
 465             {
 466                Pattern = DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest);
 467             }
 468
 469             DIB_1BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF);
 470 //            Dest >>= 1;
 471          }
 472       }
 473
 474       SourceY++;
 475       if (BltInfo->PatternSurface)
 476       {
 477          PatternY++;
 478          PatternY %= BltInfo->PatternSurface->sizlBitmap.cy;
 479       }
 480    }
 481
 482    return TRUE;
 483 }
 484
 485 /* BitBlt Optimize */
 486 BOOLEAN
 487 DIB_1BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color)
 488 {
 489   ULONG DestY;
 490
 491          for (DestY = DestRect->top; DestY< DestRect->bottom; DestY++)
 492         {
 493                 DIB_1BPP_HLine(DestSurface, DestRect->left, DestRect->right, DestY, color);
 494         }
 495
 496 return TRUE;
 497 }
 498
 499 //NOTE: If you change something here, please do the same in other dibXXbpp.c files!
 500
 501 BOOLEAN DIB_1BPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
 502                             RECTL* DestRect, RECTL *SourceRect,
 503                             POINTL* MaskOrigin, POINTL BrushOrigin,
 504                             CLIPOBJ *ClipRegion, XLATEOBJ *ColorTranslation,
 505                             ULONG Mode)
 506 {
 507    LONG SrcSizeY;
 508    LONG SrcSizeX;
 509    LONG DesSizeY;
 510    LONG DesSizeX;
 511    LONG sx;
 512    LONG sy;
 513    LONG DesX;
 514    LONG DesY;
 515    LONG color;
 516
 517    SrcSizeY = SourceRect->bottom - SourceRect->top;
 518    SrcSizeX = SourceRect->right - SourceRect->left;
 519
 520    DesSizeY = DestRect->bottom - DestRect->top;
 521    DesSizeX = DestRect->right - DestRect->left;
 522
 523    switch(SourceSurf->iBitmapFormat)
 524    {
 525       case BMF_1BPP:
 526           /* FIXME :  MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
 527       /* This is a reference implementation, it hasn't been optimized for speed */
 528
 529        for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
 530        {
 531            sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
 532
 533             for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
 534             {
 535                   sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
 536
 537                   color = DIB_1BPP_GetPixel(SourceSurf, sx, sy);
 538                                   DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
 539             }
 540        }
 541
 542           break;
 543
 544       case BMF_4BPP:
 545       /* FIXME :  MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
 546       /* This is a reference implementation, it hasn't been optimized for speed */
 547
 548        for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
 549        {
 550            sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
 551
 552             for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
 553             {
 554                  sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
 555                  color = DIB_4BPP_GetPixel(SourceSurf, sx, sy);
 556                  DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
 557             }
 558        }
 559       break;
 560
 561       case BMF_8BPP:
 562       /* FIXME :  MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
 563       /* This is a reference implementation, it hasn't been optimized for speed */
 564
 565        for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
 566        {
 567            sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
 568
 569             for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
 570             {
 571                  sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
 572                  color = DIB_8BPP_GetPixel(SourceSurf, sx, sy);
 573                  DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
 574             }
 575        }
 576       break;
 577
 578       case BMF_16BPP:
 579       /* FIXME :  MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
 580       /* This is a reference implementation, it hasn't been optimized for speed */
 581
 582        for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
 583        {
 584            sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
 585
 586             for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
 587             {
 588                  sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
 589                  color = DIB_16BPP_GetPixel(SourceSurf, sx, sy);
 590                  DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
 591             }
 592        }
 593       break;
 594
 595       case BMF_24BPP:
 596       /* FIXME :  MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
 597       /* This is a reference implementation, it hasn't been optimized for speed */
 598
 599        for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
 600        {
 601            sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
 602
 603             for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
 604             {
 605                  sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
 606                  color = DIB_24BPP_GetPixel(SourceSurf, sx, sy);
 607                  DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
 608             }
 609        }
 610       break;
 611
 612       case BMF_32BPP:
 613       /* FIXME :  MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
 614       /* This is a reference implementation, it hasn't been optimized for speed */
 615
 616        for (DesY=DestRect->top; DesY<DestRect->bottom; DesY++)
 617        {
 618            sy = (((DesY - DestRect->top) * SrcSizeY) / DesSizeY) + SourceRect->top;
 619
 620             for (DesX=DestRect->left; DesX<DestRect->right; DesX++)
 621             {
 622                  sx = (((DesX - DestRect->left) * SrcSizeX) / DesSizeX) + SourceRect->left;
 623                  color = DIB_32BPP_GetPixel(SourceSurf, sx, sy);
 624                  DIB_1BPP_PutPixel(DestSurf, DesX, DesY, XLATEOBJ_iXlate(ColorTranslation, color));
 625             }
 626        }
 627       break;
 628
 629       default:
 630       //DPRINT1("DIB_1BPP_StretchBlt: Unhandled Source BPP: %u\n", BitsPerFormat(SourceSurf->iBitmapFormat));
 631       return FALSE;
 632     }
 633
 634   return TRUE;
 635 }
 636
 637 BOOLEAN
 638 DIB_1BPP_TransparentBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
 639                         RECTL*  DestRect,  POINTL  *SourcePoint,
 640                         XLATEOBJ *ColorTranslation, ULONG iTransColor)
 641 {
 642   return FALSE;
 643 }
 644
 645 BOOLEAN
 646 DIB_1BPP_AlphaBlend(SURFOBJ* Dest, SURFOBJ* Source, RECTL* DestRect,
 647                     RECTL* SourceRect, CLIPOBJ* ClipRegion,
 648                     XLATEOBJ* ColorTranslation, BLENDOBJ* BlendObj)
 649 {
 650   UNIMPLEMENTED;
 651   return FALSE;
 652 }
 653
 654 /* EOF */