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