dlls/winedib.drv/bitblt.c

   1 /*
   2  * DIBDRV bit-blit operations
   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 void intSwap(int *a, int *b)
  29 {
  30     int tmp;
  31     tmp = *a;
  32     *a = *b;
  33     *b = tmp;
  34 }
  35
  36 static inline void setRect(RECT *r, int x1, int y1, int x2, int y2)
  37 {
  38     r->left   = x1;
  39     r->top    = y1;
  40     r->right  = x2;
  41     r->bottom = y2;
  42 }
  43
  44 static inline void setPoint(POINT *p, int x, int y)
  45 {
  46     p->x = x;
  47     p->y = y;
  48 }
  49
  50 static inline void setSize(SIZE *sz, int cx, int cy)
  51 {
  52     sz->cx = cx;
  53     sz->cy = cy;
  54 }
  55
  56 /* clips a source and destination areas to their respective clip rectangles
  57    returning both source and dest modified; result is TRUE if clipping
  58    leads to a non null rectangle, FALSE otherwise */
  59 static BOOL BitBlt_ClipAreas(POINT *ps, POINT *pd, SIZE *sz, RECT*srcClip, RECT*dstClip)
  60 {
  61     int xs1, ys1, xs2, ys2;
  62     int xsc1, ysc1, xsc2, ysc2;
  63     int xd1, yd1, xd2, yd2;
  64     int xdc1, ydc1, xdc2, ydc2;
  65     int w, h, dx, dy;
  66
  67     /* extract sizes */
  68     w = sz->cx; h = sz->cy;
  69
  70     /* if sizes null or negative, just return false */
  71     if(w <= 0 || h <= 0)
  72         return FALSE;
  73
  74     /* extract dest area data */
  75     xd1 = pd->x;
  76     yd1 = pd->y;
  77     xd2 = xd1 + w;
  78     yd2 = yd1 + h;
  79
  80     /* extract source data */
  81     xs1 = ps->x;
  82     ys1 = ps->y;
  83     xs2 = xs1 + w;
  84     ys2 = ys1 + h;
  85
  86     /* if source clip area is not null, do first clipping on it */
  87     if(srcClip)
  88     {
  89         /* extract source clipping area */
  90         xsc1 = srcClip->left;
  91         ysc1 = srcClip->top;
  92         xsc2 = srcClip->right;
  93         ysc2 = srcClip->bottom;
  94
  95         /* order clip area rectangle points */
  96         if(xsc1 > xsc2) intSwap(&xsc1, &xsc2);
  97         if(ysc1 > ysc2) intSwap(&ysc1, &ysc2);
  98
  99         /* clip on source clipping start point */
 100         if(xs1 < xsc1) { dx = xsc1 - xs1; w -= dx; xd1 += dx; xs1 = xsc1; }
 101         if(ys1 < ysc1) { dy = ysc1 - ys1; h -= dy; yd1 += dy; ys1 = ysc1; }
 102
 103         /* clip on source clipping end point */
 104         if(xs2 > xsc2) { dx = xs2 - xsc2; w -= dx; xd2 -= dx; xs2 = xsc2; }
 105         if(ys2 > ysc2) { dy = ys2 - ysc2; h -= dy; yd2 -= dy; ys2 = ysc2; }
 106
 107         /* if already zero area, return false */
 108         if(w <= 0 || h <= 0)
 109             return FALSE;
 110     }
 111     /* now do clipping on destination area */
 112
 113     if(dstClip)
 114     {
 115         /* extract destination clipping area */
 116         xdc1 = dstClip->left;
 117         ydc1 = dstClip->top;
 118         xdc2 = dstClip->right;
 119         ydc2 = dstClip->bottom;
 120
 121         /* order clip area rectangle points */
 122         if(xdc1 > xdc2) intSwap(&xdc1, &xdc2);
 123         if(ydc1 > ydc2) intSwap(&ydc1, &ydc2);
 124
 125         /* clip on dest clipping start point */
 126         if(xd1 < xdc1) { dx = xdc1 - xd1; w -= dx; xs1 += dx; xd1 = xdc1; }
 127         if(yd1 < ydc1) { dy = ydc1 - yd1; h -= dy; ys1 += dy; yd1 = ydc1; }
 128
 129         /* clip on dest clipping end point */
 130         if(xd2 > xdc2) { dx = xd2 - xdc2; w -= dx; xs2 -= dx; xd2 = xdc2; }
 131         if(yd2 > ydc2) { dy = yd2 - ydc2; h -= dy; ys2 -= dy; yd2 = ydc2; }
 132
 133         /* if already zero area, return false */
 134         if(w <= 0 || h <= 0)
 135             return FALSE;
 136     }
 137
 138     /* sets clipped/translated points and sizes and returns TRUE */
 139     ps->x = xs1; ps->y = ys1;
 140     pd->x = xd1; pd->y = yd1;
 141     sz->cx = w; sz->cy = h;
 142
 143     return TRUE;
 144
 145 }
 146
 147
 148 /* clips a source and destination areas to their respective clip rectangles
 149    returning both source and dest modified; result is TRUE if clipping
 150    leads to a non null rectangle, FALSE otherwise */
 151 static BOOL StretchBlt_ClipAreas(POINT *ps, POINT *pd, SIZE *szSrc, SIZE *szDst, RECT*srcClip, RECT*dstClip)
 152 {
 153     int xs1, ys1, xs2, ys2;
 154     int xsc1, ysc1, xsc2, ysc2;
 155     int xd1, yd1, xd2, yd2;
 156     int xdc1, ydc1, xdc2, ydc2;
 157     int ws, hs, wd, hd, dx, dy;
 158     int mulh, divh, mulv, divv;
 159
 160     /* extract sizes */
 161     ws = szSrc->cx; hs = szSrc->cy;
 162     wd = szDst->cx; hd = szDst->cy;
 163
 164     /* if sizes null or negative, just return false */
 165     /* FIXME : add support for mirror stretch */
 166     if(ws <= 0 || hs <= 0 || wd <= 0 || hd <= 0)
 167         return FALSE;
 168
 169     /* stores scaling factors from source rect to dest one */
 170     mulh = wd; divh = ws;
 171     mulv = hd; divv = hs;
 172
 173     /* extract dest area data */
 174     xd1 = pd->x;
 175     yd1 = pd->y;
 176     xd2 = xd1 + wd;
 177     yd2 = yd1 + hd;
 178
 179     /* extract source data */
 180     xs1 = ps->x;
 181     ys1 = ps->y;
 182     xs2 = xs1 + ws;
 183     ys2 = ys1 + hs;
 184
 185     /* if source clip area is not null, do first clipping on it */
 186     if(srcClip)
 187     {
 188         /* extract source clipping area */
 189         xsc1 = srcClip->left;
 190         ysc1 = srcClip->top;
 191         xsc2 = srcClip->right;
 192         ysc2 = srcClip->bottom;
 193
 194         /* order clip area rectangle points */
 195         if(xsc1 > xsc2) intSwap(&xsc1, &xsc2);
 196         if(ysc1 > ysc2) intSwap(&ysc1, &ysc2);
 197
 198         /* clip on source clipping start point */
 199         if(xs1 < xsc1) { dx = xsc1 - xs1; ws -= dx; xd1 += MulDiv(dx, mulh, divh); xs1 = xsc1; }
 200         if(ys1 < ysc1) { dy = ysc1 - ys1; hs -= dy; yd1 += MulDiv(dy, mulv, divv); ys1 = ysc1; }
 201
 202         /* clip on source clipping end point */
 203         if(xs2 > xsc2) { dx = xs2 - xsc2; ws -= dx; xd2 -= MulDiv(dx, mulh, divh); xs2 = xsc2; }
 204         if(ys2 > ysc2) { dy = ys2 - ysc2; hs -= dy; yd2 -= MulDiv(dy, mulv, divv); ys2 = ysc2; }
 205
 206         /* if already zero area, return false */
 207         if(ws <= 0 || hs <= 0)
 208             return FALSE;
 209         wd = xd2 - xd1;
 210         hd = yd2 - yd1;
 211     }
 212     /* now do clipping on destination area */
 213
 214     if(dstClip)
 215     {
 216         /* extract destination clipping area */
 217         xdc1 = dstClip->left;
 218         ydc1 = dstClip->top;
 219         xdc2 = dstClip->right;
 220         ydc2 = dstClip->bottom;
 221
 222         /* order clip area rectangle points */
 223         if(xdc1 > xdc2) intSwap(&xdc1, &xdc2);
 224         if(ydc1 > ydc2) intSwap(&ydc1, &ydc2);
 225
 226         /* clip on dest clipping start point */
 227         if(xd1 < xdc1) { dx = xdc1 - xd1; wd -= dx; xs1 += MulDiv(dx, divh, mulh); xd1 = xdc1; }
 228         if(yd1 < ydc1) { dy = ydc1 - yd1; hd -= dy; ys1 += MulDiv(dy, divv, mulv); yd1 = ydc1; }
 229
 230         /* clip on dest clipping end point */
 231         if(xd2 > xdc2) { dx = xd2 - xdc2; wd -= dx; xs2 -= MulDiv(dx, divh, mulh); xd2 = xdc2; }
 232         if(yd2 > ydc2) { dy = yd2 - ydc2; hd -= dy; ys2 -= MulDiv(dy, divv, mulv); yd2 = ydc2; }
 233
 234         /* if already zero area, return false */
 235         if(wd <= 0 || hd <= 0)
 236             return FALSE;
 237
 238         ws = xs2 - xs1;
 239         hs = ys2 - ys1;
 240     }
 241
 242     /* sets clipped/translated points and sizes and returns TRUE */
 243     ps->x = xs1; ps->y = ys1;
 244     pd->x = xd1; pd->y = yd1;
 245     szSrc->cx = ws; szSrc->cy = hs;
 246     szDst->cx = wd; szDst->cy = hd;
 247
 248     return TRUE;
 249
 250 }
 251
 252 /***********************************************************************
 253  *           _DIBDRV_InternalAlphaBlend
 254  */
 255 BOOL _DIBDRV_InternalAlphaBlend( DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
 256                         DIBDRVPHYSDEV *physDevSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
 257                         BLENDFUNCTION blendfn)
 258 {
 259     BOOL res;
 260     POINT pd, ps;
 261     SIZE szSrc, szDst;
 262     int iRec;
 263     RECT dstClip, srcClip;
 264
 265     /* first clip on physical DC sizes */
 266     setPoint(&pd, xDst, yDst);
 267     setPoint(&ps, xSrc, ySrc);
 268     setSize(&szDst, widthDst, heightDst);
 269     setSize(&szSrc, widthSrc, heightSrc);
 270     setRect(&dstClip, 0, 0, physDevDst->physBitmap.width, physDevDst->physBitmap.height);
 271     if(physDevSrc)
 272     {
 273         setRect(&srcClip, 0, 0, physDevSrc->physBitmap.width, physDevSrc->physBitmap.height);
 274         res = StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, &srcClip, &dstClip);
 275     }
 276     else
 277         res = StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, 0, &dstClip);
 278     if(!res)
 279         return FALSE;
 280     xDst = pd.x; yDst = pd.y;
 281     xSrc = ps.x; ySrc = ps.y;
 282     widthDst = szDst.cx; heightDst = szDst.cy;
 283     widthSrc = szSrc.cx; heightSrc = szSrc.cy;
 284
 285     /* then, do blitting for each dest clip area (no clipping on source) */
 286     res = FALSE;
 287     for(iRec = 0; iRec < physDevDst->regionRectCount; iRec++)
 288     {
 289         RECT *r = physDevDst->regionRects + iRec;
 290         setRect(&dstClip, r->left, r->top, r->right, r->bottom);
 291         setPoint(&pd, xDst, yDst);
 292         setPoint(&ps, xSrc, ySrc);
 293         setSize(&szDst, widthDst, heightDst);
 294         setSize(&szSrc, widthSrc, heightSrc);
 295         if(!StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, 0, &dstClip))
 296             continue;
 297         if(physDevDst->physBitmap.funcs->AlphaBlend(physDevDst, pd.x, pd.y, szDst.cx, szDst.cy,
 298                                                     physDevSrc, ps.x, ps.y, szSrc.cx, szSrc.cy, blendfn))
 299             res = TRUE;
 300     }
 301     return res;
 302 }
 303
 304 /***********************************************************************
 305  *           DIBDRV_AlphaBlend
 306  */
 307 BOOL DIBDRV_AlphaBlend( DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
 308                         DIBDRVPHYSDEV *physDevSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
 309                         BLENDFUNCTION blendfn)
 310 {
 311     BOOL res;
 312
 313     POINT pd = {xDst, yDst};
 314     POINT ps = {xSrc, ySrc};
 315     SIZE szDst = {widthDst, heightDst};
 316     SIZE szSrc = {widthSrc, heightSrc};
 317
 318     MAYBE(TRACE("physDevDst:%p(%s%s), xDst:%d, yDst:%d, widthDst:%d, heightDst:%d, physDevSrc:%p(%s%s), xSrc:%d, ySrc:%d, widthSrc:%d, heightSrc:%d\n",
 319           physDevDst, physDevDst->hasDIB ? "DIB-" : "DDB", physDevDst->hasDIB ? _DIBDRVBITMAP_GetFormatName(&physDevDst->physBitmap) : "",
 320           xDst, yDst, widthDst, heightDst,
 321           physDevSrc, physDevSrc->hasDIB ? "DIB-" : "DDB", physDevSrc->hasDIB ? _DIBDRVBITMAP_GetFormatName(&physDevSrc->physBitmap) : "",
 322           xSrc, ySrc, widthSrc, heightSrc));
 323
 324
 325     /* if sizes are null or negative, returns false */
 326     if(widthSrc <= 0 || heightSrc <= 0 || widthDst <= 0 || heightDst <= 0)
 327     {
 328         res = FALSE;
 329         goto fin;
 330     }
 331
 332     /* source sould be a 32 bit DIB */
 333     if(!physDevSrc)
 334     {
 335         FIXME("Null source bitmap -- shouldn't happen\n");
 336         res = FALSE;
 337         goto fin;
 338     }
 339     else if(!physDevSrc->hasDIB)
 340     {
 341         FIXME("DDB source bitmap -- shouldn't happen\n");
 342         res = FALSE;
 343         goto fin;
 344     }
 345
 346     if(physDevDst->hasDIB)
 347     {
 348         /* DIB section selected in dest DC, use DIB Engine */
 349         MAYBE(TRACE("Blending DIB->DIB\n"));
 350         res = _DIBDRV_InternalAlphaBlend(physDevDst, xDst, yDst, widthDst, heightDst,
 351                                          physDevSrc, xSrc, ySrc, widthSrc, heightSrc, blendfn);
 352     }
 353     else
 354     {
 355         /* DDB selected on dest DC -- must double-convert */
 356         HBITMAP tmpDIB, stock;
 357         HDC tmpDC;
 358         RECT srcClip = {0, 0, physDevSrc->physBitmap.width, physDevSrc->physBitmap.height};
 359         MAYBE(TRACE("Blending DIB->DDB\n"));
 360
 361         /* clip blit area */
 362         res = StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, &srcClip, 0);
 363         if(!res)
 364             goto fin;
 365         xDst = pd.x; yDst = pd.y; widthDst = szDst.cx; heightDst = szDst.cy;
 366         xSrc = ps.x; ySrc = ps.y; widthSrc = szSrc.cx; heightSrc = szSrc.cy;
 367
 368         /* converts dest DDB onto a temporary DIB -- just the needed part */
 369         tmpDIB = _DIBDRV_ConvertDevDDBtoDIB(physDevDst->hdc, physDevSrc->hdc, xDst, yDst, widthDst, heightDst);
 370         if(!tmpDIB)
 371         {
 372             ERR("Couldn't convert dest DDB to DIB\n");
 373             res = FALSE;
 374             goto fin;
 375         }
 376
 377         /* selects the temporary DIB into a temporary DC */
 378         tmpDC = CreateCompatibleDC(physDevDst->hdc);
 379         if(!tmpDC)
 380         {
 381             ERR("Couldn't create temporary DC\n");
 382             DeleteObject(tmpDIB);
 383             res = FALSE;
 384             goto fin;
 385         }
 386         stock = SelectObject(tmpDC, tmpDIB);
 387         if(!stock)
 388         {
 389             ERR("Couldn't select temporary DIB into temporary DC\n");
 390             DeleteDC(tmpDC);
 391             DeleteObject(tmpDIB);
 392             res = FALSE;
 393             goto fin;
 394         }
 395
 396         /* blends source DIB onto temp DIB and re-blits onto dest DC */
 397         res = GdiAlphaBlend(tmpDC, 0, 0, widthDst, heightDst, physDevSrc->hdc, xSrc, ySrc, widthSrc, heightSrc, blendfn);
 398         if(!res)
 399             MAYBE(TRACE("AlphaBlend failed\n"));
 400         else
 401             res = BitBlt(physDevDst->hdc, xDst, yDst, widthDst, heightDst, tmpDC, 0, 0, SRCCOPY);
 402
 403         /* frees resources */
 404         SelectObject(tmpDC, stock);
 405         DeleteDC(tmpDC);
 406         DeleteObject(tmpDIB);
 407     }
 408 fin:
 409     return res;
 410 }
 411
 412 /***********************************************************************
 413  *           _DIBDRV_InternalBitBlt
 414  */
 415 BOOL _DIBDRV_InternalBitBlt( DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst,
 416                     INT width, INT height, DIBDRVPHYSDEV *physDevSrc,
 417                     INT xSrc, INT ySrc, DWORD rop )
 418 {
 419     BOOL res;
 420     POINT pd, ps;
 421     SIZE sz;
 422     int iRec;
 423     RECT dstClip, srcClip;
 424
 425     /* first clip on physical DC sizes */
 426     setPoint(&pd, xDst, yDst);
 427     setPoint(&ps, xSrc, ySrc);
 428     setSize(&sz, width, height);
 429     setRect(&dstClip, 0, 0, physDevDst->physBitmap.width, physDevDst->physBitmap.height);
 430     if(physDevSrc)
 431     {
 432         setRect(&srcClip, 0, 0, physDevSrc->physBitmap.width, physDevSrc->physBitmap.height);
 433         res = BitBlt_ClipAreas(&ps, &pd, &sz, &srcClip, &dstClip);
 434     }
 435     else
 436         res = BitBlt_ClipAreas(&ps, &pd, &sz, 0, &dstClip);
 437     if(!res)
 438         return FALSE;
 439     xDst = pd.x; yDst = pd.y;
 440     xSrc = ps.x; ySrc = ps.y;
 441     width = sz.cx; height = sz.cy;
 442
 443     /* then, do blitting for each dest clip area (no clipping on source) */
 444     res = FALSE;
 445     for(iRec = 0; iRec < physDevDst->regionRectCount; iRec++)
 446     {
 447         RECT *r = physDevDst->regionRects + iRec;
 448         setRect(&dstClip, r->left, r->top, r->right, r->bottom);
 449         setPoint(&pd, xDst, yDst);
 450         setPoint(&ps, xSrc, ySrc);
 451         setSize(&sz, width, height);
 452         if(!BitBlt_ClipAreas(&ps, &pd, &sz, 0, &dstClip))
 453             continue;
 454         if(physDevDst->physBitmap.funcs->BitBlt(physDevDst, pd.x, pd.y, sz.cx, sz.cy, physDevSrc, ps.x, ps.y, rop))
 455             res = TRUE;
 456     }
 457     return res;
 458 }
 459
 460 /***********************************************************************
 461  *           DIBDRV_BitBlt                                             */
 462 BOOL DIBDRV_BitBlt( DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst,
 463                     INT width, INT height, DIBDRVPHYSDEV *physDevSrc,
 464                     INT xSrc, INT ySrc, DWORD rop )
 465 {
 466     BOOL res;
 467
 468     /* clip blit area */
 469     POINT pd = {xDst, yDst};
 470     POINT ps = {xSrc, ySrc};
 471     SIZE sz = {width, height};
 472
 473     MAYBE(TRACE("physDevDst:%p(%s%s), xDst:%d, yDst:%d, width:%d, height:%d, physDevSrc:%p(%s%s), xSrc:%d, ySrc:%d, rop:%08x\n",
 474           physDevDst, physDevDst->hasDIB ? "DIB-" : "DDB", physDevDst->hasDIB ? _DIBDRVBITMAP_GetFormatName(&physDevDst->physBitmap) : "",
 475           xDst, yDst, width, height,
 476           physDevSrc, physDevSrc ? (physDevSrc->hasDIB ? "DIB-" : "DDB"): "---", physDevSrc && physDevSrc->hasDIB ? _DIBDRVBITMAP_GetFormatName(&physDevSrc->physBitmap) : "",
 477           xSrc, ySrc, rop));
 478
 479     if(physDevDst->hasDIB)
 480     {
 481         /* DIB section selected in dest DC, use DIB Engine */
 482         /* clip blit area */
 483         RECT dstClip = {0, 0, physDevDst->physBitmap.width, physDevDst->physBitmap.height};
 484
 485         if(!physDevSrc || physDevSrc->hasDIB)
 486         {
 487             /* source is null or has a DIB, no need to convert anyting */
 488             res = _DIBDRV_InternalBitBlt(physDevDst, xDst, yDst, width, height, physDevSrc, xSrc, ySrc, rop);
 489         }
 490         else
 491         {
 492             /* source is a DDB, must convert it to DIB */
 493
 494             /* don't clip on source */
 495             res = BitBlt_ClipAreas(&ps, &pd, &sz, 0, &dstClip);
 496             if(!res)
 497                 goto noBlt2;
 498             xDst = pd.x; yDst = pd.y; width = sz.cx; height = sz.cy; xSrc = ps.x; ySrc = ps.y;
 499
 500             /* we must differentiate from 2 cases :
 501                1) source DC is a memory DC
 502                2) source DC is a device DC */
 503             if(GetObjectType(physDevSrc->hdc) == OBJ_MEMDC)
 504             {
 505                 /* memory DC */
 506                 HBITMAP dib, ddb;
 507
 508                 ddb = SelectObject(physDevSrc->hdc, GetStockObject(DEFAULT_BITMAP));
 509                 if(!ddb)
 510                 {
 511                     ERR("Couldn't select out DDB from source HDC\n");
 512                     res = 0;
 513                     goto noBlt1;
 514                 }
 515                 dib = _DIBDRV_ConvertDDBtoDIB(physDevSrc->hdc, ddb, ySrc, height);
 516                 if(!dib)
 517                 {
 518                     ERR("Failed converting source DDB to DIB\n");
 519                     SelectObject(physDevSrc->hdc, ddb);
 520                     res = 0;
 521                     goto noBlt1;
 522                 }
 523                 SelectObject(physDevSrc->hdc, dib);
 524                 res = _DIBDRV_InternalBitBlt(physDevDst, xDst, yDst, width, height, physDevSrc, xSrc, 0, rop);
 525                 SelectObject(physDevSrc->hdc, ddb);
 526                 DeleteObject(dib);
 527     noBlt1:
 528                 ;
 529             }
 530             else
 531             {
 532                 /* device DC */
 533                 HBITMAP dib, stock;
 534                 HDC memHdc;
 535
 536                 dib = _DIBDRV_ConvertDevDDBtoDIB(physDevSrc->hdc, physDevDst->hdc, xSrc, ySrc, width, height);
 537                 if(!dib)
 538                 {
 539                     ERR("Failed converting source DDB tp DIB for device DC\n");
 540                     res = 0;
 541                     goto noBlt2;
 542                 }
 543                 memHdc = CreateCompatibleDC(physDevDst->hdc);
 544                 if(!memHdc)
 545                 {
 546                     ERR("Failed creating temporary memory DC\n");
 547                     DeleteObject(dib);
 548                     res = 0;
 549                     goto noBlt2;
 550                 }
 551                 stock = SelectObject(memHdc, dib);
 552                 if(!stock)
 553                 {
 554                     ERR("Failed selecting converted DIB into temporary memory DC\n");
 555                     DeleteObject(dib);
 556                     DeleteDC(memHdc);
 557                     res = 0;
 558                     goto noBlt2;
 559                 }
 560                 res = BitBlt(physDevDst->hdc, xDst, yDst, width, height, memHdc, 0, 0, rop);
 561
 562                 SelectObject(memHdc, stock);
 563                 DeleteObject(dib);
 564                 DeleteDC(memHdc);
 565     noBlt2:
 566                 ;
 567             }
 568         }
 569     }
 570     else /* dest is a DDB */
 571     {
 572         /* DDB selected on dest DC, use X11 Driver */
 573         if(!physDevSrc || !physDevSrc->hasDIB)
 574         {
 575             /* source is null or has also a DDB, no need to convert anything */
 576             res = _DIBDRV_GetDisplayDriver()->pBitBlt(physDevDst->X11PhysDev, xDst, yDst, width, height,
 577                                                       physDevSrc ? physDevSrc->X11PhysDev : 0, xSrc, ySrc, rop);
 578         }
 579         else
 580         {
 581             /* DIB on source, DDB on dest -- must convert source DIB to DDB and use X11 driver for blit */
 582             HBITMAP dib, ddb;
 583
 584             /* clip blit area */
 585             if(physDevSrc)
 586             {
 587                 RECT srcClip = {0, 0, physDevSrc->physBitmap.width, physDevSrc->physBitmap.height};
 588                 res = BitBlt_ClipAreas(&ps, &pd, &sz, &srcClip, 0);
 589             }
 590             else
 591                 res = TRUE;
 592             if(!res)
 593                 goto noBlt3;
 594             xDst = pd.x; yDst = pd.y; width = sz.cx; height = sz.cy; xSrc = ps.x; ySrc = ps.y;
 595
 596             dib = SelectObject(physDevSrc->hdc, GetStockObject(DEFAULT_BITMAP));
 597             if(!dib)
 598             {
 599                 ERR("Couldn't select out DIB from source HDC\n");
 600                 res = 0;
 601                 goto noBlt3;
 602             }
 603             ddb = _DIBDRV_ConvertDIBtoDDB(physDevSrc->hdc, dib, ySrc, height);
 604             if(!ddb)
 605             {
 606                 ERR("Failed converting source DIB to DDB\n");
 607                 SelectObject(physDevSrc->hdc, dib);
 608                 res = 0;
 609                 goto noBlt3;
 610             }
 611             SelectObject(physDevSrc->hdc, ddb);
 612             res = _DIBDRV_GetDisplayDriver()->pBitBlt(physDevDst->X11PhysDev, xDst, yDst, width, height,
 613                                                       physDevSrc ? physDevSrc->X11PhysDev : 0, xSrc, 0, rop);
 614             SelectObject(physDevSrc->hdc, dib);
 615             DeleteObject(ddb);
 616 noBlt3:
 617             ;
 618         }
 619     }
 620     return res;
 621 }
 622
 623 /***********************************************************************
 624  *           _DIBDRV_InternalStretchBlt
 625  */
 626 BOOL _DIBDRV_InternalStretchBlt( DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst,
 627                     INT widthDst, INT heightDst, DIBDRVPHYSDEV *physDevSrc,
 628                     INT xSrc, INT ySrc, int widthSrc, int heightSrc, DWORD rop )
 629 {
 630     BOOL res;
 631     POINT pd, ps;
 632     SIZE szSrc, szDst;
 633     int iRec;
 634     RECT dstClip, srcClip;
 635
 636     /* first clip on physical DC sizes */
 637     setPoint(&pd, xDst, yDst);
 638     setPoint(&ps, xSrc, ySrc);
 639     setSize(&szDst, widthDst, heightDst);
 640     setSize(&szSrc, widthSrc, heightSrc);
 641     setRect(&dstClip, 0, 0, physDevDst->physBitmap.width, physDevDst->physBitmap.height);
 642     if(physDevSrc)
 643     {
 644         setRect(&srcClip, 0, 0, physDevSrc->physBitmap.width, physDevSrc->physBitmap.height);
 645         res = StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, &srcClip, &dstClip);
 646     }
 647     else
 648         res = StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, 0, &dstClip);
 649     if(!res)
 650         return FALSE;
 651     xDst = pd.x; yDst = pd.y;
 652     xSrc = ps.x; ySrc = ps.y;
 653     widthDst = szDst.cx; heightDst = szDst.cy;
 654     widthSrc = szSrc.cx; heightSrc = szSrc.cy;
 655
 656     /* then, do blitting for each dest clip area (no clipping on source) */
 657     res = FALSE;
 658     for(iRec = 0; iRec < physDevDst->regionRectCount; iRec++)
 659     {
 660         RECT *r = physDevDst->regionRects + iRec;
 661         setRect(&dstClip, r->left, r->top, r->right, r->bottom);
 662         setPoint(&pd, xDst, yDst);
 663         setPoint(&ps, xSrc, ySrc);
 664         setSize(&szDst, widthDst, heightDst);
 665         setSize(&szSrc, widthSrc, heightSrc);
 666         if(!StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, 0, &dstClip))
 667             continue;
 668         if(physDevDst->physBitmap.funcs->StretchBlt(physDevDst, pd.x, pd.y, szDst.cx, szDst.cy,
 669                                                     physDevSrc, ps.x, ps.y, szSrc.cx, szSrc.cy, rop))
 670             res = TRUE;
 671     }
 672     return res;
 673 }
 674
 675 /***********************************************************************
 676  *           DIBDRV_StretchBlt
 677  */
 678 BOOL DIBDRV_StretchBlt( DIBDRVPHYSDEV *physDevDst, INT xDst, INT yDst,
 679                         INT widthDst, INT heightDst,
 680                         DIBDRVPHYSDEV *physDevSrc, INT xSrc, INT ySrc,
 681                         INT widthSrc, INT heightSrc, DWORD rop )
 682 {
 683     BOOL res;
 684
 685     /* clip blit area */
 686     POINT pd = {xDst, yDst};
 687     POINT ps = {xSrc, ySrc};
 688     SIZE szDst = {widthDst, heightDst};
 689     SIZE szSrc = {widthSrc, heightSrc};
 690
 691     /* if source and dest sizes match, just call BitBlt(), it's faster */
 692     if(!physDevSrc || (widthDst == widthSrc && heightDst == heightSrc))
 693         return DIBDRV_BitBlt(physDevDst, xDst, yDst, widthDst, heightDst, physDevSrc, xSrc, ySrc, rop);
 694
 695     MAYBE(TRACE("physDevDst:%p(%s%s), xDst:%d, yDst:%d, widthDst:%d, heightDst:%d, physDevSrc:%p(%s%s), xSrc:%d, ySrc:%d, widthSrc:%d, heightSrc:%d, rop:%08x\n",
 696           physDevDst, physDevDst->hasDIB ? "DIB-" : "DDB", physDevDst->hasDIB ? _DIBDRVBITMAP_GetFormatName(&physDevDst->physBitmap) : "",
 697           xDst, yDst, widthDst, heightDst,
 698           physDevSrc, physDevSrc->hasDIB ? "DIB-" : "DDB", physDevSrc->hasDIB ? _DIBDRVBITMAP_GetFormatName(&physDevSrc->physBitmap) : "",
 699           xSrc, ySrc, widthSrc, heightSrc, rop));
 700
 701     if(physDevDst->hasDIB)
 702     {
 703         /* DIB section selected in dest DC, use DIB Engine */
 704
 705         if(!physDevSrc || physDevSrc->hasDIB)
 706         {
 707             /* source is null or has a DIB, no need to convert anyting */
 708             res = _DIBDRV_InternalStretchBlt(physDevDst, xDst, yDst, widthDst, heightDst, physDevSrc, xSrc, ySrc, widthSrc, heightSrc, rop);
 709         }
 710         else
 711         {
 712             /* source is a DDB, must convert it to DIB */
 713
 714             /* we must differentiate from 2 cases :
 715                1) source DC is a memory DC
 716                2) source DC is a device DC */
 717             if(GetObjectType(physDevSrc->hdc) == OBJ_MEMDC)
 718             {
 719                 /* memory DC */
 720                 HBITMAP dib, ddb;
 721
 722                 ddb = SelectObject(physDevSrc->hdc, GetStockObject(DEFAULT_BITMAP));
 723                 if(!ddb)
 724                 {
 725                     ERR("Couldn't select out DDB from source HDC\n");
 726                     res = 0;
 727                     goto noBlt1;
 728                 }
 729                 dib = _DIBDRV_ConvertDDBtoDIB(physDevSrc->hdc, ddb, ySrc, heightSrc);
 730                 if(!dib)
 731                 {
 732                     ERR("Failed converting source DDB to DIB\n");
 733                     SelectObject(physDevSrc->hdc, ddb);
 734                     res = 0;
 735                     goto noBlt1;
 736                 }
 737                 SelectObject(physDevSrc->hdc, dib);
 738                 res = _DIBDRV_InternalStretchBlt(physDevDst, xDst, yDst, widthDst, heightDst,
 739                                                  physDevSrc, xSrc, 0, widthSrc, heightSrc, rop);
 740                 SelectObject(physDevSrc->hdc, ddb);
 741                 DeleteObject(dib);
 742     noBlt1:
 743                 ;
 744             }
 745             else
 746             {
 747                 /* device DC */
 748                 HBITMAP dib, stock;
 749                 HDC memHdc;
 750
 751                 dib = _DIBDRV_ConvertDevDDBtoDIB(physDevSrc->hdc, physDevDst->hdc, xSrc, ySrc, widthSrc, heightSrc);
 752                 if(!dib)
 753                 {
 754                     ERR("Failed converting source DDB tp DIB for device DC\n");
 755                     res = 0;
 756                     goto noBlt2;
 757                 }
 758                 memHdc = CreateCompatibleDC(physDevDst->hdc);
 759                 if(!memHdc)
 760                 {
 761                     ERR("Failed creating temporary memory DC\n");
 762                     DeleteObject(dib);
 763                     res = 0;
 764                     goto noBlt2;
 765                 }
 766                 stock = SelectObject(memHdc, dib);
 767                 if(!stock)
 768                 {
 769                     ERR("Failed selecting converted DIB into temporary memory DC\n");
 770                     DeleteObject(dib);
 771                     DeleteDC(memHdc);
 772                     res = 0;
 773                     goto noBlt2;
 774                 }
 775                 res = StretchBlt(physDevDst->hdc, xDst, yDst, widthDst, heightDst, memHdc, 0, 0, widthSrc, widthDst, rop);
 776
 777                 SelectObject(memHdc, stock);
 778                 DeleteObject(dib);
 779                 DeleteDC(memHdc);
 780     noBlt2:
 781                 ;
 782             }
 783         }
 784     }
 785     else /* dest is a DDB */
 786     {
 787         /* DDB selected on dest DC, use X11 Driver */
 788         if(!physDevSrc || !physDevSrc->hasDIB)
 789         {
 790             /* source is null or has also a DDB, no need to convert anything */
 791             res = _DIBDRV_GetDisplayDriver()->pStretchBlt(physDevDst->X11PhysDev, xDst, yDst, widthDst, heightDst,
 792                                                       physDevSrc ? physDevSrc->X11PhysDev : 0, xSrc, ySrc, widthSrc, heightSrc, rop);
 793         }
 794         else
 795         {
 796             /* DIB on source, DDB on dest -- must convert source DIB to DDB and use X11 driver for blit */
 797             HBITMAP dib, ddb;
 798
 799             /* clip blit area */
 800             if(physDevSrc)
 801             {
 802                 RECT srcClip = {0, 0, physDevSrc->physBitmap.width, physDevSrc->physBitmap.height};
 803                 res = StretchBlt_ClipAreas(&ps, &pd, &szSrc, &szDst, &srcClip, 0);
 804             }
 805             else
 806                 res = TRUE;
 807             if(!res)
 808                 goto noBlt3;
 809             xDst = pd.x; yDst = pd.y; widthDst = szDst.cx; heightDst = szDst.cy;
 810             xSrc = ps.x; ySrc = ps.y; widthSrc = szSrc.cx; heightSrc = szSrc.cy;
 811
 812             dib = SelectObject(physDevSrc->hdc, GetStockObject(DEFAULT_BITMAP));
 813             if(!dib)
 814             {
 815                 ERR("Couldn't select out DIB from source HDC\n");
 816                 res = 0;
 817                 goto noBlt3;
 818             }
 819             ddb = _DIBDRV_ConvertDIBtoDDB(physDevSrc->hdc, dib, ySrc, heightSrc);
 820             if(!ddb)
 821             {
 822                 ERR("Failed converting source DIB to DDB\n");
 823                 SelectObject(physDevSrc->hdc, dib);
 824                 res = 0;
 825                 goto noBlt3;
 826             }
 827             if(!SelectObject(physDevSrc->hdc, ddb))
 828             {
 829                 ERR("Failed to select converted DDB into source HDC\n");
 830                 SelectObject(physDevSrc->hdc, dib);
 831                 DeleteObject(ddb);
 832                 res = 0;
 833                 goto noBlt3;
 834             }
 835             res = _DIBDRV_GetDisplayDriver()->pStretchBlt(physDevDst->X11PhysDev, xDst, yDst, widthDst, heightDst,
 836                                                       physDevSrc ? physDevSrc->X11PhysDev : 0, xSrc, 0, widthSrc, heightSrc, rop);
 837             SelectObject(physDevSrc->hdc, dib);
 838             DeleteObject(ddb);
 839 noBlt3:
 840             ;
 841         }
 842     }
 843     return res;
 844 }
 845
 846 /***********************************************************************
 847  *           DIBDRV_PatBlt
 848  */
 849 BOOL DIBDRV_PatBlt( DIBDRVPHYSDEV *physDev, INT left, INT top, INT width, INT height, DWORD rop )
 850 {
 851     BOOL res;
 852
 853     MAYBE(TRACE("physDev:%p, left:%d, top:%d, width:%d, height:%d, rop:%06x\n", physDev, left, top, width, height, rop));
 854
 855     if(physDev->hasDIB)
 856     {
 857         /* DIB section selected in, use DIB Engine */
 858         ONCE(FIXME("TEMPORARY - use BitBlt by now\n"));
 859         res = DIBDRV_BitBlt(physDev, left, top, width, height, NULL, 0, 0, rop);
 860     }
 861     else
 862     {
 863         /* DDB selected in, use X11 driver */
 864         res = _DIBDRV_GetDisplayDriver()->pPatBlt(physDev->X11PhysDev, left, top, width, height, rop);
 865     }
 866     return res;
 867 }