dlls/winedib.drv/primitives_bitblt.c

   1 /*
   2  * DIB Engine BitBlt Primitives
   3  *
   4  * Copyright 2009 Massimo Del Fedele
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include "dibdrv.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(dibdrv);
  27
  28 static inline COLORREF SwapColors(DWORD c)
  29 {
  30     return ((c & 0x0000ff) << 16) | (c & 0x00ff00) | ((c & 0xff0000) >> 16);
  31
  32 }
  33
  34 /* shrinks a line -- srcWidth >= dstWidth */
  35 static void ShrinkLine(DWORD *dst, int dstWidth, DWORD *src, int srcWidth)
  36 {
  37     int srcPos, dstPos;
  38     int delta;
  39
  40     srcPos = 0;
  41     dstPos = 0;
  42     delta = 0;
  43     while(dstPos < dstWidth)
  44     {
  45         *dst++ = *src;
  46         while(delta < srcWidth)
  47         {
  48             srcPos++;
  49             src++;
  50             delta += dstWidth;
  51         }
  52         delta -= srcWidth;
  53         dstPos++;
  54     }
  55 }
  56
  57 /* expands a line -- srcWidth <= dstWidth */
  58 static void ExpandLine(DWORD *dst, int dstWidth, DWORD *src, int srcWidth)
  59 {
  60     int srcPos;
  61     int delta;
  62
  63     srcPos = 0;
  64     delta = 0;
  65     while(srcPos < srcWidth)
  66     {
  67         while(delta < dstWidth)
  68         {
  69             *dst++ = *src;
  70             delta += srcWidth;
  71         }
  72         delta -= dstWidth;
  73         src++;
  74         srcPos++;
  75     }
  76 }
  77
  78 /* stretch a line */
  79 static void StretchLine(DWORD *dst, int dstWidth, DWORD *src, int srcWidth)
  80 {
  81     if(srcWidth > dstWidth)
  82         ShrinkLine(dst, dstWidth, src, srcWidth);
  83     else if(srcWidth < dstWidth)
  84         ExpandLine(dst, dstWidth, src, srcWidth);
  85     else
  86         memcpy(dst, src, 4 * srcWidth);
  87 }
  88
  89 /* premultiply alpha channel on a line by a constant alpha
  90    note : it seems that pixels are already premultiplied
  91    by alpha channel content */
  92 static void PemultiplyLine(DWORD *dst, int width, BYTE constAlpha)
  93 {
  94     int i = width;
  95     BYTE *alphaPnt = (BYTE *)dst + 3;
  96
  97     /* small optimization for 0 and 255 values of constAlpha */
  98
  99     /* fully transparent -- just sets all pix to 0 */
 100     if(constAlpha == 0)
 101     {
 102         while(i--)
 103             *dst++ = 0;
 104         return;
 105     }
 106
 107     /* fully opaque, just do nothing */
 108     if(constAlpha == 255)
 109         return;
 110
 111     /* intermediate -- premultiply alpha values */
 112     while(i--)
 113     {
 114         *alphaPnt = MulDiv(*alphaPnt, constAlpha, 255);
 115         alphaPnt += 4;
 116     }
 117     return;
 118
 119 }
 120
 121 /* alpha blends a source line onto a destination line
 122    preconditions :
 123    1) source and dest widths must be the same
 124    2) source line should be already premultiplied by constant alpha */
 125 static void BlendLine(DWORD *dst, DWORD *src, int width)
 126 {
 127     int i = width;
 128     BYTE *blueDst  = (BYTE *)dst;
 129     BYTE *greenDst = blueDst  + 1;
 130     BYTE *redDst   = greenDst + 1;
 131     BYTE *blueSrc  = (BYTE *)src;
 132     BYTE *greenSrc = blueSrc  + 1;
 133     BYTE *redSrc   = greenSrc + 1;
 134     BYTE *alphaSrc = redSrc   + 1;
 135     BYTE alpha;
 136
 137     /* still don't know if it must take in account an eventual dest
 138        alpha channel..... */
 139     while(i--)
 140     {
 141         alpha = 255 - *alphaSrc;
 142
 143         *blueDst  = *blueSrc  + MulDiv(*blueDst,  alpha, 255);
 144         *greenDst = *greenSrc + MulDiv(*greenDst, alpha, 255);
 145         *redDst   = *redSrc   + MulDiv(*redDst,   alpha, 255);
 146
 147         blueSrc  += 4;
 148         greenSrc += 4;
 149         redSrc   += 4;
 150         alphaSrc += 4;
 151         blueDst  += 4;
 152         greenDst += 4;
 153         redDst   += 4;
 154     }
 155
 156 }
 157
 158 /* ------------------------------------------------------------*/
 159 /*                        ALPHABLEND PRIMITIVES                */
 160 BOOL _DIBDRV_AlphaBlend_generic(DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst,
 161                     INT widthDst, INT heightDst, const DIBDRVPHYSDEV *physDevSrc,
 162                     INT xSrc, INT ySrc, int widthSrc, int heightSrc, BLENDFUNCTION blendFn)
 163 {
 164     /* flags indicating wether source should be stretched */
 165     BOOL horStretch = (widthSrc != widthDst);
 166     BOOL verStretch = (heightSrc != heightDst);
 167
 168     /* constant alpha value */
 169     BYTE constAlpha = blendFn.SourceConstantAlpha;
 170
 171     /* source and dest bitmaps */
 172     const DIBDRVBITMAP *srcBmp = &physDevSrc->physBitmap;
 173     DIBDRVBITMAP *dstBmp = &physDevDst->physBitmap;
 174
 175     /* source and destination line buffers */
 176     DWORD *sBuf = HeapAlloc(GetProcessHeap(), 0, abs(srcBmp->stride));
 177     DWORD *dBuf = HeapAlloc(GetProcessHeap(), 0, abs(dstBmp->stride));
 178
 179     int ys = ySrc;
 180     int yd = yDst;
 181     int iLine;
 182     int delta;
 183
 184     /* in order to optimize a bit, we divide the routine in 4 parts,
 185        depending on stretching modes */
 186     if(!horStretch && !verStretch)
 187     {
 188         /* simplest case, no stretching needed */
 189         MAYBE(TRACE("No stretching\n"));
 190         for(iLine = 0; iLine < heightSrc; iLine++, ys++, yd++)
 191         {
 192             /* load source and dest lines */
 193             srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBuf);
 194             dstBmp->funcs->GetLine(dstBmp, yd, xDst, widthDst, dBuf);
 195
 196             /* premultiply source by constant and pixel alpha */
 197             PemultiplyLine(sBuf, widthSrc, constAlpha);
 198
 199             /* blends source on dest */
 200             BlendLine(dBuf, sBuf, widthSrc);
 201
 202             /* puts dest line back */
 203             dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 204         }
 205     }
 206     else if (horStretch && !verStretch)
 207     {
 208         /* just horizontal stretching needed */
 209         DWORD *strBuf = HeapAlloc(GetProcessHeap(), 0, abs(dstBmp->stride));
 210         MAYBE(TRACE("Horizontal stretching\n"));
 211
 212         for(iLine = 0; iLine < heightSrc; iLine++, ys++, yd++)
 213         {
 214             /* load source and dest lines */
 215             srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBuf);
 216             dstBmp->funcs->GetLine(dstBmp, yd, xDst, widthDst, dBuf);
 217
 218             /* stretch source line to match dest one */
 219             StretchLine(strBuf, widthDst, sBuf, widthSrc);
 220
 221             /* premultiply source by constant and pixel alpha */
 222             PemultiplyLine(strBuf, widthDst, constAlpha);
 223
 224             /* blends source on dest */
 225             BlendLine(dBuf, strBuf, widthDst);
 226
 227             /* puts dest line back */
 228             dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 229         }
 230         HeapFree(GetProcessHeap(), 0, strBuf);
 231     }
 232     else if (!horStretch && verStretch)
 233     {
 234         /* just vertical stretching needed */
 235         MAYBE(TRACE("Vertical stretching\n"));
 236
 237         if(heightSrc > heightDst)
 238         {
 239             iLine = 0;
 240             delta = 0;
 241             while(iLine < heightDst)
 242             {
 243                 /* load source and dest lines */
 244                 srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBuf);
 245                 dstBmp->funcs->GetLine(dstBmp, yd, xDst, widthDst, dBuf);
 246
 247                 /* premultiply source by constant and pixel alpha */
 248                 PemultiplyLine(sBuf, widthSrc, constAlpha);
 249
 250                 /* blends source on dest */
 251                 BlendLine(dBuf, sBuf, widthDst);
 252
 253                 /* puts dest line back */
 254                 dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 255
 256                 while(delta < heightSrc)
 257                 {
 258                     ys++;
 259                     delta += heightDst;
 260                 }
 261                 delta -= heightSrc;
 262                 yd++;
 263                 iLine++;
 264             }
 265         }
 266         else if(heightSrc < heightDst)
 267         {
 268             iLine = 0;
 269             delta = 0;
 270             while(iLine < heightSrc)
 271             {
 272                 /* load source line */
 273                 srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBuf);
 274
 275                 /* premultiply source by constant and pixel alpha */
 276                 PemultiplyLine(sBuf, widthSrc, constAlpha);
 277
 278                 while(delta < heightDst)
 279                 {
 280                     /* load dest line */
 281                     dstBmp->funcs->GetLine(dstBmp, yd, xDst, widthDst, dBuf);
 282
 283                     /* blends source on dest */
 284                     BlendLine(dBuf, sBuf, widthDst);
 285
 286                     /* puts dest line back */
 287                     dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 288                     yd++;
 289                     delta += heightSrc;
 290                 }
 291                 delta -= heightDst;
 292                 ys++;
 293                 iLine++;
 294             }
 295         }
 296     }
 297     else
 298     {
 299         DWORD *strBuf = HeapAlloc(GetProcessHeap(), 0, abs(dstBmp->stride));
 300         /* both stretching needed -- generic case */
 301         MAYBE(TRACE("Horizontal and vertical stretching\n"));
 302
 303         if(heightSrc > heightDst)
 304         {
 305             iLine = 0;
 306             delta = 0;
 307             while(iLine < heightDst)
 308             {
 309                 /* load source and dest lines */
 310                 srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBuf);
 311                 dstBmp->funcs->GetLine(dstBmp, yd, xDst, widthDst, dBuf);
 312
 313                 /* stretch source line to match dest one */
 314                 StretchLine(strBuf, widthDst, sBuf, widthSrc);
 315
 316                 /* premultiply source by constant and pixel alpha */
 317                 PemultiplyLine(strBuf, widthDst, constAlpha);
 318
 319                 /* blends source on dest */
 320                 BlendLine(dBuf, strBuf, widthDst);
 321
 322                 /* puts dest line back */
 323                 dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 324
 325                 while(delta < heightSrc)
 326                 {
 327                     ys++;
 328                     delta += heightDst;
 329                 }
 330                 delta -= heightSrc;
 331                 yd++;
 332                 iLine++;
 333             }
 334         }
 335         else if(heightSrc < heightDst)
 336         {
 337             iLine = 0;
 338             delta = 0;
 339             while(iLine < heightSrc)
 340             {
 341                 /* load source line */
 342                 srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBuf);
 343
 344                 /* stretch source line to match dest one */
 345                 StretchLine(strBuf, widthDst, sBuf, widthSrc);
 346
 347                 /* premultiply source by constant and pixel alpha */
 348                 PemultiplyLine(strBuf, widthDst, constAlpha);
 349
 350                 while(delta < heightDst)
 351                 {
 352                     /* load dest line */
 353                     dstBmp->funcs->GetLine(dstBmp, yd, xDst, widthDst, dBuf);
 354
 355                     /* blends source on dest */
 356                     BlendLine(dBuf, strBuf, widthDst);
 357
 358                     /* puts dest line back */
 359                     dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 360                     yd++;
 361                     delta += heightSrc;
 362                 }
 363                 delta -= heightDst;
 364                 ys++;
 365                 iLine++;
 366             }
 367         }
 368         HeapFree(GetProcessHeap(), 0, strBuf);
 369     }
 370
 371     HeapFree(GetProcessHeap(), 0, sBuf);
 372     HeapFree(GetProcessHeap(), 0, dBuf);
 373     return TRUE;
 374 }
 375
 376 /* ------------------------------------------------------------*/
 377 /*                        BLITTING PRIMITIVES                  */
 378 BOOL _DIBDRV_BitBlt_generic(DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst,
 379                     INT width, INT height, const DIBDRVPHYSDEV *physDevSrc,
 380                     INT xSrc, INT ySrc, DWORD rop)
 381 {
 382     int ys, yd;
 383     int i;
 384     DWORD *dwBuf;
 385     DIBDRVBITMAP *dstBmp, *patBmp;
 386     const DIBDRVBITMAP *srcBmp;
 387     DWORD *wDstPnt, *wSrcPnt, *wPatPnt;
 388     BOOL usePat, useSrc, useDst;
 389     DWORD patColor;
 390     BOOL res = FALSE;
 391
 392     /* 32 bit RGB source and destination buffer, if needed */
 393     DWORD *sBuf = 0, *dBuf = 0, *pBuf = 0;
 394
 395     /* get elements usage */
 396     usePat = (((rop >> 4) & 0x0f0000) != (rop & 0x0f0000));
 397     useSrc = (((rop >> 2) & 0x330000) != (rop & 0x330000));
 398     useDst = (((rop >> 1) & 0x550000) != (rop & 0x550000));
 399
 400     /* sanity check -- MSN messenger crashes without */
 401     if(useSrc && !physDevSrc)
 402         return FALSE;
 403
 404     /* gets source, dest and pattern bitmaps, if available */
 405     if(usePat && physDevDst->isBrushBitmap)
 406         patBmp = &physDevDst->brushBmpCache;
 407     else
 408         patBmp = NULL;
 409
 410     if(useSrc)
 411         srcBmp = &physDevSrc->physBitmap;
 412     else
 413         srcBmp = NULL;
 414     dstBmp = &physDevDst->physBitmap;
 415
 416     /* gets pattern color, in case it's needed
 417        it's NOT the COLORREF value (colors are swapped
 418        NOR the pixel value (it's applied to a 32 BPP BI_RGB */
 419     if(usePat)
 420         patColor = SwapColors(physDevDst->brushColorref);
 421     else
 422         patColor = 0;
 423
 424     /* allocate 32 bit RGB destination buffer */
 425     if(!(dBuf = (DWORD *)HeapAlloc( GetProcessHeap(), 0, width * 4)))
 426         goto error;
 427
 428     MAYBE(TRACE("dstBmp:%p(%s), xDst:%d, yDst:%d, width:%d, height:%d, srcBmp:%p(%s), xSrc:%d, ySrc:%d, rop:%8x\n",
 429           dstBmp, _DIBDRVBITMAP_GetFormatName(dstBmp), xDst, yDst, width, height,
 430           srcBmp, _DIBDRVBITMAP_GetFormatName(srcBmp), xSrc, ySrc, rop));
 431
 432     /* some simple ROPs optimizations */
 433     switch(rop)
 434     {
 435           case BLACKNESS:
 436               MAYBE(TRACE("BLACKNESS\n"));
 437               memset(dBuf, 0x00, width * 4);
 438               for(yd = yDst; yd < yDst+height; yd++)
 439                   dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 440               break;
 441
 442           case WHITENESS:
 443               MAYBE(TRACE("WHITENESS\n"));
 444               for(dwBuf = dBuf, i = width; i; i--)
 445                   *dwBuf++ = 0x00ffffff;
 446               for(yd = yDst; yd < yDst+height; yd++)
 447                   dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 448               break;
 449
 450           case SRCCOPY:
 451               MAYBE(TRACE("SRCCOPY\n"));
 452               for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 453               {
 454                   srcBmp->funcs->GetLine(srcBmp, ys, xSrc, width, dBuf);
 455                   dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 456               }
 457               break;
 458
 459           /* fallback for generic ROP operation */
 460           default:
 461               rop >>= 16;
 462               if(useSrc && useDst && usePat && physDevDst->isBrushBitmap)
 463               {
 464                   MAYBE(TRACE("BitBlt use: src+dst+pat - pattern brush\n"));
 465                   if(!(sBuf = HeapAlloc( GetProcessHeap(), 0, width * 4)))
 466                       goto error;
 467                   if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, width * 4)))
 468                       goto error;
 469                   for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 470                   {
 471                       srcBmp->funcs->GetLine(srcBmp, ys, xSrc, width, sBuf);
 472                       dstBmp->funcs->GetLine(dstBmp, ys, xDst, width, dBuf);
 473                       patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, width, pBuf);
 474                       wDstPnt = dBuf;
 475                       wSrcPnt = sBuf;
 476                       wPatPnt = pBuf;
 477                       for(i = width; i > 0 ; i--)
 478                       {
 479                           *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, *wDstPnt, rop);
 480                           wDstPnt++;
 481                       }
 482                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 483                   }
 484               }
 485               else if(useSrc && useDst)
 486               {
 487                   if(usePat)
 488                       MAYBE(TRACE("BitBlt use: src+dst+pat - solid brush\n"));
 489                   else
 490                       MAYBE(TRACE("BitBlt use: src+dst\n"));
 491                   if(!(sBuf = HeapAlloc( GetProcessHeap(), 0, width * 4)))
 492                       goto error;
 493                   for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 494                   {
 495                       srcBmp->funcs->GetLine(srcBmp, ys, xSrc, width, sBuf);
 496                       dstBmp->funcs->GetLine(dstBmp, yd, xDst, width, dBuf);
 497                       wDstPnt = dBuf;
 498                       wSrcPnt = sBuf;
 499                       for(i = width; i > 0 ; i--)
 500                       {
 501                           *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, *wDstPnt, rop);
 502                           wDstPnt++;
 503                       }
 504                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 505                   }
 506               }
 507               else if(useSrc && usePat && physDevDst->isBrushBitmap)
 508               {
 509                   MAYBE(TRACE("BitBlt use: src+pat -- pattern brush\n"));
 510                   if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, width * 4)))
 511                       goto error;
 512                   for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 513                   {
 514                       srcBmp->funcs->GetLine(srcBmp, ys, xSrc, width, dBuf);
 515                       patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, width, pBuf);
 516                       wDstPnt = dBuf;
 517                       wSrcPnt = dBuf;
 518                       wPatPnt = pBuf;
 519                       for(i = width; i > 0 ; i--)
 520                       {
 521                           *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, 0, rop);
 522                           wDstPnt++;
 523                       }
 524                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 525                   }
 526               }
 527               else if(useSrc)
 528               {
 529                   if(usePat)
 530                       MAYBE(TRACE("BitBlt use: src+pat - solid brush\n"));
 531                   else
 532                       MAYBE(TRACE("BitBlt use: src\n"));
 533                   for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 534                   {
 535                       srcBmp->funcs->GetLine(srcBmp, ys, xSrc, width, dBuf);
 536                       wDstPnt = dBuf;
 537                       wSrcPnt = dBuf;
 538                       for(i = width; i > 0 ; i--)
 539                       {
 540                           *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, 0, rop);
 541                           wDstPnt++;
 542                       }
 543                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 544                   }
 545               }
 546               else if(useDst && usePat && physDevDst->isBrushBitmap)
 547               {
 548                   MAYBE(TRACE("BitBlt use: dst+pat -- pattern brush\n"));
 549                   if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, width * 4)))
 550                       goto error;
 551                   for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 552                   {
 553                       dstBmp->funcs->GetLine(dstBmp, ys, xDst, width, dBuf);
 554                       patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, width, pBuf);
 555                       wDstPnt = dBuf;
 556                       wPatPnt = pBuf;
 557                       for(i = width; i > 0 ; i--)
 558                       {
 559                           *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, *wDstPnt, rop);
 560                           wDstPnt++;
 561                       }
 562                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 563                   }
 564               }
 565               else if(useDst)
 566               {
 567                   if(usePat)
 568                       MAYBE(TRACE("BitBlt use: dst+pat - solid brush\n"));
 569                   else
 570                       MAYBE(TRACE("BitBlt use: dst\n"));
 571                   for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 572                   {
 573                       dstBmp->funcs->GetLine(dstBmp, ys, xDst, width, dBuf);
 574                       wDstPnt = dBuf;
 575                       for(i = width; i > 0 ; i--)
 576                       {
 577                           *wDstPnt = _DIBDRV_ROP3(patColor, 0, *wDstPnt, rop);
 578                           wDstPnt++;
 579                       }
 580                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 581                   }
 582               }
 583               else if(usePat && physDevDst->isBrushBitmap)
 584               {
 585                   MAYBE(TRACE("BitBlt use: pat -- pattern brush\n"));
 586                   if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, width * 4)))
 587                       goto error;
 588                   for(ys = ySrc, yd = yDst; ys < ySrc+height; ys++, yd++)
 589                   {
 590                       patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, width, pBuf);
 591                       wDstPnt = dBuf;
 592                       wPatPnt = pBuf;
 593                       for(i = width; i > 0 ; i--)
 594                       {
 595                           *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, 0, rop);
 596                           wDstPnt++;
 597                       }
 598                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 599                   }
 600               }
 601               else if(usePat)
 602               {
 603                   MAYBE(TRACE("BitBlt use: pat -- solid brush -- rop is %02x, color is %08x\n", rop, patColor));
 604                   MAYBE(TRACE("Dest BMP is a '%s'\n", _DIBDRVBITMAP_GetFormatName(dstBmp)));
 605                   MAYBE(TRACE("xDst = %d, yDst = %d, width = %d, height = %d\n", xDst, yDst, width, height));
 606                   for(yd = yDst; yd < yDst+height; yd++)
 607                   {
 608                       wDstPnt = dBuf;
 609                       for(i = width; i > 0 ; i--)
 610                       {
 611                           *wDstPnt = _DIBDRV_ROP3(patColor, 0, 0, rop);
 612                           wDstPnt++;
 613                       }
 614                       dstBmp->funcs->PutLine(dstBmp, yd, xDst, width, dBuf);
 615                   }
 616               }
 617               else
 618                   ERR("What happened ?????? \n");
 619               break;
 620     } /* switch */
 621     res = TRUE;
 622 error:
 623     if(sBuf) HeapFree( GetProcessHeap(), 0, sBuf );
 624     if(dBuf) HeapFree( GetProcessHeap(), 0, dBuf );
 625     if(pBuf) HeapFree( GetProcessHeap(), 0, pBuf );
 626     return res;
 627 }
 628
 629 /* ------------------------------------------------------------*/
 630 /*                        STRETCHING PRIMITIVES                */
 631 BOOL _DIBDRV_StretchBlt_generic(DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst,
 632                     INT widthDst, INT heightDst, const DIBDRVPHYSDEV *physDevSrc,
 633                     INT xSrc, INT ySrc, int widthSrc, int heightSrc, DWORD rop)
 634 {
 635     int ys, yd;
 636     int i, delta;
 637     DWORD *dwBuf;
 638     DIBDRVBITMAP *dstBmp, *patBmp;
 639     const DIBDRVBITMAP *srcBmp;
 640     DWORD *wDstPnt, *wSrcPnt, *wPatPnt;
 641     BOOL usePat, useSrc, useDst;
 642     DWORD patColor;
 643     BOOL res = FALSE;
 644
 645     /* 32 bit RGB source and destination buffer, if needed */
 646     DWORD *sBufOrig = 0, *sBufStr = 0, *dBuf = 0, *pBuf = 0;
 647
 648     /* get elements usage */
 649     usePat = (((rop >> 4) & 0x0f0000) != (rop & 0x0f0000));
 650     useSrc = (((rop >> 2) & 0x330000) != (rop & 0x330000));
 651     useDst = (((rop >> 1) & 0x550000) != (rop & 0x550000));
 652
 653     /* sanity check -- MSN messenger crashes without */
 654     if(useSrc && !physDevSrc)
 655         return FALSE;
 656
 657     /* gets source, dest and pattern bitmaps, if available */
 658     if(usePat && physDevDst->isBrushBitmap)
 659         patBmp = &physDevDst->brushBmpCache;
 660     else
 661         patBmp = NULL;
 662
 663     if(useSrc)
 664         srcBmp = &physDevSrc->physBitmap;
 665     else
 666         srcBmp = NULL;
 667     dstBmp = &physDevDst->physBitmap;
 668
 669     /* gets pattern color, in case it's needed
 670        it's NOT the COLORREF value (colors are swapped
 671        NOR the pixel value (it's applied to a 32 BPP BI_RGB */
 672     if(usePat)
 673         patColor = SwapColors(physDevDst->brushColorref);
 674     else
 675         patColor = 0;
 676
 677     /* allocate 32 bit RGB destination buffer */
 678     if(!(dBuf = (DWORD *)HeapAlloc( GetProcessHeap(), 0, widthDst * 4)))
 679         goto error;
 680
 681     MAYBE(TRACE("dstBmp:%p(%s), xDst:%d, yDst:%d, widthDst:%d, heightDst:%d, srcBmp:%p(%s), xSrc:%d, ySrc:%d, , widthSrc:%d, heightSrc:%drop:%8x\n",
 682           dstBmp, _DIBDRVBITMAP_GetFormatName(dstBmp), xDst, yDst, widthDst, heightDst,
 683           srcBmp, _DIBDRVBITMAP_GetFormatName(srcBmp), xSrc, ySrc, widthSrc, heightSrc, rop));
 684
 685     /* some simple ROPs optimizations */
 686     switch(rop)
 687     {
 688         case BLACKNESS:
 689             MAYBE(TRACE("BLACKNESS\n"));
 690             memset(dBuf, 0x00, widthDst * 4);
 691             for(yd = yDst; yd < yDst+heightDst; yd++)
 692                 dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 693             break;
 694
 695         case WHITENESS:
 696             MAYBE(TRACE("WHITENESS\n"));
 697             for(dwBuf = dBuf, i = widthDst; i; i--)
 698                 *dwBuf++ = 0x00ffffff;
 699             for(yd = yDst; yd < yDst+heightDst; yd++)
 700                 dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 701             break;
 702
 703         case SRCCOPY:
 704             MAYBE(TRACE("SRCCOPY\n"));
 705             sBufOrig = HeapAlloc(GetProcessHeap(), 0, widthSrc * 4);
 706             if(heightSrc > heightDst)
 707             {
 708                 ys = 0;
 709                 yd = 0;
 710                 delta = 0;
 711                 while(yd < heightDst)
 712                 {
 713                     srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 714                     StretchLine(dBuf, widthDst, sBufOrig, widthSrc);
 715                     dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 716                     while(delta < heightSrc)
 717                     {
 718                         ys++;
 719                         delta += heightDst;
 720                     }
 721                     delta -= heightSrc;
 722                     yd++;
 723                 }
 724             }
 725             else if(heightSrc < heightDst)
 726             {
 727                 ys = 0;
 728                 yd = 0;
 729                 delta = 0;
 730                 while(ys < heightSrc)
 731                 {
 732                     srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 733                     StretchLine(dBuf, widthDst, sBufOrig, widthSrc);
 734                     while(delta < heightDst)
 735                     {
 736                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 737                         yd++;
 738                         delta += heightSrc;
 739                     }
 740                     delta -= heightDst;
 741                     ys++;
 742                 }
 743             }
 744             else
 745             {
 746                 for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
 747                 {
 748                     srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBufOrig);
 749                     StretchLine(dBuf, widthDst, sBufOrig, widthSrc);
 750                     dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 751                 }
 752             }
 753             break;
 754
 755         /* fallback for generic ROP operation */
 756         default:
 757             rop >>= 16;
 758             if(useSrc && useDst && usePat && physDevDst->isBrushBitmap)
 759             {
 760                 MAYBE(TRACE("StretchBlt use: src+dst+pat - pattern brush\n"));
 761                 if(!(sBufOrig = HeapAlloc(GetProcessHeap(), 0, widthSrc * 4)))
 762                     goto error;
 763                 if(!(sBufStr = HeapAlloc(GetProcessHeap(), 0, widthDst * 4)))
 764                     goto error;
 765                 if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, widthDst * 4)))
 766                     goto error;
 767                 if(heightSrc > heightDst)
 768                 {
 769                     ys = 0;
 770                     yd = 0;
 771                     delta = 0;
 772                     while(yd < heightDst)
 773                     {
 774                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 775                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 776                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 777                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
 778                         wDstPnt = dBuf;
 779                         wSrcPnt = sBufStr;
 780                         wPatPnt = pBuf;
 781                         for(i = widthDst; i > 0 ; i--)
 782                         {
 783                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, *wDstPnt, rop);
 784                             wDstPnt++;
 785                         }
 786                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 787                         while(delta < heightSrc)
 788                         {
 789                             ys++;
 790                             delta += heightDst;
 791                         }
 792                         delta -= heightSrc;
 793                         yd++;
 794                     }
 795                 }
 796                 else if(heightSrc < heightDst)
 797                 {
 798                     ys = 0;
 799                     yd = 0;
 800                     delta = 0;
 801                     while(ys < heightSrc)
 802                     {
 803                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 804                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 805                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 806                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
 807                         while(delta < heightDst)
 808                         {
 809                             wDstPnt = dBuf;
 810                             wSrcPnt = sBufStr;
 811                             wPatPnt = pBuf;
 812                             for(i = widthDst; i > 0 ; i--)
 813                             {
 814                                 *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, *wDstPnt, rop);
 815                                 wDstPnt++;
 816                             }
 817                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 818                             yd++;
 819                             delta += heightSrc;
 820                         }
 821                         delta -= heightDst;
 822                         ys++;
 823                     }
 824                 }
 825                 else
 826                 {
 827                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
 828                     {
 829                         srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBufOrig);
 830                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 831                         dstBmp->funcs->GetLine(dstBmp, ys, xDst, widthDst, dBuf);
 832                         patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, widthDst, pBuf);
 833                         wDstPnt = dBuf;
 834                         wSrcPnt = sBufStr;
 835                         wPatPnt = pBuf;
 836                         for(i = widthDst; i > 0 ; i--)
 837                         {
 838                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, *wDstPnt, rop);
 839                             wDstPnt++;
 840                         }
 841                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 842                     }
 843                 }
 844             }
 845             else if(useSrc && useDst)
 846             {
 847                 if(usePat)
 848                     MAYBE(TRACE("StretchBlt use: src+dst+pat - solid brush\n"));
 849                 else
 850                     MAYBE(TRACE("StretchBlt use: src+dst\n"));
 851                 if(!(sBufOrig = HeapAlloc(GetProcessHeap(), 0, widthSrc * 4)))
 852                     goto error;
 853                 if(!(sBufStr = HeapAlloc(GetProcessHeap(), 0, widthDst * 4)))
 854                     goto error;
 855                 if(heightSrc > heightDst)
 856                 {
 857                     ys = 0;
 858                     yd = 0;
 859                     delta = 0;
 860                     while(yd < heightDst)
 861                     {
 862                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 863                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 864                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 865                         wDstPnt = dBuf;
 866                         wSrcPnt = sBufStr;
 867                         for(i = widthDst; i > 0 ; i--)
 868                         {
 869                             *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, *wDstPnt, rop);
 870                             wDstPnt++;
 871                         }
 872                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 873                         while(delta < heightSrc)
 874                         {
 875                             ys++;
 876                             delta += heightDst;
 877                         }
 878                         delta -= heightSrc;
 879                         yd++;
 880                     }
 881                 }
 882                 else if(heightSrc < heightDst)
 883                 {
 884                     ys = 0;
 885                     yd = 0;
 886                     delta = 0;
 887                     while(ys < heightSrc)
 888                     {
 889                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 890                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 891                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 892                         while(delta < heightDst)
 893                         {
 894                             wDstPnt = dBuf;
 895                             wSrcPnt = sBufStr;
 896                             for(i = widthDst; i > 0 ; i--)
 897                             {
 898                                 *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, *wDstPnt, rop);
 899                                 wDstPnt++;
 900                             }
 901                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 902                             yd++;
 903                             delta += heightSrc;
 904                         }
 905                         delta -= heightDst;
 906                         ys++;
 907                     }
 908                 }
 909                 else
 910                 {
 911                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
 912                     {
 913                         srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBufOrig);
 914                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 915                         dstBmp->funcs->GetLine(dstBmp, ys, xDst, widthDst, dBuf);
 916                         wDstPnt = dBuf;
 917                         wSrcPnt = sBufStr;
 918                         for(i = widthDst; i > 0 ; i--)
 919                         {
 920                             *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, *wDstPnt, rop);
 921                             wDstPnt++;
 922                         }
 923                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
 924                     }
 925                 }
 926             }
 927             else if(useSrc && usePat && physDevDst->isBrushBitmap)
 928             {
 929                 MAYBE(TRACE("StretchBlt use: src+pat -- pattern brush\n"));
 930                 if(!(sBufOrig = HeapAlloc(GetProcessHeap(), 0, widthSrc * 4)))
 931                     goto error;
 932                 if(!(sBufStr = HeapAlloc(GetProcessHeap(), 0, widthDst * 4)))
 933                     goto error;
 934                 if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, widthDst * 4)))
 935                     goto error;
 936                 if(heightSrc > heightDst)
 937                 {
 938                     ys = 0;
 939                     yd = 0;
 940                     delta = 0;
 941                     while(yd < heightDst)
 942                     {
 943                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 944                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 945                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
 946                         wDstPnt = dBuf;
 947                         wSrcPnt = sBufStr;
 948                         wPatPnt = pBuf;
 949                         for(i = widthDst; i > 0 ; i--)
 950                         {
 951                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, 0, rop);
 952                             wDstPnt++;
 953                         }
 954                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 955                         while(delta < heightSrc)
 956                         {
 957                             ys++;
 958                             delta += heightDst;
 959                         }
 960                         delta -= heightSrc;
 961                         yd++;
 962                     }
 963                 }
 964                 else if(heightSrc < heightDst)
 965                 {
 966                     ys = 0;
 967                     yd = 0;
 968                     delta = 0;
 969                     while(ys < heightSrc)
 970                     {
 971                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
 972                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 973                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
 974                         while(delta < heightDst)
 975                         {
 976                             wDstPnt = dBuf;
 977                             wSrcPnt = sBufStr;
 978                             wPatPnt = pBuf;
 979                             for(i = widthDst; i > 0 ; i--)
 980                             {
 981                                 *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, 0, rop);
 982                                 wDstPnt++;
 983                             }
 984                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
 985                             yd++;
 986                             delta += heightSrc;
 987                         }
 988                         delta -= heightDst;
 989                         ys++;
 990                     }
 991                 }
 992                 else
 993                 {
 994                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
 995                     {
 996                         srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBufOrig);
 997                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
 998                         patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, widthDst, pBuf);
 999                         wDstPnt = dBuf;
1000                         wSrcPnt = sBufStr;
1001                         wPatPnt = pBuf;
1002                         for(i = widthDst; i > 0 ; i--)
1003                         {
1004                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, *wSrcPnt++, 0, rop);
1005                             wDstPnt++;
1006                         }
1007                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
1008                     }
1009                 }
1010             }
1011             else if(useSrc)
1012             {
1013                 if(usePat)
1014                     MAYBE(TRACE("StretchBlt use: src+pat - solid brush\n"));
1015                 else
1016                     MAYBE(TRACE("StretchBlt use: src\n"));
1017                 if(!(sBufOrig = HeapAlloc(GetProcessHeap(), 0, widthSrc * 4)))
1018                     goto error;
1019                 if(!(sBufStr = HeapAlloc(GetProcessHeap(), 0, widthDst * 4)))
1020                     goto error;
1021                 if(heightSrc > heightDst)
1022                 {
1023                     ys = 0;
1024                     yd = 0;
1025                     delta = 0;
1026                     while(yd < heightDst)
1027                     {
1028                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
1029                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
1030                         wDstPnt = dBuf;
1031                         wSrcPnt = sBufStr;
1032                         for(i = widthDst; i > 0 ; i--)
1033                         {
1034                             *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, 0, rop);
1035                             wDstPnt++;
1036                         }
1037                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1038                         while(delta < heightSrc)
1039                         {
1040                             ys++;
1041                             delta += heightDst;
1042                         }
1043                         delta -= heightSrc;
1044                         yd++;
1045                     }
1046                 }
1047                 else if(heightSrc < heightDst)
1048                 {
1049                     ys = 0;
1050                     yd = 0;
1051                     delta = 0;
1052                     while(ys < heightSrc)
1053                     {
1054                         srcBmp->funcs->GetLine(srcBmp, ys + ySrc, xSrc, widthSrc, sBufOrig);
1055                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
1056                         while(delta < heightDst)
1057                         {
1058                             wDstPnt = dBuf;
1059                             wSrcPnt = sBufStr;
1060                             for(i = widthDst; i > 0 ; i--)
1061                             {
1062                                 *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, 0, rop);
1063                                 wDstPnt++;
1064                             }
1065                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1066                             yd++;
1067                             delta += heightSrc;
1068                         }
1069                         delta -= heightDst;
1070                         ys++;
1071                     }
1072                 }
1073                 else
1074                 {
1075                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
1076                     {
1077                         srcBmp->funcs->GetLine(srcBmp, ys, xSrc, widthSrc, sBufOrig);
1078                         StretchLine(sBufStr, widthDst, sBufOrig, widthSrc);
1079                         wDstPnt = dBuf;
1080                         wSrcPnt = sBufStr;
1081                         for(i = widthDst; i > 0 ; i--)
1082                         {
1083                             *wDstPnt = _DIBDRV_ROP3(patColor, *wSrcPnt++, 0, rop);
1084                             wDstPnt++;
1085                         }
1086                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
1087                     }
1088                 }
1089             }
1090             else if(useDst && usePat && physDevDst->isBrushBitmap)
1091             {
1092                 MAYBE(TRACE("StretchBlt use: dst+pat -- pattern brush\n"));
1093                 if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, widthDst * 4)))
1094                     goto error;
1095                 if(heightSrc > heightDst)
1096                 {
1097                     ys = 0;
1098                     yd = 0;
1099                     delta = 0;
1100                     while(yd < heightDst)
1101                     {
1102                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1103                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
1104                         wDstPnt = dBuf;
1105                         wPatPnt = pBuf;
1106                         for(i = widthDst; i > 0 ; i--)
1107                         {
1108                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, *wDstPnt, rop);
1109                             wDstPnt++;
1110                         }
1111                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1112                         while(delta < heightSrc)
1113                         {
1114                             ys++;
1115                             delta += heightDst;
1116                         }
1117                         delta -= heightSrc;
1118                         yd++;
1119                     }
1120                 }
1121                 else if(heightSrc < heightDst)
1122                 {
1123                     ys = 0;
1124                     yd = 0;
1125                     delta = 0;
1126                     while(ys < heightSrc)
1127                     {
1128                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1129                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
1130                         while(delta < heightDst)
1131                         {
1132                             wDstPnt = dBuf;
1133                             wPatPnt = pBuf;
1134                             for(i = widthDst; i > 0 ; i--)
1135                             {
1136                                 *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, *wDstPnt, rop);
1137                                 wDstPnt++;
1138                             }
1139                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1140                             yd++;
1141                             delta += heightSrc;
1142                         }
1143                         delta -= heightDst;
1144                         ys++;
1145                     }
1146                 }
1147                 else
1148                 {
1149                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
1150                     {
1151                         dstBmp->funcs->GetLine(dstBmp, ys, xDst, widthDst, dBuf);
1152                         patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, widthDst, pBuf);
1153                         wDstPnt = dBuf;
1154                         wPatPnt = pBuf;
1155                         for(i = widthDst; i > 0 ; i--)
1156                         {
1157                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, *wDstPnt, rop);
1158                             wDstPnt++;
1159                         }
1160                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
1161                     }
1162                 }
1163             }
1164             else if(useDst)
1165             {
1166                 if(usePat)
1167                     MAYBE(TRACE("StretchBlt use: dst+pat - solid brush\n"));
1168                 else
1169                     MAYBE(TRACE("StretchBlt use: dst\n"));
1170                 if(heightSrc > heightDst)
1171                 {
1172                     ys = 0;
1173                     yd = 0;
1174                     delta = 0;
1175                     while(yd < heightDst)
1176                     {
1177                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1178                         wDstPnt = dBuf;
1179                         for(i = widthDst; i > 0 ; i--)
1180                         {
1181                             *wDstPnt = _DIBDRV_ROP3(patColor, 0, *wDstPnt, rop);
1182                             wDstPnt++;
1183                         }
1184                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1185                         while(delta < heightSrc)
1186                         {
1187                             ys++;
1188                             delta += heightDst;
1189                         }
1190                         delta -= heightSrc;
1191                         yd++;
1192                     }
1193                 }
1194                 else if(heightSrc < heightDst)
1195                 {
1196                     ys = 0;
1197                     yd = 0;
1198                     delta = 0;
1199                     while(ys < heightSrc)
1200                     {
1201                         dstBmp->funcs->GetLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1202                         while(delta < heightDst)
1203                         {
1204                             wDstPnt = dBuf;
1205                             for(i = widthDst; i > 0 ; i--)
1206                             {
1207                                 *wDstPnt = _DIBDRV_ROP3(patColor, 0, *wDstPnt, rop);
1208                                 wDstPnt++;
1209                             }
1210                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1211                             yd++;
1212                             delta += heightSrc;
1213                         }
1214                         delta -= heightDst;
1215                         ys++;
1216                     }
1217                 }
1218                 else
1219                 {
1220                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
1221                     {
1222                         dstBmp->funcs->GetLine(dstBmp, ys, xDst, widthDst, dBuf);
1223                         wDstPnt = dBuf;
1224                         for(i = widthDst; i > 0 ; i--)
1225                         {
1226                             *wDstPnt = _DIBDRV_ROP3(patColor, 0, *wDstPnt, rop);
1227                             wDstPnt++;
1228                         }
1229                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
1230                     }
1231                 }
1232             }
1233             else if(usePat && physDevDst->isBrushBitmap)
1234             {
1235                 MAYBE(TRACE("StretchBlt use: pat -- pattern brush\n"));
1236                 if(!(pBuf = HeapAlloc( GetProcessHeap(), 0, widthDst * 4)))
1237                     goto error;
1238                 if(heightSrc > heightDst)
1239                 {
1240                     ys = 0;
1241                     yd = 0;
1242                     delta = 0;
1243                     while(yd < heightDst)
1244                     {
1245                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
1246                         wDstPnt = dBuf;
1247                         wPatPnt = pBuf;
1248                         for(i = widthDst; i > 0 ; i--)
1249                         {
1250                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, 0, rop);
1251                             wDstPnt++;
1252                         }
1253                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1254                         while(delta < heightSrc)
1255                         {
1256                             ys++;
1257                             delta += heightDst;
1258                         }
1259                         delta -= heightSrc;
1260                         yd++;
1261                     }
1262                 }
1263                 else if(heightSrc < heightDst)
1264                 {
1265                     ys = 0;
1266                     yd = 0;
1267                     delta = 0;
1268                     while(ys < heightSrc)
1269                     {
1270                         patBmp->funcs->GetLine(patBmp, (yd + yDst)%patBmp->height, 0, widthDst, pBuf);
1271                         while(delta < heightDst)
1272                         {
1273                             wDstPnt = dBuf;
1274                             wPatPnt = pBuf;
1275                             for(i = widthDst; i > 0 ; i--)
1276                             {
1277                                 *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, 0, rop);
1278                                 wDstPnt++;
1279                             }
1280                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1281                             yd++;
1282                             delta += heightSrc;
1283                         }
1284                         delta -= heightDst;
1285                         ys++;
1286                     }
1287                 }
1288                 else
1289                 {
1290                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
1291                     {
1292                         patBmp->funcs->GetLine(patBmp, ys%patBmp->height, 0, widthDst, pBuf);
1293                         wDstPnt = dBuf;
1294                         wPatPnt = pBuf;
1295                         for(i = widthDst; i > 0 ; i--)
1296                         {
1297                             *wDstPnt = _DIBDRV_ROP3(*wPatPnt++, 0, 0, rop);
1298                             wDstPnt++;
1299                         }
1300                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
1301                     }
1302                 }
1303             }
1304             else if(usePat)
1305             {
1306                 MAYBE(TRACE("StretchBlt use: pat -- solid brush -- rop is %02x, color is %08x\n", rop, patColor));
1307                 MAYBE(TRACE("Dest BMP is a '%s'\n", _DIBDRVBITMAP_GetFormatName(dstBmp)));
1308                 MAYBE(TRACE("xDst = %d, yDst = %d, widthDst = %d, heightDst = %d\n", xDst, yDst, widthDst, heightDst));
1309                 if(heightSrc > heightDst)
1310                 {
1311                     ys = 0;
1312                     yd = 0;
1313                     delta = 0;
1314                     while(yd < heightDst)
1315                     {
1316                         wDstPnt = dBuf;
1317                         for(i = widthDst; i > 0 ; i--)
1318                         {
1319                             *wDstPnt = _DIBDRV_ROP3(patColor, 0, 0, rop);
1320                             wDstPnt++;
1321                         }
1322                         dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1323                         while(delta < heightSrc)
1324                         {
1325                             ys++;
1326                             delta += heightDst;
1327                         }
1328                         delta -= heightSrc;
1329                         yd++;
1330                     }
1331                 }
1332                 else if(heightSrc < heightDst)
1333                 {
1334                     ys = 0;
1335                     yd = 0;
1336                     delta = 0;
1337                     while(ys < heightSrc)
1338                     {
1339                         while(delta < heightDst)
1340                         {
1341                             wDstPnt = dBuf;
1342                             for(i = widthDst; i > 0 ; i--)
1343                             {
1344                                 *wDstPnt = _DIBDRV_ROP3(patColor, 0, 0, rop);
1345                                 wDstPnt++;
1346                             }
1347                             dstBmp->funcs->PutLine(dstBmp, yd + yDst, xDst, widthDst, dBuf);
1348                             yd++;
1349                             delta += heightSrc;
1350                         }
1351                         delta -= heightDst;
1352                         ys++;
1353                     }
1354                 }
1355                 else
1356                 {
1357                     for(ys = ySrc, yd = yDst; ys < ySrc+heightSrc; ys++, yd++)
1358                     {
1359                         wDstPnt = dBuf;
1360                         for(i = widthDst; i > 0 ; i--)
1361                         {
1362                             *wDstPnt = _DIBDRV_ROP3(patColor, 0, 0, rop);
1363                             wDstPnt++;
1364                         }
1365                         dstBmp->funcs->PutLine(dstBmp, yd, xDst, widthDst, dBuf);
1366                     }
1367                 }
1368             }
1369             else
1370                 ERR("What happened ?????? \n");
1371             break;
1372     } /* switch */
1373     res = TRUE;
1374 error:
1375     if(sBufOrig) HeapFree( GetProcessHeap(), 0, sBufOrig );
1376     if(sBufStr)  HeapFree( GetProcessHeap(), 0, sBufStr );
1377     if(dBuf)     HeapFree( GetProcessHeap(), 0, dBuf );
1378     if(pBuf)     HeapFree( GetProcessHeap(), 0, pBuf );
1379     return res;
1380 }