git.oblomov.eu Git - wine/blob - dlls/ddraw/surface_dib.c

   1 /*              DIBSection DirectDrawSurface driver
   2  *
   3  * Copyright 1997-2000 Marcus Meissner
   4  * Copyright 1998-2000 Lionel Ulmer
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #define NONAMELESSUNION
  30 #define NONAMELESSSTRUCT
  31
  32 #include "winerror.h"
  33 #include "wine/debug.h"
  34 #include "ddraw_private.h"
  35 #include "d3d_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  38
  39 /* FIXME */
  40 extern HBITMAP DIB_CreateDIBSection( HDC hdc, const BITMAPINFO *bmi, UINT usage, VOID **bits,
  41                                      HANDLE section, DWORD offset, DWORD ovr_pitch );
  42
  43 static const IDirectDrawSurface7Vtbl DIB_IDirectDrawSurface7_VTable;
  44
  45 /* Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned. */
  46 inline static int get_dib_width_bytes( int width, int depth )
  47 {
  48     int words;
  49
  50     switch(depth)
  51     {
  52     case 1:  words = (width + 31) / 32; break;
  53     case 4:  words = (width + 7) / 8; break;
  54     case 8:  words = (width + 3) / 4; break;
  55     case 15:
  56     case 16: words = (width + 1) / 2; break;
  57     case 24: words = (width * 3 + 3)/4; break;
  58     default:
  59         WARN("(%d): Unsupported depth\n", depth );
  60         /* fall through */
  61     case 32: words = width; break;
  62     }
  63     return 4 * words;
  64 }
  65
  66
  67 static HRESULT create_dib(IDirectDrawSurfaceImpl* This)
  68 {
  69     BITMAPINFO* b_info;
  70     UINT usage;
  71     HDC ddc;
  72     DIB_DirectDrawSurfaceImpl* priv = This->private;
  73
  74     assert(This->surface_desc.lpSurface != NULL);
  75
  76     switch (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount)
  77     {
  78     case 16:
  79     case 32:
  80         /* Allocate extra space to store the RGB bit masks. */
  81         b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  82                            sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD));
  83         break;
  84
  85     case 24:
  86         b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  87                            sizeof(BITMAPINFOHEADER));
  88         break;
  89
  90     default:
  91         /* Allocate extra space for a palette. */
  92         b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  93                            sizeof(BITMAPINFOHEADER)
  94                            + sizeof(RGBQUAD)
  95                            * (1 << This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount));
  96         break;
  97     }
  98
  99     b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 100     b_info->bmiHeader.biWidth = This->surface_desc.dwWidth;
 101     b_info->bmiHeader.biHeight = -This->surface_desc.dwHeight;
 102     b_info->bmiHeader.biPlanes = 1;
 103     b_info->bmiHeader.biBitCount = This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount;
 104
 105     if ((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount != 16)
 106         && (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount != 32))
 107         b_info->bmiHeader.biCompression = BI_RGB;
 108     else
 109         b_info->bmiHeader.biCompression = BI_BITFIELDS;
 110
 111     b_info->bmiHeader.biSizeImage
 112         = (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8)
 113         * This->surface_desc.dwWidth * This->surface_desc.dwHeight;
 114
 115     b_info->bmiHeader.biXPelsPerMeter = 0;
 116     b_info->bmiHeader.biYPelsPerMeter = 0;
 117     b_info->bmiHeader.biClrUsed = 0;
 118     b_info->bmiHeader.biClrImportant = 0;
 119
 120     if (!This->surface_desc.u1.lPitch) {
 121         /* This can't happen, right? */
 122         /* or use GDI_GetObj to get it from the created DIB? */
 123         This->surface_desc.u1.lPitch = get_dib_width_bytes(b_info->bmiHeader.biWidth, b_info->bmiHeader.biBitCount);
 124         This->surface_desc.dwFlags |= DDSD_PITCH;
 125     }
 126
 127     switch (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount)
 128     {
 129     case 16:
 130     case 32:
 131     {
 132         DWORD *masks = (DWORD *) &(b_info->bmiColors);
 133
 134         usage = 0;
 135         masks[0] = This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask;
 136         masks[1] = This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask;
 137         masks[2] = This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask;
 138     }
 139     break;
 140
 141     case 24:
 142         /* Nothing to do */
 143         usage = DIB_RGB_COLORS;
 144         break;
 145
 146     default:
 147         /* Don't know palette */
 148         usage = 0;
 149         break;
 150     }
 151
 152     ddc = CreateDCA("DISPLAY", NULL, NULL, NULL);
 153     if (ddc == 0)
 154     {
 155         HeapFree(GetProcessHeap(), 0, b_info);
 156         return HRESULT_FROM_WIN32(GetLastError());
 157     }
 158
 159     priv->dib.DIBsection
 160         = DIB_CreateDIBSection(ddc, b_info, usage, &(priv->dib.bitmap_data), 0,
 161                                (DWORD)This->surface_desc.lpSurface,
 162                                This->surface_desc.u1.lPitch);
 163     DeleteDC(ddc);
 164     if (!priv->dib.DIBsection) {
 165         ERR("CreateDIBSection failed!\n");
 166         HeapFree(GetProcessHeap(), 0, b_info);
 167         return HRESULT_FROM_WIN32(GetLastError());
 168     }
 169
 170     TRACE("DIBSection at : %p\n", priv->dib.bitmap_data);
 171
 172     if (!This->surface_desc.lpSurface) {
 173         This->surface_desc.lpSurface = priv->dib.bitmap_data;
 174         This->surface_desc.dwFlags |= DDSD_LPSURFACE;
 175     }
 176
 177     HeapFree(GetProcessHeap(), 0, b_info);
 178
 179     /* I don't think it's worth checking for this. */
 180     if (priv->dib.bitmap_data != This->surface_desc.lpSurface)
 181         ERR("unexpected error creating DirectDrawSurface DIB section\n");
 182
 183     /* this seems like a good place to put the handle for HAL driver use */
 184     This->global_more.hKernelSurface = (ULONG_PTR)priv->dib.DIBsection;
 185
 186     return S_OK;
 187 }
 188
 189 void DIB_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl* This)
 190 {
 191     DIB_DirectDrawSurfaceImpl* priv = This->private;
 192
 193     DeleteObject(priv->dib.DIBsection);
 194
 195     if (!priv->dib.client_memory)
 196         VirtualFree(This->surface_desc.lpSurface, 0, MEM_RELEASE);
 197
 198     Main_DirectDrawSurface_final_release(This);
 199 }
 200
 201 HRESULT DIB_DirectDrawSurface_duplicate_surface(IDirectDrawSurfaceImpl* This,
 202                                                 LPDIRECTDRAWSURFACE7* ppDup)
 203 {
 204     return DIB_DirectDrawSurface_Create(This->ddraw_owner,
 205                                         &This->surface_desc, ppDup, NULL);
 206 }
 207
 208 HRESULT DIB_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl *This,
 209                                         IDirectDrawImpl *pDD,
 210                                         const DDSURFACEDESC2 *pDDSD)
 211 {
 212     HRESULT hr;
 213     DIB_DirectDrawSurfaceImpl* priv = This->private;
 214
 215     TRACE("(%p)->(%p,%p)\n",This,pDD,pDDSD);
 216     hr = Main_DirectDrawSurface_Construct(This, pDD, pDDSD);
 217     if (FAILED(hr)) return hr;
 218
 219     ICOM_INIT_INTERFACE(This, IDirectDrawSurface7,
 220                         DIB_IDirectDrawSurface7_VTable);
 221
 222     This->final_release = DIB_DirectDrawSurface_final_release;
 223     This->duplicate_surface = DIB_DirectDrawSurface_duplicate_surface;
 224     This->flip_data = DIB_DirectDrawSurface_flip_data;
 225
 226     This->get_dc     = DIB_DirectDrawSurface_get_dc;
 227     This->release_dc = DIB_DirectDrawSurface_release_dc;
 228     This->hDC = NULL;
 229
 230     This->set_palette    = DIB_DirectDrawSurface_set_palette;
 231     This->update_palette = DIB_DirectDrawSurface_update_palette;
 232
 233     TRACE("(%ldx%ld, pitch=%ld)\n",
 234           This->surface_desc.dwWidth, This->surface_desc.dwHeight,
 235           This->surface_desc.u1.lPitch);
 236     /* XXX load dwWidth and dwHeight from pDD if they are not specified? */
 237
 238     if (This->surface_desc.dwFlags & DDSD_LPSURFACE)
 239     {
 240         /* "Client memory": it is managed by the application. */
 241         /* XXX What if lPitch is not set? Use dwWidth or fail? */
 242
 243         priv->dib.client_memory = TRUE;
 244     }
 245     else
 246     {
 247         if (!(This->surface_desc.dwFlags & DDSD_PITCH))
 248         {
 249             int pitch = This->surface_desc.u1.lPitch;
 250             if (pitch % 8 != 0)
 251                 pitch += 8 - (pitch % 8);
 252         }
 253         /* XXX else: how should lPitch be verified? */
 254
 255         This->surface_desc.dwFlags |= DDSD_LPSURFACE;
 256
 257         /* Ensure that DDSD_PITCH is respected for DDPF_FOURCC surfaces too */
 258         if (This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC && !(This->surface_desc.dwFlags & DDSD_PITCH)) {
 259             This->surface_desc.lpSurface
 260                 = VirtualAlloc(NULL, This->surface_desc.u1.dwLinearSize, MEM_COMMIT, PAGE_READWRITE);
 261             This->surface_desc.dwFlags |= DDSD_LINEARSIZE;
 262         } else {
 263             This->surface_desc.lpSurface
 264                 = VirtualAlloc(NULL, This->surface_desc.u1.lPitch
 265                            * This->surface_desc.dwHeight + 4, /* The + 4 here is for dumb games reading after the end of the surface
 266                                                                  when reading the last byte / half using word access */
 267                            MEM_COMMIT, PAGE_READWRITE);
 268             This->surface_desc.dwFlags |= DDSD_PITCH;
 269         }
 270
 271         if (This->surface_desc.lpSurface == NULL)
 272         {
 273             Main_DirectDrawSurface_final_release(This);
 274             return HRESULT_FROM_WIN32(GetLastError());
 275         }
 276
 277         priv->dib.client_memory = FALSE;
 278     }
 279
 280     hr = create_dib(This);
 281     if (FAILED(hr))
 282     {
 283         if (!priv->dib.client_memory)
 284             VirtualFree(This->surface_desc.lpSurface, 0, MEM_RELEASE);
 285
 286         Main_DirectDrawSurface_final_release(This);
 287
 288         return hr;
 289     }
 290
 291     return DD_OK;
 292 }
 293
 294 /* Not an API */
 295 HRESULT DIB_DirectDrawSurface_Create(IDirectDrawImpl *pDD,
 296                                      const DDSURFACEDESC2 *pDDSD,
 297                                      LPDIRECTDRAWSURFACE7 *ppSurf,
 298                                      IUnknown *pUnkOuter)
 299 {
 300     IDirectDrawSurfaceImpl* This;
 301     HRESULT hr;
 302     assert(pUnkOuter == NULL);
 303
 304     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 305                      sizeof(*This) + sizeof(DIB_DirectDrawSurfaceImpl));
 306     if (This == NULL) return E_OUTOFMEMORY;
 307
 308     This->private = (DIB_DirectDrawSurfaceImpl*)(This+1);
 309
 310     hr = DIB_DirectDrawSurface_Construct(This, pDD, pDDSD);
 311     if (FAILED(hr))
 312         HeapFree(GetProcessHeap(), 0, This);
 313     else
 314         *ppSurf = ICOM_INTERFACE(This, IDirectDrawSurface7);
 315
 316     return hr;
 317
 318 }
 319
 320 /* AddAttachedSurface: generic */
 321 /* AddOverlayDirtyRect: generic, unimplemented */
 322
 323 static HRESULT _Blt_ColorFill(
 324     LPBYTE buf, int width, int height, int bpp, LONG lPitch, DWORD color
 325 ) {
 326     int x, y;
 327     LPBYTE first;
 328
 329     /* Do first row */
 330
 331 #define COLORFILL_ROW(type) { \
 332     type *d = (type *) buf; \
 333     for (x = 0; x < width; x++) \
 334         d[x] = (type) color; \
 335     break; \
 336 }
 337
 338     switch(bpp) {
 339     case 1: COLORFILL_ROW(BYTE)
 340     case 2: COLORFILL_ROW(WORD)
 341     case 3: { BYTE *d = (BYTE *) buf;
 342               for (x = 0; x < width; x++,d+=3) {
 343                 d[0] = (color    ) & 0xFF;
 344                 d[1] = (color>> 8) & 0xFF;
 345                 d[2] = (color>>16) & 0xFF;
 346               }
 347               break;}
 348     case 4: COLORFILL_ROW(DWORD)
 349     default:
 350         FIXME("Color fill not implemented for bpp %d!\n", bpp*8);
 351         return DDERR_UNSUPPORTED;
 352     }
 353
 354 #undef COLORFILL_ROW
 355
 356     /* Now copy first row */
 357     first = buf;
 358     for (y = 1; y < height; y++) {
 359         buf += lPitch;
 360         memcpy(buf, first, width * bpp);
 361     }
 362     return DD_OK;
 363 }
 364
 365 static void ComputeShifts(DWORD mask, DWORD* lshift, DWORD* rshift)
 366 {
 367     int pos = 0;
 368     int bits = 0;
 369     *lshift = 0;
 370     *rshift = 0;
 371
 372     if (!mask)
 373         return;
 374
 375     while(!(mask & (1 << pos)))
 376         pos++;
 377
 378     while(mask & (1 << (pos+bits)))
 379         bits++;
 380
 381     *lshift = pos;
 382     *rshift = 8 - bits;
 383 }
 384
 385 /* This is used to factorize the decompression between the Blt and BltFast code */
 386 static void DoDXTCDecompression(const DDSURFACEDESC2 *sdesc, const DDSURFACEDESC2 *ddesc)
 387 {
 388     DWORD rs,rb,rm;
 389     DWORD gs,gb,gm;
 390     DWORD bs,bb,bm;
 391     DWORD as,ab,am;
 392
 393     if (!s3tc_initialized) {
 394         /* FIXME: We may fake this by rendering the texture into the framebuffer using OpenGL functions and reading back
 395          *        the framebuffer. This will be slow and somewhat ugly. */
 396         FIXME("Manual S3TC decompression is not supported in native mode\n");
 397         return;
 398     }
 399
 400     rm = ddesc->u4.ddpfPixelFormat.u2.dwRBitMask;
 401     ComputeShifts(rm, &rs, &rb);
 402     gm = ddesc->u4.ddpfPixelFormat.u3.dwGBitMask;
 403     ComputeShifts(gm, &gs, &gb);
 404     bm = ddesc->u4.ddpfPixelFormat.u4.dwBBitMask;
 405     ComputeShifts(bm, &bs, &bb);
 406     am = ddesc->u4.ddpfPixelFormat.u5.dwRGBAlphaBitMask;
 407     ComputeShifts(am, &as, &ab);
 408     if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','1')) {
 409         int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
 410         int pitch = ddesc->u1.lPitch;
 411         int width = ddesc->dwWidth;
 412         int height = ddesc->dwHeight;
 413         int x,y;
 414         unsigned char* dst = (unsigned char*) ddesc->lpSurface;
 415         unsigned char* src = (unsigned char*) sdesc->lpSurface;
 416         for (x = 0; x < width; x++)
 417             for (y =0; y < height; y++) {
 418                 DWORD pixel = 0;
 419                 BYTE data[4];
 420                 (*fetch_2d_texel_rgba_dxt1)(width, src, x, y, data);
 421                 pixel = 0;
 422                 pixel |= ((data[0] >> rb) << rs) & rm;
 423                 pixel |= ((data[1] >> gb) << gs) & gm;
 424                 pixel |= ((data[2] >> bb) << bs) & bm;
 425                 pixel |= ((data[3] >> ab) << as) & am;
 426                 if (is16)
 427                     *((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
 428                 else
 429                     *((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
 430             }
 431     } else if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','3')) {
 432         int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
 433         int pitch = ddesc->u1.lPitch;
 434         int width = ddesc->dwWidth;
 435         int height = ddesc->dwHeight;
 436         int x,y;
 437         unsigned char* dst = (unsigned char*) ddesc->lpSurface;
 438         unsigned char* src = (unsigned char*) sdesc->lpSurface;
 439         for (x = 0; x < width; x++)
 440             for (y =0; y < height; y++) {
 441                 DWORD pixel = 0;
 442                 BYTE data[4];
 443                 (*fetch_2d_texel_rgba_dxt3)(width, src, x, y, data);
 444                 pixel = 0;
 445                 pixel |= ((data[0] >> rb) << rs) & rm;
 446                 pixel |= ((data[1] >> gb) << gs) & gm;
 447                 pixel |= ((data[2] >> bb) << bs) & bm;
 448                 pixel |= ((data[3] >> ab) << as) & am;
 449                 if (is16)
 450                     *((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
 451                 else
 452                     *((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
 453             }
 454     } else if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','5')) {
 455         int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
 456         int pitch = ddesc->u1.lPitch;
 457         int width = ddesc->dwWidth;
 458         int height = ddesc->dwHeight;
 459         int x,y;
 460         unsigned char* dst = (unsigned char*) ddesc->lpSurface;
 461         unsigned char* src = (unsigned char*) sdesc->lpSurface;
 462         for (x = 0; x < width; x++)
 463             for (y =0; y < height; y++) {
 464                 DWORD pixel = 0;
 465                 BYTE data[4];
 466                 (*fetch_2d_texel_rgba_dxt5)(width, src, x, y, data);
 467                 pixel = 0;
 468                 pixel |= ((data[0] >> rb) << rs) & rm;
 469                 pixel |= ((data[1] >> gb) << gs) & gm;
 470                 pixel |= ((data[2] >> bb) << bs) & bm;
 471                 pixel |= ((data[3] >> ab) << as) & am;
 472                 if (is16)
 473                     *((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
 474                 else
 475                     *((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
 476             }
 477     }
 478 #if 0 /* Useful for debugging */
 479     {
 480         static int idx;
 481         char texname[255];
 482         FILE* f;
 483         sprintf(texname, "dxt_%d.pnm", idx++);
 484         f = fopen(texname,"w");
 485         DDRAW_dump_surface_to_disk(This, f, 1);
 486         fclose(f);
 487     }
 488 #endif
 489 }
 490
 491 HRESULT WINAPI
 492 DIB_DirectDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
 493                           LPDIRECTDRAWSURFACE7 src, LPRECT rsrc,
 494                           DWORD dwFlags, LPDDBLTFX lpbltfx)
 495 {
 496     IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
 497     RECT                xdst,xsrc;
 498     DDSURFACEDESC2      ddesc,sdesc;
 499     HRESULT             ret = DD_OK;
 500     int bpp, srcheight, srcwidth, dstheight, dstwidth, width;
 501     int x, y;
 502     LPBYTE dbuf, sbuf;
 503
 504     TRACE("(%p)->(%p,%p,%p,%08lx,%p)\n", This,rdst,src,rsrc,dwFlags,lpbltfx);
 505
 506     if (TRACE_ON(ddraw)) {
 507         if (rdst) TRACE("\tdestrect :%ldx%ld-%ldx%ld\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
 508         if (rsrc) TRACE("\tsrcrect  :%ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
 509         TRACE("\tflags: ");
 510         DDRAW_dump_DDBLT(dwFlags);
 511         if (dwFlags & DDBLT_DDFX) {
 512             TRACE("\tblitfx: ");
 513             DDRAW_dump_DDBLTFX(lpbltfx->dwDDFX);
 514         }
 515     }
 516
 517     if ((This->locked) || ((src != NULL) && (((IDirectDrawSurfaceImpl *)src)->locked))) {
 518         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
 519         return DDERR_SURFACEBUSY;
 520     }
 521
 522     /* First, check if the possible override function handles this case */
 523     if (This->aux_blt != NULL) {
 524         if (This->aux_blt(This, rdst, src, rsrc, dwFlags, lpbltfx) == DD_OK) return DD_OK;
 525     }
 526
 527     DD_STRUCT_INIT(&ddesc);
 528     DD_STRUCT_INIT(&sdesc);
 529
 530     sdesc.dwSize = sizeof(sdesc);
 531     ddesc.dwSize = sizeof(ddesc);
 532
 533     if (src == iface) {
 534         IDirectDrawSurface7_Lock(iface, NULL, &ddesc, 0, 0);
 535         DD_STRUCT_COPY_BYSIZE(&sdesc, &ddesc);
 536     } else {
 537         if (src) IDirectDrawSurface7_Lock(src, NULL, &sdesc, DDLOCK_READONLY, 0);
 538         IDirectDrawSurface7_Lock(iface,NULL,&ddesc,DDLOCK_WRITEONLY,0);
 539     }
 540
 541     if (!lpbltfx || !(lpbltfx->dwDDFX)) dwFlags &= ~DDBLT_DDFX;
 542
 543     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
 544         (ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)) {
 545         if (sdesc.u4.ddpfPixelFormat.dwFourCC != sdesc.u4.ddpfPixelFormat.dwFourCC) {
 546             FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
 547             ret = DDERR_INVALIDPIXELFORMAT;
 548             goto release;
 549         }
 550         memcpy(ddesc.lpSurface, sdesc.lpSurface, ddesc.u1.dwLinearSize);
 551         goto release;
 552     }
 553
 554     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
 555         (!(ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC))) {
 556         DoDXTCDecompression(&sdesc, &ddesc);
 557         goto release;
 558     }
 559
 560     if (rdst) {
 561         memcpy(&xdst,rdst,sizeof(xdst));
 562     } else {
 563         xdst.top        = 0;
 564         xdst.bottom     = ddesc.dwHeight;
 565         xdst.left       = 0;
 566         xdst.right      = ddesc.dwWidth;
 567     }
 568
 569     if (rsrc) {
 570         memcpy(&xsrc,rsrc,sizeof(xsrc));
 571     } else {
 572         if (src) {
 573             xsrc.top    = 0;
 574             xsrc.bottom = sdesc.dwHeight;
 575             xsrc.left   = 0;
 576             xsrc.right  = sdesc.dwWidth;
 577         } else {
 578             memset(&xsrc,0,sizeof(xsrc));
 579         }
 580     }
 581
 582     /* First check for the validity of source / destination rectangles. This was
 583        verified using a test application + by MSDN.
 584     */
 585     if ((src != NULL) &&
 586         ((xsrc.bottom > sdesc.dwHeight) || (xsrc.bottom < 0) ||
 587          (xsrc.top > sdesc.dwHeight) || (xsrc.top < 0) ||
 588          (xsrc.left > sdesc.dwWidth) || (xsrc.left < 0) ||
 589          (xsrc.right > sdesc.dwWidth) || (xsrc.right < 0) ||
 590          (xsrc.right < xsrc.left) || (xsrc.bottom < xsrc.top))) {
 591         WARN("Application gave us bad source rectangle for Blt.\n");
 592         ret = DDERR_INVALIDRECT;
 593         goto release;
 594     }
 595     /* For the Destination rect, it can be out of bounds on the condition that a clipper
 596        is set for the given surface.
 597     */
 598     if ((This->clipper == NULL) &&
 599         ((xdst.bottom > ddesc.dwHeight) || (xdst.bottom < 0) ||
 600          (xdst.top > ddesc.dwHeight) || (xdst.top < 0) ||
 601          (xdst.left > ddesc.dwWidth) || (xdst.left < 0) ||
 602          (xdst.right > ddesc.dwWidth) || (xdst.right < 0) ||
 603          (xdst.right < xdst.left) || (xdst.bottom < xdst.top))) {
 604         WARN("Application gave us bad destination rectangle for Blt without a clipper set.\n");
 605         ret = DDERR_INVALIDRECT;
 606         goto release;
 607     }
 608
 609     /* Now handle negative values in the rectangles. Warning: only supported for now
 610        in the 'simple' cases (ie not in any stretching / rotation cases).
 611
 612        First, the case where nothing is to be done.
 613     */
 614     if (((xdst.bottom <= 0) || (xdst.right <= 0) || (xdst.top >= (int) ddesc.dwHeight) || (xdst.left >= (int) ddesc.dwWidth)) ||
 615         ((src != NULL) &&
 616          ((xsrc.bottom <= 0) || (xsrc.right <= 0) || (xsrc.top >= (int) sdesc.dwHeight) || (xsrc.left >= (int) sdesc.dwWidth))))
 617     {
 618         TRACE("Nothing to be done !\n");
 619         goto release;
 620     }
 621
 622     /* The easy case : the source-less blits.... */
 623     if (src == NULL) {
 624         RECT full_rect;
 625         RECT temp_rect; /* No idea if intersect rect can be the same as one of the source rect */
 626
 627         full_rect.left   = 0;
 628         full_rect.top    = 0;
 629         full_rect.right  = ddesc.dwWidth;
 630         full_rect.bottom = ddesc.dwHeight;
 631         IntersectRect(&temp_rect, &full_rect, &xdst);
 632         xdst = temp_rect;
 633     } else {
 634         /* Only handle clipping on the destination rectangle */
 635         int clip_horiz = (xdst.left < 0) || (xdst.right  > (int) ddesc.dwWidth );
 636         int clip_vert  = (xdst.top  < 0) || (xdst.bottom > (int) ddesc.dwHeight);
 637         if (clip_vert || clip_horiz) {
 638             /* Now check if this is a special case or not... */
 639             if ((((xdst.bottom - xdst.top ) != (xsrc.bottom - xsrc.top )) && clip_vert ) ||
 640                 (((xdst.right  - xdst.left) != (xsrc.right  - xsrc.left)) && clip_horiz) ||
 641                 (dwFlags & DDBLT_DDFX)) {
 642                 WARN("Out of screen rectangle in special case. Not handled right now.\n");
 643                 goto release;
 644             }
 645
 646             if (clip_horiz) {
 647               if (xdst.left < 0) { xsrc.left -= xdst.left; xdst.left = 0; }
 648               if (xdst.right > ddesc.dwWidth) { xsrc.right -= (xdst.right - (int) ddesc.dwWidth); xdst.right = (int) ddesc.dwWidth; }
 649             }
 650             if (clip_vert) {
 651                 if (xdst.top < 0) { xsrc.top -= xdst.top; xdst.top = 0; }
 652                 if (xdst.bottom > ddesc.dwHeight) { xsrc.bottom -= (xdst.bottom - (int) ddesc.dwHeight); xdst.bottom = (int) ddesc.dwHeight; }
 653             }
 654             /* And check if after clipping something is still to be done... */
 655             if ((xdst.bottom <= 0) || (xdst.right <= 0) || (xdst.top >= (int) ddesc.dwHeight) || (xdst.left >= (int) ddesc.dwWidth) ||
 656                 (xsrc.bottom <= 0) || (xsrc.right <= 0) || (xsrc.top >= (int) sdesc.dwHeight) || (xsrc.left >= (int) sdesc.dwWidth)) {
 657                 TRACE("Nothing to be done after clipping !\n");
 658                 goto release;
 659             }
 660         }
 661     }
 662
 663     bpp = GET_BPP(ddesc);
 664     srcheight = xsrc.bottom - xsrc.top;
 665     srcwidth = xsrc.right - xsrc.left;
 666     dstheight = xdst.bottom - xdst.top;
 667     dstwidth = xdst.right - xdst.left;
 668     width = (xdst.right - xdst.left) * bpp;
 669
 670     assert(width <= ddesc.u1.lPitch);
 671
 672     dbuf = (BYTE*)ddesc.lpSurface+(xdst.top*ddesc.u1.lPitch)+(xdst.left*bpp);
 673
 674     if (dwFlags & DDBLT_WAIT) {
 675         static BOOL displayed = FALSE;
 676         if (!displayed)
 677             FIXME("Can't handle DDBLT_WAIT flag right now.\n");
 678         displayed = TRUE;
 679         dwFlags &= ~DDBLT_WAIT;
 680     }
 681     if (dwFlags & DDBLT_ASYNC) {
 682         static BOOL displayed = FALSE;
 683         if (!displayed)
 684             FIXME("Can't handle DDBLT_ASYNC flag right now.\n");
 685         displayed = TRUE;
 686         dwFlags &= ~DDBLT_ASYNC;
 687     }
 688     if (dwFlags & DDBLT_DONOTWAIT) {
 689         /* DDBLT_DONOTWAIT appeared in DX7 */
 690         static BOOL displayed = FALSE;
 691         if (!displayed)
 692             FIXME("Can't handle DDBLT_DONOTWAIT flag right now.\n");
 693         displayed = TRUE;
 694         dwFlags &= ~DDBLT_DONOTWAIT;
 695     }
 696
 697     /* First, all the 'source-less' blits */
 698     if (dwFlags & DDBLT_COLORFILL) {
 699         ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp,
 700                              ddesc.u1.lPitch, lpbltfx->u5.dwFillColor);
 701         dwFlags &= ~DDBLT_COLORFILL;
 702     }
 703
 704     if (dwFlags & DDBLT_DEPTHFILL)
 705         FIXME("DDBLT_DEPTHFILL needs to be implemented!\n");
 706     if (dwFlags & DDBLT_ROP) {
 707         /* Catch some degenerate cases here */
 708         switch(lpbltfx->dwROP) {
 709         case BLACKNESS:
 710             ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,ddesc.u1.lPitch,0);
 711             break;
 712         case 0xAA0029: /* No-op */
 713             break;
 714         case WHITENESS:
 715             ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,ddesc.u1.lPitch,~0);
 716             break;
 717         case SRCCOPY: /* well, we do that below ? */
 718             break;
 719         default:
 720             FIXME("Unsupported raster op: %08lx  Pattern: %p\n", lpbltfx->dwROP, lpbltfx->u5.lpDDSPattern);
 721             goto error;
 722         }
 723         dwFlags &= ~DDBLT_ROP;
 724     }
 725     if (dwFlags & DDBLT_DDROPS) {
 726         FIXME("\tDdraw Raster Ops: %08lx  Pattern: %p\n", lpbltfx->dwDDROP, lpbltfx->u5.lpDDSPattern);
 727     }
 728     /* Now the 'with source' blits */
 729     if (src) {
 730         LPBYTE sbase;
 731         int sx, xinc, sy, yinc;
 732
 733         if (!dstwidth || !dstheight) /* hmm... stupid program ? */
 734             goto release;
 735         sbase = (BYTE*)sdesc.lpSurface+(xsrc.top*sdesc.u1.lPitch)+xsrc.left*bpp;
 736         xinc = (srcwidth << 16) / dstwidth;
 737         yinc = (srcheight << 16) / dstheight;
 738
 739         if (!dwFlags) {
 740             /* No effects, we can cheat here */
 741             if (dstwidth == srcwidth) {
 742                 if (dstheight == srcheight) {
 743                     /* No stretching in either direction. This needs to be as
 744                      * fast as possible */
 745                     sbuf = sbase;
 746
 747                     /* check for overlapping surfaces */
 748                     if (src != iface || xdst.top < xsrc.top ||
 749                         xdst.right <= xsrc.left || xsrc.right <= xdst.left)
 750                     {
 751                         /* no overlap, or dst above src, so copy from top downwards */
 752                         for (y = 0; y < dstheight; y++)
 753                         {
 754                             memcpy(dbuf, sbuf, width);
 755                             sbuf += sdesc.u1.lPitch;
 756                             dbuf += ddesc.u1.lPitch;
 757                         }
 758                     }
 759                     else if (xdst.top > xsrc.top)  /* copy from bottom upwards */
 760                     {
 761                         sbuf += (sdesc.u1.lPitch*dstheight);
 762                         dbuf += (ddesc.u1.lPitch*dstheight);
 763                         for (y = 0; y < dstheight; y++)
 764                         {
 765                             sbuf -= sdesc.u1.lPitch;
 766                             dbuf -= ddesc.u1.lPitch;
 767                             memcpy(dbuf, sbuf, width);
 768                         }
 769                     }
 770                     else /* src and dst overlapping on the same line, use memmove */
 771                     {
 772                         for (y = 0; y < dstheight; y++)
 773                         {
 774                             memmove(dbuf, sbuf, width);
 775                             sbuf += sdesc.u1.lPitch;
 776                             dbuf += ddesc.u1.lPitch;
 777                         }
 778                     }
 779                 } else {
 780                     /* Stretching in Y direction only */
 781                     for (y = sy = 0; y < dstheight; y++, sy += yinc) {
 782                         sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
 783                         memcpy(dbuf, sbuf, width);
 784                         dbuf += ddesc.u1.lPitch;
 785                     }
 786                 }
 787             } else {
 788                 /* Stretching in X direction */
 789                 int last_sy = -1;
 790                 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
 791                     sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
 792
 793                     if ((sy >> 16) == (last_sy >> 16)) {
 794                         /* this sourcerow is the same as last sourcerow -
 795                          * copy already stretched row
 796                          */
 797                         memcpy(dbuf, dbuf - ddesc.u1.lPitch, width);
 798                     } else {
 799 #define STRETCH_ROW(type) { \
 800                     type *s = (type *) sbuf, *d = (type *) dbuf; \
 801                     for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
 802                     d[x] = s[sx >> 16]; \
 803                     break; }
 804
 805                     switch(bpp) {
 806                     case 1: STRETCH_ROW(BYTE)
 807                     case 2: STRETCH_ROW(WORD)
 808                     case 4: STRETCH_ROW(DWORD)
 809                     case 3: {
 810                         LPBYTE s,d = dbuf;
 811                         for (x = sx = 0; x < dstwidth; x++, sx+= xinc) {
 812                             DWORD pixel;
 813
 814                             s = sbuf+3*(sx>>16);
 815                             pixel = s[0]|(s[1]<<8)|(s[2]<<16);
 816                             d[0] = (pixel    )&0xff;
 817                             d[1] = (pixel>> 8)&0xff;
 818                             d[2] = (pixel>>16)&0xff;
 819                             d+=3;
 820                         }
 821                         break;
 822                     }
 823                     default:
 824                         FIXME("Stretched blit not implemented for bpp %d!\n", bpp*8);
 825                         ret = DDERR_UNSUPPORTED;
 826                         goto error;
 827                     }
 828 #undef STRETCH_ROW
 829                     }
 830                     dbuf += ddesc.u1.lPitch;
 831                     last_sy = sy;
 832                 }
 833             }
 834         } else {
 835            LONG dstyinc = ddesc.u1.lPitch, dstxinc = bpp;
 836            DWORD keylow = 0xFFFFFFFF, keyhigh = 0, keymask = 0xFFFFFFFF;
 837            if (dwFlags & (DDBLT_KEYSRC | DDBLT_KEYDEST | DDBLT_KEYSRCOVERRIDE | DDBLT_KEYDESTOVERRIDE)) {
 838
 839               if (dwFlags & DDBLT_KEYSRC) {
 840                  keylow  = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
 841                  keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
 842               } else if (dwFlags & DDBLT_KEYDEST){
 843                  keylow  = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
 844                  keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
 845               } else if (dwFlags & DDBLT_KEYSRCOVERRIDE) {
 846                  keylow  = lpbltfx->ddckSrcColorkey.dwColorSpaceLowValue;
 847                  keyhigh = lpbltfx->ddckSrcColorkey.dwColorSpaceHighValue;
 848               } else {
 849                  keylow  = lpbltfx->ddckDestColorkey.dwColorSpaceLowValue;
 850                  keyhigh = lpbltfx->ddckDestColorkey.dwColorSpaceHighValue;
 851               }
 852               keymask = sdesc.u4.ddpfPixelFormat.u2.dwRBitMask | sdesc.u4.ddpfPixelFormat.u3.dwGBitMask | sdesc.u4.ddpfPixelFormat.u4.dwBBitMask;
 853               dwFlags &= ~(DDBLT_KEYSRC | DDBLT_KEYDEST | DDBLT_KEYSRCOVERRIDE | DDBLT_KEYDESTOVERRIDE);
 854            }
 855
 856            if (dwFlags & DDBLT_DDFX)  {
 857               LPBYTE dTopLeft, dTopRight, dBottomLeft, dBottomRight, tmp;
 858               LONG tmpxy;
 859               dTopLeft     = dbuf;
 860               dTopRight    = dbuf+((dstwidth-1)*bpp);
 861               dBottomLeft  = dTopLeft+((dstheight-1)*ddesc.u1.lPitch);
 862               dBottomRight = dBottomLeft+((dstwidth-1)*bpp);
 863
 864               if (lpbltfx->dwDDFX & DDBLTFX_ARITHSTRETCHY){
 865                  /* I don't think we need to do anything about this flag */
 866                  WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ARITHSTRETCHY\n");
 867               }
 868               if (lpbltfx->dwDDFX & DDBLTFX_MIRRORLEFTRIGHT) {
 869                  tmp          = dTopRight;
 870                  dTopRight    = dTopLeft;
 871                  dTopLeft     = tmp;
 872                  tmp          = dBottomRight;
 873                  dBottomRight = dBottomLeft;
 874                  dBottomLeft  = tmp;
 875                  dstxinc = dstxinc *-1;
 876               }
 877               if (lpbltfx->dwDDFX & DDBLTFX_MIRRORUPDOWN) {
 878                  tmp          = dTopLeft;
 879                  dTopLeft     = dBottomLeft;
 880                  dBottomLeft  = tmp;
 881                  tmp          = dTopRight;
 882                  dTopRight    = dBottomRight;
 883                  dBottomRight = tmp;
 884                  dstyinc = dstyinc *-1;
 885               }
 886               if (lpbltfx->dwDDFX & DDBLTFX_NOTEARING) {
 887                  /* I don't think we need to do anything about this flag */
 888                  WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_NOTEARING\n");
 889               }
 890               if (lpbltfx->dwDDFX & DDBLTFX_ROTATE180) {
 891                  tmp          = dBottomRight;
 892                  dBottomRight = dTopLeft;
 893                  dTopLeft     = tmp;
 894                  tmp          = dBottomLeft;
 895                  dBottomLeft  = dTopRight;
 896                  dTopRight    = tmp;
 897                  dstxinc = dstxinc * -1;
 898                  dstyinc = dstyinc * -1;
 899               }
 900               if (lpbltfx->dwDDFX & DDBLTFX_ROTATE270) {
 901                  tmp          = dTopLeft;
 902                  dTopLeft     = dBottomLeft;
 903                  dBottomLeft  = dBottomRight;
 904                  dBottomRight = dTopRight;
 905                  dTopRight    = tmp;
 906                  tmpxy   = dstxinc;
 907                  dstxinc = dstyinc;
 908                  dstyinc = tmpxy;
 909                  dstxinc = dstxinc * -1;
 910               }
 911               if (lpbltfx->dwDDFX & DDBLTFX_ROTATE90) {
 912                  tmp          = dTopLeft;
 913                  dTopLeft     = dTopRight;
 914                  dTopRight    = dBottomRight;
 915                  dBottomRight = dBottomLeft;
 916                  dBottomLeft  = tmp;
 917                  tmpxy   = dstxinc;
 918                  dstxinc = dstyinc;
 919                  dstyinc = tmpxy;
 920                  dstyinc = dstyinc * -1;
 921               }
 922               if (lpbltfx->dwDDFX & DDBLTFX_ZBUFFERBASEDEST) {
 923                  /* I don't think we need to do anything about this flag */
 924                  WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ZBUFFERBASEDEST\n");
 925               }
 926               dbuf = dTopLeft;
 927               dwFlags &= ~(DDBLT_DDFX);
 928            }
 929
 930 #define COPY_COLORKEY_FX(type) { \
 931             type *s, *d = (type *) dbuf, *dx, tmp; \
 932             for (y = sy = 0; y < dstheight; y++, sy += yinc) { \
 933                s = (type*)(sbase + (sy >> 16) * sdesc.u1.lPitch); \
 934                dx = d; \
 935                for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
 936                   tmp = s[sx >> 16]; \
 937                   if ((tmp & keymask) < keylow || (tmp & keymask) > keyhigh) dx[0] = tmp; \
 938                   dx = (type*)(((LPBYTE)dx)+dstxinc); \
 939                } \
 940                d = (type*)(((LPBYTE)d)+dstyinc); \
 941             } \
 942             break; }
 943
 944             switch (bpp) {
 945             case 1: COPY_COLORKEY_FX(BYTE)
 946             case 2: COPY_COLORKEY_FX(WORD)
 947             case 4: COPY_COLORKEY_FX(DWORD)
 948             case 3: {LPBYTE s,d = dbuf, dx;
 949                 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
 950                     sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
 951                     dx = d;
 952                     for (x = sx = 0; x < dstwidth; x++, sx+= xinc) {
 953                         DWORD pixel;
 954                         s = sbuf+3*(sx>>16);
 955                         pixel = s[0]|(s[1]<<8)|(s[2]<<16);
 956                         if ((pixel & keymask) < keylow || (pixel & keymask) > keyhigh) {
 957                             dx[0] = (pixel    )&0xff;
 958                             dx[1] = (pixel>> 8)&0xff;
 959                             dx[2] = (pixel>>16)&0xff;
 960                         }
 961                         dx+= dstxinc;
 962                     }
 963                     d += dstyinc;
 964                 }
 965                 break;}
 966             default:
 967                FIXME("%s color-keyed blit not implemented for bpp %d!\n",
 968                   (dwFlags & DDBLT_KEYSRC) ? "Source" : "Destination", bpp*8);
 969                   ret = DDERR_UNSUPPORTED;
 970                   goto error;
 971 #undef COPY_COLORKEY_FX
 972             }
 973         }
 974     }
 975
 976 error:
 977     if (dwFlags && FIXME_ON(ddraw)) {
 978         FIXME("\tUnsupported flags: ");
 979         DDRAW_dump_DDBLT(dwFlags);
 980     }
 981
 982 release:
 983     IDirectDrawSurface7_Unlock(iface,NULL);
 984     if (src && src != iface) IDirectDrawSurface7_Unlock(src,NULL);
 985     return ret;
 986 }
 987
 988 /* BltBatch: generic, unimplemented */
 989
 990 HRESULT WINAPI
 991 DIB_DirectDrawSurface_BltFast(LPDIRECTDRAWSURFACE7 iface, DWORD dstx,
 992                               DWORD dsty, LPDIRECTDRAWSURFACE7 src,
 993                               LPRECT rsrc, DWORD trans)
 994 {
 995     IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
 996     int                 bpp, w, h, x, y;
 997     DDSURFACEDESC2      ddesc,sdesc;
 998     HRESULT             ret = DD_OK;
 999     LPBYTE              sbuf, dbuf;
1000     RECT                rsrc2;
1001     RECT                lock_src, lock_dst, lock_union;
1002
1003     if (TRACE_ON(ddraw)) {
1004         TRACE("(%p)->(%ld,%ld,%p,%p,%08lx)\n",
1005                 This,dstx,dsty,src,rsrc,trans
1006         );
1007         TRACE("\ttrans:");
1008         if (FIXME_ON(ddraw))
1009           DDRAW_dump_DDBLTFAST(trans);
1010         if (rsrc)
1011           TRACE("\tsrcrect: %ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
1012         else
1013           TRACE(" srcrect: NULL\n");
1014     }
1015
1016     if ((This->locked) || ((src != NULL) && (((IDirectDrawSurfaceImpl *)src)->locked))) {
1017         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
1018         return DDERR_SURFACEBUSY;
1019     }
1020
1021     /* First, check if the possible override function handles this case */
1022     if (This->aux_bltfast != NULL) {
1023         if (This->aux_bltfast(This, dstx, dsty, src, rsrc, trans) == DD_OK) return DD_OK;
1024     }
1025
1026     /* Get the surface description without locking to first compute the width / height */
1027     ddesc = This->surface_desc;
1028     sdesc = (ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, src))->surface_desc;
1029
1030     if (!rsrc) {
1031         WARN("rsrc is NULL!\n");
1032         rsrc = &rsrc2;
1033         rsrc->left = rsrc->top = 0;
1034         rsrc->right = sdesc.dwWidth;
1035         rsrc->bottom = sdesc.dwHeight;
1036     }
1037
1038     /* Check source rect for validity. Copied from normal Blt. Fixes Baldur's Gate.*/
1039     if ((rsrc->bottom > sdesc.dwHeight) || (rsrc->bottom < 0) ||
1040         (rsrc->top > sdesc.dwHeight) || (rsrc->top < 0) ||
1041         (rsrc->left > sdesc.dwWidth) || (rsrc->left < 0) ||
1042         (rsrc->right > sdesc.dwWidth) || (rsrc->right < 0) ||
1043         (rsrc->right < rsrc->left) || (rsrc->bottom < rsrc->top)) {
1044         WARN("Application gave us bad source rectangle for BltFast.\n");
1045         return DDERR_INVALIDRECT;
1046     }
1047
1048     h=rsrc->bottom-rsrc->top;
1049     if (h>ddesc.dwHeight-dsty) h=ddesc.dwHeight-dsty;
1050     if (h>sdesc.dwHeight-rsrc->top) h=sdesc.dwHeight-rsrc->top;
1051     if (h<=0) return DDERR_INVALIDRECT;
1052
1053     w=rsrc->right-rsrc->left;
1054     if (w>ddesc.dwWidth-dstx) w=ddesc.dwWidth-dstx;
1055     if (w>sdesc.dwWidth-rsrc->left) w=sdesc.dwWidth-rsrc->left;
1056     if (w<=0) return DDERR_INVALIDRECT;
1057
1058     /* Now compute the locking rectangle... */
1059     lock_src.left = rsrc->left;
1060     lock_src.top = rsrc->top;
1061     lock_src.right = lock_src.left + w;
1062     lock_src.bottom = lock_src.top + h;
1063
1064     lock_dst.left = dstx;
1065     lock_dst.top = dsty;
1066     lock_dst.right = dstx + w;
1067     lock_dst.bottom = dsty + h;
1068
1069     bpp = GET_BPP(This->surface_desc);
1070
1071     /* We need to lock the surfaces, or we won't get refreshes when done. */
1072     if (src == iface) {
1073         int pitch;
1074
1075         UnionRect(&lock_union, &lock_src, &lock_dst);
1076
1077         /* Lock the union of the two rectangles */
1078         IDirectDrawSurface7_Lock(iface, &lock_union, &ddesc, 0, 0);
1079
1080         pitch = This->surface_desc.u1.lPitch;
1081
1082         /* Since sdesc was originally copied from this surface's description, we can just reuse it */
1083         sdesc.lpSurface = (BYTE *)This->surface_desc.lpSurface + lock_src.top * pitch + lock_src.left * bpp;
1084         ddesc.lpSurface = (BYTE *)This->surface_desc.lpSurface + lock_dst.top * pitch + lock_dst.left * bpp;
1085     } else {
1086         sdesc.dwSize = sizeof(sdesc);
1087         IDirectDrawSurface7_Lock(src, &lock_src, &sdesc, DDLOCK_READONLY, 0);
1088         ddesc.dwSize = sizeof(ddesc);
1089         IDirectDrawSurface7_Lock(iface, &lock_dst, &ddesc, DDLOCK_WRITEONLY, 0);
1090     }
1091
1092     /* Handle first the FOURCC surfaces... */
1093     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) && (ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)) {
1094         if (trans)
1095             FIXME("trans arg not supported when a FOURCC surface is involved\n");
1096         if (dstx || dsty)
1097             FIXME("offset for destination surface is not supported\n");
1098         if (sdesc.u4.ddpfPixelFormat.dwFourCC != sdesc.u4.ddpfPixelFormat.dwFourCC) {
1099             FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
1100             ret = DDERR_INVALIDPIXELFORMAT;
1101             goto error;
1102         }
1103         memcpy(ddesc.lpSurface, sdesc.lpSurface, ddesc.u1.dwLinearSize);
1104         goto error;
1105     }
1106     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
1107         (!(ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC))) {
1108         DoDXTCDecompression(&sdesc, &ddesc);
1109         goto error;
1110     }
1111
1112     sbuf = (BYTE *) sdesc.lpSurface;
1113     dbuf = (BYTE *) ddesc.lpSurface;
1114
1115     if (trans & (DDBLTFAST_SRCCOLORKEY | DDBLTFAST_DESTCOLORKEY)) {
1116         DWORD keylow, keyhigh;
1117         if (trans & DDBLTFAST_SRCCOLORKEY) {
1118             keylow  = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
1119             keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
1120         } else {
1121             /* I'm not sure if this is correct */
1122             FIXME("DDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
1123             keylow  = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
1124             keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
1125         }
1126
1127 #define COPYBOX_COLORKEY(type) { \
1128             type *d, *s, tmp; \
1129             s = (type *) sdesc.lpSurface; \
1130             d = (type *) ddesc.lpSurface; \
1131             for (y = 0; y < h; y++) { \
1132                 for (x = 0; x < w; x++) { \
1133                     tmp = s[x]; \
1134                     if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1135                 } \
1136                 s = (type *)((BYTE *)s + sdesc.u1.lPitch); \
1137                 d = (type *)((BYTE *)d + ddesc.u1.lPitch); \
1138             } \
1139             break; \
1140         }
1141
1142         switch (bpp) {
1143             case 1: COPYBOX_COLORKEY(BYTE)
1144             case 2: COPYBOX_COLORKEY(WORD)
1145             case 4: COPYBOX_COLORKEY(DWORD)
1146             case 3:
1147             {
1148                 BYTE *d, *s;
1149                 DWORD tmp;
1150                 s = (BYTE *) sdesc.lpSurface;
1151                 d = (BYTE *) ddesc.lpSurface;
1152                 for (y = 0; y < h; y++) {
1153                     for (x = 0; x < w * 3; x += 3) {
1154                         tmp = (DWORD)s[x] + ((DWORD)s[x + 1] << 8) + ((DWORD)s[x + 2] << 16);
1155                         if (tmp < keylow || tmp > keyhigh) {
1156                             d[x + 0] = s[x + 0];
1157                             d[x + 1] = s[x + 1];
1158                             d[x + 2] = s[x + 2];
1159                         }
1160                     }
1161                     s += sdesc.u1.lPitch;
1162                     d += ddesc.u1.lPitch;
1163                 }
1164                 break;
1165             }
1166             default:
1167                 FIXME("Source color key blitting not supported for bpp %d\n",bpp*8);
1168                 ret = DDERR_UNSUPPORTED;
1169                 goto error;
1170         }
1171 #undef COPYBOX_COLORKEY
1172     } else {
1173         int width = w * bpp;
1174
1175         for (y = 0; y < h; y++) {
1176             memcpy(dbuf, sbuf, width);
1177             sbuf += sdesc.u1.lPitch;
1178             dbuf += ddesc.u1.lPitch;
1179         }
1180     }
1181
1182 error:
1183     if (src == iface) {
1184         IDirectDrawSurface7_Unlock(iface, &lock_union);
1185     } else {
1186         IDirectDrawSurface7_Unlock(iface, &lock_dst);
1187         IDirectDrawSurface7_Unlock(src, &lock_src);
1188     }
1189
1190     return ret;
1191 }
1192
1193 /* ChangeUniquenessValue: generic */
1194 /* DeleteAttachedSurface: generic */
1195 /* EnumAttachedSurfaces: generic */
1196 /* EnumOverlayZOrders: generic, unimplemented */
1197
1198 BOOL DIB_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl* front,
1199                                      IDirectDrawSurfaceImpl* back,
1200                                      DWORD dwFlags)
1201 {
1202     DIB_DirectDrawSurfaceImpl* front_priv = front->private;
1203     DIB_DirectDrawSurfaceImpl* back_priv = back->private;
1204
1205     TRACE("(%p,%p)\n",front,back);
1206
1207     {
1208         HBITMAP tmp;
1209         tmp = front_priv->dib.DIBsection;
1210         front_priv->dib.DIBsection = back_priv->dib.DIBsection;
1211         back_priv->dib.DIBsection = tmp;
1212     }
1213
1214     {
1215         void* tmp;
1216         tmp = front_priv->dib.bitmap_data;
1217         front_priv->dib.bitmap_data = back_priv->dib.bitmap_data;
1218         back_priv->dib.bitmap_data = tmp;
1219
1220         tmp = front->surface_desc.lpSurface;
1221         front->surface_desc.lpSurface = back->surface_desc.lpSurface;
1222         back->surface_desc.lpSurface = tmp;
1223     }
1224
1225     /* client_memory should not be different, but just in case */
1226     {
1227         BOOL tmp;
1228         tmp = front_priv->dib.client_memory;
1229         front_priv->dib.client_memory = back_priv->dib.client_memory;
1230         back_priv->dib.client_memory = tmp;
1231     }
1232
1233     return Main_DirectDrawSurface_flip_data(front, back, dwFlags);
1234 }
1235
1236 /* Flip: generic */
1237 /* FreePrivateData: generic */
1238 /* GetAttachedSurface: generic */
1239 /* GetBltStatus: generic */
1240 /* GetCaps: generic (Returns the caps from This->surface_desc.) */
1241 /* GetClipper: generic */
1242 /* GetColorKey: generic */
1243
1244 HRESULT DIB_DirectDrawSurface_alloc_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
1245 {
1246     DIB_PRIV_VAR(priv, This);
1247     HDC hDC;
1248
1249     TRACE("Grabbing a DC for surface: %p\n", This);
1250
1251     hDC = CreateCompatibleDC(0);
1252     priv->dib.holdbitmap = SelectObject(hDC, priv->dib.DIBsection);
1253     if (This->palette)
1254         SelectPalette(hDC, This->palette->hpal, FALSE);
1255
1256     *phDC = hDC;
1257
1258     return S_OK;
1259 }
1260
1261 HRESULT DIB_DirectDrawSurface_free_dc(IDirectDrawSurfaceImpl* This, HDC hDC)
1262 {
1263     DIB_PRIV_VAR(priv, This);
1264
1265     TRACE("Releasing DC for surface: %p\n", This);
1266
1267     SelectObject(hDC, priv->dib.holdbitmap);
1268     DeleteDC(hDC);
1269
1270     return S_OK;
1271 }
1272
1273 HRESULT DIB_DirectDrawSurface_get_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
1274 {
1275     return DIB_DirectDrawSurface_alloc_dc(This, phDC);
1276 }
1277
1278 HRESULT DIB_DirectDrawSurface_release_dc(IDirectDrawSurfaceImpl* This, HDC hDC)
1279 {
1280     return DIB_DirectDrawSurface_free_dc(This, hDC);
1281 }
1282
1283 /* GetDDInterface: generic */
1284 /* GetFlipStatus: generic */
1285 /* GetLOD: generic */
1286 /* GetOverlayPosition: generic */
1287 /* GetPalette: generic */
1288 /* GetPixelFormat: generic */
1289 /* GetPriority: generic */
1290 /* GetPrivateData: generic */
1291 /* GetSurfaceDesc: generic */
1292 /* GetUniquenessValue: generic */
1293 /* Initialize: generic */
1294 /* IsLost: generic */
1295 /* Lock: generic with callback? */
1296 /* PageLock: generic */
1297 /* PageUnlock: generic */
1298
1299 HRESULT WINAPI
1300 DIB_DirectDrawSurface_Restore(LPDIRECTDRAWSURFACE7 iface)
1301 {
1302     TRACE("(%p)\n",iface);
1303     return DD_OK;       /* ??? */
1304 }
1305
1306 /* SetClipper: generic */
1307 /* SetColorKey: generic */
1308 /* SetLOD: generic */
1309 /* SetOverlayPosition: generic */
1310
1311 void DIB_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl* This,
1312                                        IDirectDrawPaletteImpl* pal)
1313 {
1314     if (!pal) return;
1315     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1316         This->update_palette(This, pal,
1317                              0, pal->palNumEntries,
1318                              pal->palents);
1319 }
1320
1321 void DIB_DirectDrawSurface_update_palette(IDirectDrawSurfaceImpl* This,
1322                                           IDirectDrawPaletteImpl* pal,
1323                                           DWORD dwStart, DWORD dwCount,
1324                                           LPPALETTEENTRY palent)
1325 {
1326     RGBQUAD col[256];
1327     unsigned int n;
1328     HDC dc;
1329
1330     TRACE("updating primary palette\n");
1331     for (n=0; n<dwCount; n++) {
1332       col[n].rgbRed   = palent[n].peRed;
1333       col[n].rgbGreen = palent[n].peGreen;
1334       col[n].rgbBlue  = palent[n].peBlue;
1335       col[n].rgbReserved = 0;
1336     }
1337     This->get_dc(This, &dc);
1338     SetDIBColorTable(dc, dwStart, dwCount, col);
1339     This->release_dc(This, dc);
1340
1341     /* Propagate change to backbuffers if there are any */
1342     /* Basically this is a modification of the Flip code to find the backbuffer */
1343     /* and duplicate the palette update there as well */
1344     if ((This->surface_desc.ddsCaps.dwCaps&(DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
1345         == (DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
1346     {
1347         static DDSCAPS2 back_caps = { DDSCAPS_BACKBUFFER };
1348         LPDIRECTDRAWSURFACE7 tgt;
1349
1350         HRESULT hr = IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(This,IDirectDrawSurface7),
1351                                                             &back_caps, &tgt);
1352         if (!FAILED(hr))
1353         {
1354             IDirectDrawSurfaceImpl* target = ICOM_OBJECT(IDirectDrawSurfaceImpl,
1355                                                          IDirectDrawSurface7,tgt);
1356             IDirectDrawSurface7_Release(tgt);
1357             target->get_dc(target, &dc);
1358             SetDIBColorTable(dc, dwStart, dwCount, col);
1359             target->release_dc(target, dc);
1360         }
1361     }
1362 }
1363
1364 /* SetPalette: generic */
1365 /* SetPriority: generic */
1366 /* SetPrivateData: generic */
1367
1368 HRESULT WINAPI
1369 DIB_DirectDrawSurface_SetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
1370                                      LPDDSURFACEDESC2 pDDSD, DWORD dwFlags)
1371 {
1372     IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
1373     DIB_PRIV_VAR(priv, This);
1374     HRESULT hr = DD_OK;
1375     DWORD flags = pDDSD->dwFlags;
1376
1377     if (TRACE_ON(ddraw)) {
1378         TRACE("(%p)->(%p,%08lx)\n",iface,pDDSD,dwFlags);
1379         DDRAW_dump_surface_desc(pDDSD);
1380     }
1381
1382     if (pDDSD->dwFlags & DDSD_PIXELFORMAT) {
1383         flags &= ~DDSD_PIXELFORMAT;
1384         if (flags & DDSD_LPSURFACE) {
1385             This->surface_desc.u4.ddpfPixelFormat = pDDSD->u4.ddpfPixelFormat;
1386         } else {
1387             FIXME("Change of pixel format without surface re-allocation is not supported !\n");
1388         }
1389     }
1390     if (pDDSD->dwFlags & DDSD_LPSURFACE) {
1391         HBITMAP oldbmp = priv->dib.DIBsection;
1392         LPVOID oldsurf = This->surface_desc.lpSurface;
1393         BOOL oldc = priv->dib.client_memory;
1394
1395         flags &= ~DDSD_LPSURFACE;
1396
1397         TRACE("new lpSurface=%p\n",pDDSD->lpSurface);
1398         This->surface_desc.lpSurface = pDDSD->lpSurface;
1399         priv->dib.client_memory = TRUE;
1400
1401         hr = create_dib(This);
1402         if (FAILED(hr))
1403         {
1404             priv->dib.DIBsection = oldbmp;
1405             This->surface_desc.lpSurface = oldsurf;
1406             priv->dib.client_memory = oldc;
1407             return hr;
1408         }
1409
1410         DeleteObject(oldbmp);
1411
1412         if (!oldc)
1413             VirtualFree(oldsurf, 0, MEM_RELEASE);
1414     }
1415     if (flags) {
1416         WARN("Unhandled flags : %08lx\n", flags);
1417     }
1418     return hr;
1419 }
1420
1421 /* Unlock: ???, need callback */
1422 /* UpdateOverlay: generic */
1423 /* UpdateOverlayDisplay: generic */
1424 /* UpdateOverlayZOrder: generic */
1425
1426 static const IDirectDrawSurface7Vtbl DIB_IDirectDrawSurface7_VTable =
1427 {
1428     Main_DirectDrawSurface_QueryInterface,
1429     Main_DirectDrawSurface_AddRef,
1430     Main_DirectDrawSurface_Release,
1431     Main_DirectDrawSurface_AddAttachedSurface,
1432     Main_DirectDrawSurface_AddOverlayDirtyRect,
1433     DIB_DirectDrawSurface_Blt,
1434     Main_DirectDrawSurface_BltBatch,
1435     DIB_DirectDrawSurface_BltFast,
1436     Main_DirectDrawSurface_DeleteAttachedSurface,
1437     Main_DirectDrawSurface_EnumAttachedSurfaces,
1438     Main_DirectDrawSurface_EnumOverlayZOrders,
1439     Main_DirectDrawSurface_Flip,
1440     Main_DirectDrawSurface_GetAttachedSurface,
1441     Main_DirectDrawSurface_GetBltStatus,
1442     Main_DirectDrawSurface_GetCaps,
1443     Main_DirectDrawSurface_GetClipper,
1444     Main_DirectDrawSurface_GetColorKey,
1445     Main_DirectDrawSurface_GetDC,
1446     Main_DirectDrawSurface_GetFlipStatus,
1447     Main_DirectDrawSurface_GetOverlayPosition,
1448     Main_DirectDrawSurface_GetPalette,
1449     Main_DirectDrawSurface_GetPixelFormat,
1450     Main_DirectDrawSurface_GetSurfaceDesc,
1451     Main_DirectDrawSurface_Initialize,
1452     Main_DirectDrawSurface_IsLost,
1453     Main_DirectDrawSurface_Lock,
1454     Main_DirectDrawSurface_ReleaseDC,
1455     DIB_DirectDrawSurface_Restore,
1456     Main_DirectDrawSurface_SetClipper,
1457     Main_DirectDrawSurface_SetColorKey,
1458     Main_DirectDrawSurface_SetOverlayPosition,
1459     Main_DirectDrawSurface_SetPalette,
1460     Main_DirectDrawSurface_Unlock,
1461     Main_DirectDrawSurface_UpdateOverlay,
1462     Main_DirectDrawSurface_UpdateOverlayDisplay,
1463     Main_DirectDrawSurface_UpdateOverlayZOrder,
1464     Main_DirectDrawSurface_GetDDInterface,
1465     Main_DirectDrawSurface_PageLock,
1466     Main_DirectDrawSurface_PageUnlock,
1467     DIB_DirectDrawSurface_SetSurfaceDesc,
1468     Main_DirectDrawSurface_SetPrivateData,
1469     Main_DirectDrawSurface_GetPrivateData,
1470     Main_DirectDrawSurface_FreePrivateData,
1471     Main_DirectDrawSurface_GetUniquenessValue,
1472     Main_DirectDrawSurface_ChangeUniquenessValue,
1473     Main_DirectDrawSurface_SetPriority,
1474     Main_DirectDrawSurface_GetPriority,
1475     Main_DirectDrawSurface_SetLOD,
1476     Main_DirectDrawSurface_GetLOD
1477 };