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

   1 /*
   2  * Unit tests for (a few) ddraw surface functions
   3  *
   4  * Copyright (C) 2005 Antoine Chavasse (a.chavasse@gmail.com)
   5  * Copyright (C) 2005 Christian Costa
   6  * Copyright 2005 Ivan Leo Puoti
   7  * Copyright (C) 2007 Stefan Dösinger
   8  * Copyright (C) 2008 Alexander Dorofeyev
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24 #define COBJMACROS
  25
  26 #include <assert.h>
  27 #include "wine/test.h"
  28 #include "ddraw.h"
  29 #include "d3d.h"
  30 #include "unknwn.h"
  31
  32 static LPDIRECTDRAW lpDD = NULL;
  33
  34 static BOOL CreateDirectDraw(void)
  35 {
  36     HRESULT rc;
  37
  38     rc = DirectDrawCreate(NULL, &lpDD, NULL);
  39     ok(rc==DD_OK || rc==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", rc);
  40     if (!lpDD) {
  41         trace("DirectDrawCreateEx() failed with an error %x\n", rc);
  42         return FALSE;
  43     }
  44
  45     rc = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL);
  46     ok(rc==DD_OK,"SetCooperativeLevel returned: %x\n",rc);
  47
  48     return TRUE;
  49 }
  50
  51
  52 static void ReleaseDirectDraw(void)
  53 {
  54     if( lpDD != NULL )
  55     {
  56         IDirectDraw_Release(lpDD);
  57         lpDD = NULL;
  58     }
  59 }
  60
  61 static void MipMapCreationTest(void)
  62 {
  63     LPDIRECTDRAWSURFACE lpDDSMipMapTest;
  64     DDSURFACEDESC ddsd;
  65     HRESULT rc;
  66
  67     /* First mipmap creation test: create a surface with DDSCAPS_COMPLEX,
  68        DDSCAPS_MIPMAP, and DDSD_MIPMAPCOUNT. This create the number of
  69         requested mipmap levels. */
  70     ddsd.dwSize = sizeof(ddsd);
  71     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT;
  72     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
  73     U2(ddsd).dwMipMapCount = 3;
  74     ddsd.dwWidth = 128;
  75     ddsd.dwHeight = 32;
  76     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL);
  77     ok(rc==DD_OK,"CreateSurface returned: %x\n",rc);
  78     if (FAILED(rc)) {
  79         skip("failed to create surface\n");
  80         return;
  81     }
  82
  83     /* Check the number of created mipmaps */
  84     memset(&ddsd, 0, sizeof(DDSURFACEDESC));
  85     ddsd.dwSize = sizeof(ddsd);
  86     rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd);
  87     ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc);
  88     ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT,
  89         "GetSurfaceDesc returned no mipmapcount.\n");
  90     ok(U2(ddsd).dwMipMapCount == 3, "Incorrect mipmap count: %d.\n",
  91         U2(ddsd).dwMipMapCount);
  92
  93     /* Destroy the surface. */
  94     IDirectDrawSurface_Release(lpDDSMipMapTest);
  95
  96
  97     /* Second mipmap creation test: create a surface without a mipmap
  98        count, with DDSCAPS_MIPMAP and without DDSCAPS_COMPLEX.
  99        This creates a single mipmap level. */
 100     memset(&ddsd, 0, sizeof(DDSURFACEDESC));
 101     ddsd.dwSize = sizeof(ddsd);
 102     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
 103     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
 104     ddsd.dwWidth = 128;
 105     ddsd.dwHeight = 32;
 106     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL);
 107     ok(rc==DD_OK,"CreateSurface returned: %x\n",rc);
 108     if (FAILED(rc)) {
 109         skip("failed to create surface\n");
 110         return;
 111     }
 112     /* Check the number of created mipmaps */
 113     memset(&ddsd, 0, sizeof(DDSURFACEDESC));
 114     ddsd.dwSize = sizeof(ddsd);
 115     rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd);
 116     ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc);
 117     ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT,
 118         "GetSurfaceDesc returned no mipmapcount.\n");
 119     ok(U2(ddsd).dwMipMapCount == 1, "Incorrect mipmap count: %d.\n",
 120         U2(ddsd).dwMipMapCount);
 121
 122     /* Destroy the surface. */
 123     IDirectDrawSurface_Release(lpDDSMipMapTest);
 124
 125
 126     /* Third mipmap creation test: create a surface with DDSCAPS_MIPMAP,
 127         DDSCAPS_COMPLEX and without DDSD_MIPMAPCOUNT.
 128        It's an undocumented features where a chain of mipmaps, starting from
 129        he specified size and down to the smallest size, is automatically
 130        created.
 131        Anarchy Online needs this feature to work. */
 132     memset(&ddsd, 0, sizeof(DDSURFACEDESC));
 133     ddsd.dwSize = sizeof(ddsd);
 134     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
 135     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
 136     ddsd.dwWidth = 128;
 137     ddsd.dwHeight = 32;
 138     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL);
 139     ok(rc==DD_OK,"CreateSurface returned: %x\n",rc);
 140     if (FAILED(rc)) {
 141         skip("failed to create surface\n");
 142         return;
 143     }
 144
 145     /* Check the number of created mipmaps */
 146     memset(&ddsd, 0, sizeof(DDSURFACEDESC));
 147     ddsd.dwSize = sizeof(ddsd);
 148     rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd);
 149     ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc);
 150     ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT,
 151         "GetSurfaceDesc returned no mipmapcount.\n");
 152     ok(U2(ddsd).dwMipMapCount == 6, "Incorrect mipmap count: %d.\n",
 153         U2(ddsd).dwMipMapCount);
 154
 155     /* Destroy the surface. */
 156     IDirectDrawSurface_Release(lpDDSMipMapTest);
 157
 158
 159     /* Fourth mipmap creation test: same as above with a different texture
 160        size.
 161        The purpose is to verify that the number of generated mipmaps is
 162        dependent on the smallest dimension. */
 163     memset(&ddsd, 0, sizeof(DDSURFACEDESC));
 164     ddsd.dwSize = sizeof(ddsd);
 165     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
 166     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
 167     ddsd.dwWidth = 32;
 168     ddsd.dwHeight = 64;
 169     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL);
 170     ok(rc==DD_OK,"CreateSurface returned: %x\n",rc);
 171     if (FAILED(rc)) {
 172         skip("failed to create surface\n");
 173         return;
 174     }
 175
 176     /* Check the number of created mipmaps */
 177     memset(&ddsd, 0, sizeof(DDSURFACEDESC));
 178     ddsd.dwSize = sizeof(ddsd);
 179     rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd);
 180     ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc);
 181     ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT,
 182         "GetSurfaceDesc returned no mipmapcount.\n");
 183     ok(U2(ddsd).dwMipMapCount == 6, "Incorrect mipmap count: %d.\n",
 184         U2(ddsd).dwMipMapCount);
 185
 186     /* Destroy the surface. */
 187     IDirectDrawSurface_Release(lpDDSMipMapTest);
 188
 189
 190     /* Fifth mipmap creation test: try to create a surface with
 191        DDSCAPS_COMPLEX, DDSCAPS_MIPMAP, DDSD_MIPMAPCOUNT,
 192        where dwMipMapCount = 0. This should fail. */
 193
 194     ddsd.dwSize = sizeof(ddsd);
 195     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT;
 196     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
 197     U2(ddsd).dwMipMapCount = 0;
 198     ddsd.dwWidth = 128;
 199     ddsd.dwHeight = 32;
 200     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL);
 201     ok(rc==DDERR_INVALIDPARAMS,"CreateSurface returned: %x\n",rc);
 202
 203     /* Destroy the surface. */
 204     if( rc == DD_OK )
 205         IDirectDrawSurface_Release(lpDDSMipMapTest);
 206
 207 }
 208
 209 static void SrcColorKey32BlitTest(void)
 210 {
 211     LPDIRECTDRAWSURFACE lpSrc;
 212     LPDIRECTDRAWSURFACE lpDst;
 213     DDSURFACEDESC ddsd, ddsd2, ddsd3;
 214     DDCOLORKEY DDColorKey;
 215     LPDWORD lpData;
 216     HRESULT rc;
 217     DDBLTFX fx;
 218
 219     ddsd2.dwSize = sizeof(ddsd2);
 220     ddsd2.ddpfPixelFormat.dwSize = sizeof(ddsd2.ddpfPixelFormat);
 221
 222     ddsd.dwSize = sizeof(ddsd);
 223     ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
 224     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
 225     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
 226     ddsd.dwWidth = 800;
 227     ddsd.dwHeight = 600;
 228     ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
 229     U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
 230     U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000;
 231     U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00;
 232     U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF;
 233     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDst, NULL);
 234     ok(rc==DD_OK,"CreateSurface returned: %x\n",rc);
 235     if (FAILED(rc)) {
 236         skip("failed to create surface\n");
 237         return;
 238     }
 239
 240     ddsd.dwFlags |= DDSD_CKSRCBLT;
 241     ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0xFF00FF;
 242     ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0xFF00FF;
 243     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSrc, NULL);
 244     ok(rc==DD_OK,"CreateSurface returned: %x\n",rc);
 245     if (FAILED(rc)) {
 246         skip("failed to create surface\n");
 247         return;
 248     }
 249
 250     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 251     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 252     lpData = ddsd2.lpSurface;
 253     lpData[0] = 0xCCCCCCCC;
 254     lpData[1] = 0xCCCCCCCC;
 255     lpData[2] = 0xCCCCCCCC;
 256     lpData[3] = 0xCCCCCCCC;
 257
 258     memset(&ddsd3, 0, sizeof(ddsd3));
 259     ddsd3.dwSize = sizeof(ddsd3);
 260     ddsd3.ddpfPixelFormat.dwSize = sizeof(ddsd3.ddpfPixelFormat);
 261     rc = IDirectDrawSurface_GetSurfaceDesc(lpDst, &ddsd3);
 262     ok(rc == DD_OK, "IDirectDrawSurface_GetSurfaceDesc between a lock/unlock pair returned %08x\n", rc);
 263     ok(ddsd3.lpSurface == ddsd3.lpSurface, "lpSurface from GetSurfaceDesc(%p) differs from the one returned by Lock(%p)\n", ddsd3.lpSurface, ddsd2.lpSurface);
 264
 265     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 266     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 267
 268     memset(&ddsd3, 0, sizeof(ddsd3));
 269     ddsd3.dwSize = sizeof(ddsd3);
 270     ddsd3.ddpfPixelFormat.dwSize = sizeof(ddsd3.ddpfPixelFormat);
 271     rc = IDirectDrawSurface_GetSurfaceDesc(lpDst, &ddsd3);
 272     ok(rc == DD_OK, "IDirectDrawSurface_GetSurfaceDesc between a lock/unlock pair returned %08x\n", rc);
 273     ok(ddsd3.lpSurface == NULL, "lpSurface from GetSurfaceDesc(%p) is not NULL after unlock\n", ddsd3.lpSurface);
 274
 275     rc = IDirectDrawSurface_Lock(lpSrc, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 276     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 277     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 278     lpData = ddsd2.lpSurface;
 279     lpData[0] = 0x77010203;
 280     lpData[1] = 0x00010203;
 281     lpData[2] = 0x77FF00FF;
 282     lpData[3] = 0x00FF00FF;
 283     rc = IDirectDrawSurface_Unlock(lpSrc, NULL);
 284     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 285
 286     IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC, NULL);
 287
 288     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 289     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 290     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 291     lpData = ddsd2.lpSurface;
 292     /* Different behavior on some drivers / windows versions. Some versions ignore the X channel when
 293      * color keying, but copy it to the destination surface. Others apply it for color keying, but
 294      * do not copy it into the destination surface.
 295      */
 296     if(lpData[0]==0x00010203) {
 297         trace("X channel was not copied into the destination surface\n");
 298         ok((lpData[0]==0x00010203)&&(lpData[1]==0x00010203)&&(lpData[2]==0x00FF00FF)&&(lpData[3]==0xCCCCCCCC),
 299            "Destination data after blitting is not correct\n");
 300     } else {
 301         ok((lpData[0]==0x77010203)&&(lpData[1]==0x00010203)&&(lpData[2]==0xCCCCCCCC)&&(lpData[3]==0xCCCCCCCC),
 302            "Destination data after blitting is not correct\n");
 303     }
 304     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 305     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 306
 307     /* Also test SetColorKey */
 308     IDirectDrawSurface_GetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey);
 309     ok(DDColorKey.dwColorSpaceLowValue == 0xFF00FF && DDColorKey.dwColorSpaceHighValue == 0xFF00FF,
 310        "GetColorKey does not return the colorkey used at surface creation\n");
 311
 312     DDColorKey.dwColorSpaceLowValue = 0x00FF00;
 313     DDColorKey.dwColorSpaceHighValue = 0x00FF00;
 314     IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey);
 315
 316     DDColorKey.dwColorSpaceLowValue = 0;
 317     DDColorKey.dwColorSpaceHighValue = 0;
 318     IDirectDrawSurface_GetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey);
 319     ok(DDColorKey.dwColorSpaceLowValue == 0x00FF00 && DDColorKey.dwColorSpaceHighValue == 0x00FF00,
 320        "GetColorKey does not return the colorkey set with SetColorKey\n");
 321
 322     ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0;
 323     ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0;
 324     IDirectDrawSurface_GetSurfaceDesc(lpSrc, &ddsd);
 325     ok(ddsd.ddckCKSrcBlt.dwColorSpaceLowValue == 0x00FF00 && ddsd.ddckCKSrcBlt.dwColorSpaceHighValue == 0x00FF00,
 326        "GetSurfaceDesc does not return the colorkey set with SetColorKey\n");
 327
 328     IDirectDrawSurface_Release(lpSrc);
 329     IDirectDrawSurface_Release(lpDst);
 330
 331     /* start with a new set of surfaces to test the color keying parameters to blit */
 332     memset(&ddsd, 0, sizeof(ddsd));
 333     ddsd.dwSize = sizeof(ddsd);
 334     ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
 335     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT | DDSD_CKDESTBLT;
 336     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
 337     ddsd.dwWidth = 800;
 338     ddsd.dwHeight = 600;
 339     ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
 340     U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
 341     U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000;
 342     U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00;
 343     U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF;
 344     ddsd.ddckCKDestBlt.dwColorSpaceLowValue = 0xFF0000;
 345     ddsd.ddckCKDestBlt.dwColorSpaceHighValue = 0xFF0000;
 346     ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0x00FF00;
 347     ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0x00FF00;
 348     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDst, NULL);
 349     ok(rc==DD_OK || rc == DDERR_NOCOLORKEYHW,"CreateSurface returned: %x\n",rc);
 350     if(FAILED(rc))
 351     {
 352         skip("Failed to create surface\n");
 353         return;
 354     }
 355
 356     /* start with a new set of surfaces to test the color keying parameters to blit */
 357     memset(&ddsd, 0, sizeof(ddsd));
 358     ddsd.dwSize = sizeof(ddsd);
 359     ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
 360     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT | DDSD_CKDESTBLT;
 361     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
 362     ddsd.dwWidth = 800;
 363     ddsd.dwHeight = 600;
 364     ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
 365     U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
 366     U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000;
 367     U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00;
 368     U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF;
 369     ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0x0000FF;
 370     ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0x0000FF;
 371     ddsd.ddckCKDestBlt.dwColorSpaceLowValue = 0x000000;
 372     ddsd.ddckCKDestBlt.dwColorSpaceHighValue = 0x000000;
 373     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSrc, NULL);
 374     ok(rc==DD_OK || rc == DDERR_NOCOLORKEYHW,"CreateSurface returned: %x\n",rc);
 375     if(FAILED(rc))
 376     {
 377         skip("Failed to create surface\n");
 378         IDirectDrawSurface_Release(lpDst);
 379         return;
 380     }
 381
 382     memset(&fx, 0, sizeof(fx));
 383     fx.dwSize = sizeof(fx);
 384     fx.ddckSrcColorkey.dwColorSpaceHighValue = 0x110000;
 385     fx.ddckSrcColorkey.dwColorSpaceLowValue = 0x110000;
 386     fx.ddckDestColorkey.dwColorSpaceHighValue = 0x001100;
 387     fx.ddckDestColorkey.dwColorSpaceLowValue = 0x001100;
 388
 389     rc = IDirectDrawSurface_Lock(lpSrc, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 390     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 391     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 392     lpData = ddsd2.lpSurface;
 393     lpData[0] = 0x000000FF; /* Applies to src blt key in src surface */
 394     lpData[1] = 0x00000000; /* Applies to dst blt key in src surface */
 395     lpData[2] = 0x00FF0000; /* Dst color key in dst surface */
 396     lpData[3] = 0x0000FF00; /* Src color key in dst surface */
 397     lpData[4] = 0x00001100; /* Src color key in ddbltfx */
 398     lpData[5] = 0x00110000; /* Dst color key in ddbltfx */
 399     rc = IDirectDrawSurface_Unlock(lpSrc, NULL);
 400     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 401
 402     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 403     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 404     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 405     lpData = ddsd2.lpSurface;
 406     lpData[0] = 0x55555555;
 407     lpData[1] = 0x55555555;
 408     lpData[2] = 0x55555555;
 409     lpData[3] = 0x55555555;
 410     lpData[4] = 0x55555555;
 411     lpData[5] = 0x55555555;
 412     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 413     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 414
 415     /* Test a blit without keying */
 416     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, 0, &fx);
 417     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 418
 419     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 420     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 421     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 422     lpData = ddsd2.lpSurface;
 423     /* Should have copied src data unmodified to dst */
 424     ok(lpData[0] == 0x000000FF &&
 425        lpData[1] == 0x00000000 &&
 426        lpData[2] == 0x00FF0000 &&
 427        lpData[3] == 0x0000FF00 &&
 428        lpData[4] == 0x00001100 &&
 429        lpData[5] == 0x00110000, "Surface data after unkeyed blit does not match\n");
 430
 431     lpData[0] = 0x55555555;
 432     lpData[1] = 0x55555555;
 433     lpData[2] = 0x55555555;
 434     lpData[3] = 0x55555555;
 435     lpData[4] = 0x55555555;
 436     lpData[5] = 0x55555555;
 437     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 438     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 439
 440     /* Src key */
 441     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC, &fx);
 442     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 443
 444     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 445     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 446     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 447     lpData = ddsd2.lpSurface;
 448
 449     ok(lpData[0] == 0x55555555 && /* Here the src key applied */
 450        lpData[1] == 0x00000000 &&
 451        lpData[2] == 0x00FF0000 &&
 452        lpData[3] == 0x0000FF00 &&
 453        lpData[4] == 0x00001100 &&
 454        lpData[5] == 0x00110000, "Surface data after srckey blit does not match\n");
 455
 456     lpData[0] = 0x55555555;
 457     lpData[1] = 0x55555555;
 458     lpData[2] = 0x55555555;
 459     lpData[3] = 0x55555555;
 460     lpData[4] = 0x55555555;
 461     lpData[5] = 0x55555555;
 462     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 463     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 464
 465     /* Src override */
 466     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRCOVERRIDE, &fx);
 467     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 468
 469     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 470     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 471     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 472     lpData = ddsd2.lpSurface;
 473
 474     ok(lpData[0] == 0x000000FF &&
 475        lpData[1] == 0x00000000 &&
 476        lpData[2] == 0x00FF0000 &&
 477        lpData[3] == 0x0000FF00 &&
 478        lpData[4] == 0x00001100 &&
 479        lpData[5] == 0x55555555, /* Override key applies here */
 480        "Surface data after src override key blit does not match\n");
 481
 482     lpData[0] = 0x55555555;
 483     lpData[1] = 0x55555555;
 484     lpData[2] = 0x55555555;
 485     lpData[3] = 0x55555555;
 486     lpData[4] = 0x55555555;
 487     lpData[5] = 0x55555555;
 488     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 489     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 490
 491     /* Src override AND src key. That is not supposed to work */
 492     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC | DDBLT_KEYSRCOVERRIDE, &fx);
 493     ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc);
 494
 495     /* Verify that the destination is unchanged */
 496     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 497     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 498     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 499     lpData = ddsd2.lpSurface;
 500
 501     ok(lpData[0] == 0x55555555 &&
 502        lpData[1] == 0x55555555 &&
 503        lpData[2] == 0x55555555 &&
 504        lpData[3] == 0x55555555 &&
 505        lpData[4] == 0x55555555 &&
 506        lpData[5] == 0x55555555, /* Override key applies here */
 507        "Surface data after src key blit with override does not match\n");
 508
 509     lpData[0] = 0x00FF0000; /* Dest key in dst surface */
 510     lpData[1] = 0x00FF0000; /* Dest key in dst surface */
 511     lpData[2] = 0x00001100; /* Dest key in override */
 512     lpData[3] = 0x00001100; /* Dest key in override */
 513     lpData[4] = 0x00000000; /* Dest key in src surface */
 514     lpData[5] = 0x00000000; /* Dest key in src surface */
 515     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 516     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 517
 518     /* Dest key blit */
 519     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST, &fx);
 520     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 521
 522     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 523     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 524     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 525     lpData = ddsd2.lpSurface;
 526
 527     /* DirectDraw uses the dest blit key from the SOURCE surface ! */
 528     ok(lpData[0] == 0x00ff0000 &&
 529        lpData[1] == 0x00ff0000 &&
 530        lpData[2] == 0x00001100 &&
 531        lpData[3] == 0x00001100 &&
 532        lpData[4] == 0x00001100 && /* Key applies here */
 533        lpData[5] == 0x00110000,   /* Key applies here */
 534        "Surface data after dest key blit does not match\n");
 535
 536     lpData[0] = 0x00FF0000; /* Dest key in dst surface */
 537     lpData[1] = 0x00FF0000; /* Dest key in dst surface */
 538     lpData[2] = 0x00001100; /* Dest key in override */
 539     lpData[3] = 0x00001100; /* Dest key in override */
 540     lpData[4] = 0x00000000; /* Dest key in src surface */
 541     lpData[5] = 0x00000000; /* Dest key in src surface */
 542     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 543     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 544
 545     /* Dest override key blit */
 546     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDESTOVERRIDE, &fx);
 547     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 548
 549     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 550     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 551     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 552     lpData = ddsd2.lpSurface;
 553
 554     ok(lpData[0] == 0x00FF0000 &&
 555        lpData[1] == 0x00FF0000 &&
 556        lpData[2] == 0x00FF0000 && /* Key applies here */
 557        lpData[3] == 0x0000FF00 && /* Key applies here */
 558        lpData[4] == 0x00000000 &&
 559        lpData[5] == 0x00000000,
 560        "Surface data after dest key override blit does not match\n");
 561
 562     lpData[0] = 0x00FF0000; /* Dest key in dst surface */
 563     lpData[1] = 0x00FF0000; /* Dest key in dst surface */
 564     lpData[2] = 0x00001100; /* Dest key in override */
 565     lpData[3] = 0x00001100; /* Dest key in override */
 566     lpData[4] = 0x00000000; /* Dest key in src surface */
 567     lpData[5] = 0x00000000; /* Dest key in src surface */
 568     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 569     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 570
 571     /* Dest override key blit. Supposed to fail too */
 572     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST | DDBLT_KEYDESTOVERRIDE, &fx);
 573     ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc);
 574
 575     /* Check for unchanged data */
 576     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 577     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 578     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 579     lpData = ddsd2.lpSurface;
 580
 581     ok(lpData[0] == 0x00FF0000 &&
 582        lpData[1] == 0x00FF0000 &&
 583        lpData[2] == 0x00001100 && /* Key applies here */
 584        lpData[3] == 0x00001100 && /* Key applies here */
 585        lpData[4] == 0x00000000 &&
 586        lpData[5] == 0x00000000,
 587        "Surface data with dest key and dest override does not match\n");
 588
 589     lpData[0] = 0x00FF0000; /* Dest key in dst surface */
 590     lpData[1] = 0x00FF0000; /* Dest key in dst surface */
 591     lpData[2] = 0x00001100; /* Dest key in override */
 592     lpData[3] = 0x00001100; /* Dest key in override */
 593     lpData[4] = 0x00000000; /* Dest key in src surface */
 594     lpData[5] = 0x00000000; /* Dest key in src surface */
 595     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 596     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 597
 598     /* Modify the source data a bit to give some more conclusive results */
 599     rc = IDirectDrawSurface_Lock(lpSrc, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 600     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 601     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 602     lpData = ddsd2.lpSurface;
 603     lpData[5] = 0x000000FF; /* Applies to src blt key in src surface */
 604     rc = IDirectDrawSurface_Unlock(lpSrc, NULL);
 605     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 606
 607     /* Source and destination key */
 608     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST | DDBLT_KEYSRC, &fx);
 609     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 610
 611     rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL);
 612     ok(rc==DD_OK,"Lock returned: %x\n",rc);
 613     ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n");
 614     lpData = ddsd2.lpSurface;
 615
 616     ok(lpData[0] == 0x00FF0000 && /* Masked by Destination key */
 617        lpData[1] == 0x00FF0000 && /* Masked by Destination key */
 618        lpData[2] == 0x00001100 && /* Masked by Destination key */
 619        lpData[3] == 0x00001100 && /* Masked by Destination key */
 620        lpData[4] == 0x00001100 && /* Allowed by destination key, not masked by source key */
 621        lpData[5] == 0x00000000,   /* Allowed by dst key, but masked by source key */
 622        "Surface data with src key and dest key blit does not match\n");
 623
 624     lpData[0] = 0x00FF0000; /* Dest key in dst surface */
 625     lpData[1] = 0x00FF0000; /* Dest key in dst surface */
 626     lpData[2] = 0x00001100; /* Dest key in override */
 627     lpData[3] = 0x00001100; /* Dest key in override */
 628     lpData[4] = 0x00000000; /* Dest key in src surface */
 629     lpData[5] = 0x00000000; /* Dest key in src surface */
 630     rc = IDirectDrawSurface_Unlock(lpDst, NULL);
 631     ok(rc==DD_OK,"Unlock returned: %x\n",rc);
 632
 633     /* Override keys without ddbltfx parameter fail */
 634     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDESTOVERRIDE, NULL);
 635     ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc);
 636     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRCOVERRIDE, NULL);
 637     ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc);
 638
 639     /* Try blitting without keys in the source surface*/
 640     rc = IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_SRCBLT, NULL);
 641     ok(rc == DD_OK, "SetColorKey returned %x\n", rc);
 642     rc = IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_DESTBLT, NULL);
 643     ok(rc == DD_OK, "SetColorKey returned %x\n", rc);
 644
 645     /* That fails now. Do not bother to check that the data is unmodified */
 646     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC, &fx);
 647     ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc);
 648
 649     /* Dest key blit still works. Which key is used this time??? */
 650     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST, &fx);
 651     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 652
 653     /* With correctly passed override keys no key in the surface is needed.
 654      * Again, the result was checked before, no need to do that again
 655      */
 656     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDESTOVERRIDE, &fx);
 657     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 658     rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRCOVERRIDE, &fx);
 659     ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc);
 660
 661     IDirectDrawSurface_Release(lpSrc);
 662     IDirectDrawSurface_Release(lpDst);
 663 }
 664
 665 static void QueryInterface(void)
 666 {
 667     LPDIRECTDRAWSURFACE dsurface;
 668     DDSURFACEDESC surface;
 669     LPVOID object;
 670     HRESULT ret;
 671
 672     /* Create a surface */
 673     ZeroMemory(&surface, sizeof(surface));
 674     surface.dwSize = sizeof(surface);
 675     surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
 676     surface.dwHeight = 10;
 677     surface.dwWidth = 10;
 678     ret = IDirectDraw_CreateSurface(lpDD, &surface, &dsurface, NULL);
 679     if(ret != DD_OK)
 680     {
 681         ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret);
 682         return;
 683     }
 684
 685     /* Call IUnknown::QueryInterface */
 686     ret = IDirectDrawSurface_QueryInterface(dsurface, 0, &object);
 687     ok(ret == DDERR_INVALIDPARAMS, "IDirectDrawSurface::QueryInterface returned %x\n", ret);
 688
 689     IDirectDrawSurface_Release(dsurface);
 690 }
 691
 692 /* The following tests test which interface is returned by IDirectDrawSurfaceX::GetDDInterface.
 693  * It uses refcounts to test that and compares the interface addresses. Partially fits here, and
 694  * partially in the refcount test
 695  */
 696
 697 static ULONG getref(IUnknown *iface)
 698 {
 699     IUnknown_AddRef(iface);
 700     return IUnknown_Release(iface);
 701 }
 702
 703 static void GetDDInterface_1(void)
 704 {
 705     LPDIRECTDRAWSURFACE dsurface;
 706     LPDIRECTDRAWSURFACE2 dsurface2;
 707     DDSURFACEDESC surface;
 708     HRESULT ret;
 709     IDirectDraw2 *dd2;
 710     IDirectDraw4 *dd4;
 711     IDirectDraw7 *dd7;
 712     ULONG ref1, ref2, ref4, ref7;
 713     void *dd;
 714
 715     /* Create a surface */
 716     ZeroMemory(&surface, sizeof(surface));
 717     surface.dwSize = sizeof(surface);
 718     surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
 719     surface.dwHeight = 10;
 720     surface.dwWidth = 10;
 721     ret = IDirectDraw_CreateSurface(lpDD, &surface, &dsurface, NULL);
 722     if(ret != DD_OK)
 723     {
 724         ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret);
 725         return;
 726     }
 727     ret = IDirectDrawSurface_QueryInterface(dsurface, &IID_IDirectDrawSurface2, (void **) &dsurface2);
 728     ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret);
 729     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2);
 730     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 731     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4);
 732     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 733     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
 734     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 735
 736     ref1 = getref((IUnknown *) lpDD);
 737     ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1);
 738     ref2 = getref((IUnknown *) dd2);
 739     ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2);
 740     ref4 = getref((IUnknown *) dd4);
 741     ok(ref4 == 1, "IDirectDraw4 refcount is %d\n", ref4);
 742     ref7 = getref((IUnknown *) dd7);
 743     ok(ref7 == 1, "IDirectDraw7 refcount is %d\n", ref7);
 744
 745
 746     ret = IDirectDrawSurface2_GetDDInterface(dsurface2, &dd);
 747     ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret);
 748     ok(getref((IUnknown *) lpDD) == ref1 + 1, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1);
 749     ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2);
 750     ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4);
 751     ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7);
 752
 753     ok(dd == lpDD, "Returned interface pointer is not equal to the creation interface\n");
 754     IUnknown_Release((IUnknown *) dd);
 755
 756     /* try a NULL pointer */
 757     ret = IDirectDrawSurface2_GetDDInterface(dsurface2, NULL);
 758     ok(ret == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret);
 759
 760     IDirectDraw_Release(dd2);
 761     IDirectDraw_Release(dd4);
 762     IDirectDraw_Release(dd7);
 763     IDirectDrawSurface2_Release(dsurface2);
 764     IDirectDrawSurface_Release(dsurface);
 765 }
 766
 767 static void GetDDInterface_2(void)
 768 {
 769     LPDIRECTDRAWSURFACE dsurface;
 770     LPDIRECTDRAWSURFACE2 dsurface2;
 771     DDSURFACEDESC surface;
 772     HRESULT ret;
 773     IDirectDraw2 *dd2;
 774     IDirectDraw4 *dd4;
 775     IDirectDraw7 *dd7;
 776     ULONG ref1, ref2, ref4, ref7;
 777     void *dd;
 778
 779     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2);
 780     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 781     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4);
 782     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 783     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
 784     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 785
 786     /* Create a surface */
 787     ZeroMemory(&surface, sizeof(surface));
 788     surface.dwSize = sizeof(surface);
 789     surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
 790     surface.dwHeight = 10;
 791     surface.dwWidth = 10;
 792     ret = IDirectDraw2_CreateSurface(dd2, &surface, &dsurface, NULL);
 793     if(ret != DD_OK)
 794     {
 795         ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret);
 796         return;
 797     }
 798     ret = IDirectDrawSurface_QueryInterface(dsurface, &IID_IDirectDrawSurface2, (void **) &dsurface2);
 799     ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret);
 800
 801     ref1 = getref((IUnknown *) lpDD);
 802     ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1);
 803     ref2 = getref((IUnknown *) dd2);
 804     ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2);
 805     ref4 = getref((IUnknown *) dd4);
 806     ok(ref4 == 1, "IDirectDraw4 refcount is %d\n", ref4);
 807     ref7 = getref((IUnknown *) dd7);
 808     ok(ref7 == 1, "IDirectDraw7 refcount is %d\n", ref7);
 809
 810
 811     ret = IDirectDrawSurface2_GetDDInterface(dsurface2, &dd);
 812     ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret);
 813     ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1);
 814     ok(getref((IUnknown *) dd2) == ref2 + 1, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2);
 815     ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4);
 816     ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7);
 817
 818     ok(dd == dd2, "Returned interface pointer is not equal to the creation interface\n");
 819     IUnknown_Release((IUnknown *) dd);
 820
 821     IDirectDraw_Release(dd2);
 822     IDirectDraw_Release(dd4);
 823     IDirectDraw_Release(dd7);
 824     IDirectDrawSurface2_Release(dsurface2);
 825     IDirectDrawSurface_Release(dsurface);
 826 }
 827
 828 static void GetDDInterface_4(void)
 829 {
 830     LPDIRECTDRAWSURFACE2 dsurface2;
 831     LPDIRECTDRAWSURFACE4 dsurface4;
 832     DDSURFACEDESC2 surface;
 833     HRESULT ret;
 834     IDirectDraw2 *dd2;
 835     IDirectDraw4 *dd4;
 836     IDirectDraw7 *dd7;
 837     ULONG ref1, ref2, ref4, ref7;
 838     void *dd;
 839
 840     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2);
 841     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 842     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4);
 843     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 844     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
 845     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 846
 847     /* Create a surface */
 848     ZeroMemory(&surface, sizeof(surface));
 849     surface.dwSize = sizeof(surface);
 850     surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
 851     surface.dwHeight = 10;
 852     surface.dwWidth = 10;
 853     ret = IDirectDraw4_CreateSurface(dd4, &surface, &dsurface4, NULL);
 854     if(ret != DD_OK)
 855     {
 856         ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret);
 857         return;
 858     }
 859     ret = IDirectDrawSurface4_QueryInterface(dsurface4, &IID_IDirectDrawSurface2, (void **) &dsurface2);
 860     ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret);
 861
 862     ref1 = getref((IUnknown *) lpDD);
 863     ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1);
 864     ref2 = getref((IUnknown *) dd2);
 865     ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2);
 866     ref4 = getref((IUnknown *) dd4);
 867     ok(ref4 == 2, "IDirectDraw4 refcount is %d\n", ref4);
 868     ref7 = getref((IUnknown *) dd7);
 869     ok(ref7 == 1, "IDirectDraw7 refcount is %d\n", ref7);
 870
 871     ret = IDirectDrawSurface4_GetDDInterface(dsurface4, &dd);
 872     ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret);
 873     ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1);
 874     ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2);
 875     ok(getref((IUnknown *) dd4) == ref4 + 1, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4);
 876     ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7);
 877
 878     ok(dd == dd4, "Returned interface pointer is not equal to the creation interface\n");
 879     IUnknown_Release((IUnknown *) dd);
 880
 881     /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */
 882     ret = IDirectDrawSurface2_GetDDInterface(dsurface2, &dd);
 883     ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret);
 884     ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1);
 885     ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2);
 886     ok(getref((IUnknown *) dd4) == ref4 + 1, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4);
 887     ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7);
 888
 889     ok(dd == dd4, "Returned interface pointer is not equal to the creation interface\n");
 890     IUnknown_Release((IUnknown *) dd);
 891
 892     IDirectDraw_Release(dd2);
 893     IDirectDraw_Release(dd4);
 894     IDirectDraw_Release(dd7);
 895     IDirectDrawSurface4_Release(dsurface4);
 896     IDirectDrawSurface2_Release(dsurface2);
 897 }
 898
 899 static void GetDDInterface_7(void)
 900 {
 901     LPDIRECTDRAWSURFACE4 dsurface4;
 902     LPDIRECTDRAWSURFACE7 dsurface7;
 903     DDSURFACEDESC2 surface;
 904     HRESULT ret;
 905     IDirectDraw2 *dd2;
 906     IDirectDraw4 *dd4;
 907     IDirectDraw7 *dd7;
 908     ULONG ref1, ref2, ref4, ref7;
 909     void *dd;
 910
 911     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2);
 912     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 913     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4);
 914     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 915     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
 916     ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret);
 917
 918     /* Create a surface */
 919     ZeroMemory(&surface, sizeof(surface));
 920     surface.dwSize = sizeof(surface);
 921     surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
 922     surface.dwHeight = 10;
 923     surface.dwWidth = 10;
 924     ret = IDirectDraw7_CreateSurface(dd7, &surface, &dsurface7, NULL);
 925     if(ret != DD_OK)
 926     {
 927         ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret);
 928         return;
 929     }
 930     ret = IDirectDrawSurface7_QueryInterface(dsurface7, &IID_IDirectDrawSurface4, (void **) &dsurface4);
 931     ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret);
 932
 933     ref1 = getref((IUnknown *) lpDD);
 934     ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1);
 935     ref2 = getref((IUnknown *) dd2);
 936     ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2);
 937     ref4 = getref((IUnknown *) dd4);
 938     ok(ref4 == 1, "IDirectDraw4 refcount is %d\n", ref4);
 939     ref7 = getref((IUnknown *) dd7);
 940     ok(ref7 == 2, "IDirectDraw7 refcount is %d\n", ref7);
 941
 942     ret = IDirectDrawSurface7_GetDDInterface(dsurface7, &dd);
 943     ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret);
 944     ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1);
 945     ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2);
 946     ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4);
 947     ok(getref((IUnknown *) dd7) == ref7 + 1, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7);
 948
 949     ok(dd == dd7, "Returned interface pointer is not equal to the creation interface\n");
 950     IUnknown_Release((IUnknown *) dd);
 951
 952     /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */
 953     ret = IDirectDrawSurface4_GetDDInterface(dsurface4, &dd);
 954     ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret);
 955     ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1);
 956     ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2);
 957     ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4);
 958     ok(getref((IUnknown *) dd7) == ref7 + 1, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7);
 959
 960     ok(dd == dd7, "Returned interface pointer is not equal to the creation interface\n");
 961     IUnknown_Release((IUnknown *) dd);
 962
 963     IDirectDraw_Release(dd2);
 964     IDirectDraw_Release(dd4);
 965     IDirectDraw_Release(dd7);
 966     IDirectDrawSurface4_Release(dsurface4);
 967     IDirectDrawSurface7_Release(dsurface7);
 968 }
 969
 970 static ULONG getRefcount(IUnknown *iface)
 971 {
 972     IUnknown_AddRef(iface);
 973     return IUnknown_Release(iface);
 974 }
 975
 976 static void IFaceRefCount(void)
 977 {
 978     LPDIRECTDRAWSURFACE surf;
 979     DDSURFACEDESC surface;
 980     HRESULT ret;
 981     IDirectDrawSurface2 *surf2;
 982     IDirectDrawSurface2 *surf2a;
 983     IDirectDrawSurface4 *surf4;
 984     IDirectDrawSurface7 *surf7a;
 985     IDirectDrawSurface7 *surf7b;
 986     IDirect3DTexture* tex;
 987     IDirect3DTexture2* tex2;
 988     IDirectDrawGammaControl* gamma;
 989     ULONG ref;
 990
 991     /* Create a surface */
 992     ZeroMemory(&surface, sizeof(surface));
 993     surface.dwSize = sizeof(surface);
 994     surface.dwFlags = DDSD_CAPS;
 995     surface.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
 996     ret = IDirectDraw_CreateSurface(lpDD, &surface, &surf, NULL);
 997
 998     if (ret != DD_OK)
 999     {
1000         ok(FALSE, "Could not create surface, skipping test\n");
1001         return;
1002     }
1003
1004     ref = getRefcount((IUnknown *) surf);
1005     ok(ref == 1, "Refcount is %u, expected 1\n", ref); /* Check the ref count is one */
1006
1007     IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface2, (void **) &surf2);
1008     ref = getRefcount((IUnknown *) surf);
1009     todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref); /* Check the ref count is one */
1010     ref = getRefcount((IUnknown *) surf2);
1011     todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref); /* This should also be one */
1012
1013     IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface2, (void **) &surf2a);
1014     ref = getRefcount((IUnknown *) surf2);
1015     todo_wine ok(ref == 2, "Refcount is %u, expected 2\n", ref);   /* Surf2's refcount should be 2 now, but surf should be 1 */
1016     ref = getRefcount((IUnknown *) surf);
1017     todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1018
1019     IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface4, (void **) &surf4);
1020     ref = getRefcount((IUnknown *) surf4);
1021     todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1022
1023     IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface7, (void **) &surf7a);
1024     ref = getRefcount((IUnknown *) surf7a);
1025     todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1026
1027     IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface7, (void **) &surf7b);
1028     ref = getRefcount((IUnknown *) surf7b);
1029     todo_wine ok(ref == 2, "Refcount is %u, expected 2\n", ref);
1030
1031     /* IDirect3DTexture interface (unlike the others) alters the original IDirectDrawSurface ref count */
1032     ret = IDirectDrawSurface_QueryInterface(surf, &IID_IDirect3DTexture, (void **) &tex);
1033     if (SUCCEEDED(ret))
1034     {
1035         ref = getRefcount((IUnknown *) tex);
1036         todo_wine ok(ref == 2, "Refcount is %u, expected 2\n", ref);
1037         ref = getRefcount((IUnknown *) surf);
1038         todo_wine ok(ref == 2, "Refcount is %u, expected 2\n", ref);
1039
1040         IDirectDrawSurface_QueryInterface(surf, &IID_IDirect3DTexture2, (void **) &tex2);
1041         ref = getRefcount((IUnknown *) tex);
1042         todo_wine ok(ref == 3, "Refcount is %u, expected 3\n", ref);
1043         ref = getRefcount((IUnknown *) tex2);
1044         todo_wine ok(ref == 3, "Refcount is %u, expected 3\n", ref);
1045         ref = getRefcount((IUnknown *) surf);
1046         todo_wine ok(ref == 3, "Refcount is %u, expected 3\n", ref);
1047
1048         IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawGammaControl, (void **) &gamma);
1049         ref = getRefcount((IUnknown *) gamma);
1050         todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1051
1052         ref = IDirect3DTexture2_Release(tex2); /* Release the texture */
1053         todo_wine ok(ref == 2, "Refcount is %u, expected 2\n", ref);
1054         ref = getRefcount((IUnknown *) surf);
1055         todo_wine ok(ref == 2, "Refcount is %u, expected 2\n", ref);
1056
1057         ref = IDirect3DTexture_Release(tex); /* Release the texture */
1058         todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1059         ref = getRefcount((IUnknown *) surf);
1060         todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1061
1062         ref = IDirectDrawGammaControl_Release(gamma); /* Release the gamma control */
1063         todo_wine ok(ref == 0, "Refcount is %u, expected 0\n", ref);
1064     }
1065
1066     ref = IDirectDrawSurface2_Release(surf2); /* Release one of the 2 surf2 interfaces */
1067     todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1068
1069     ref = IDirectDrawSurface2_Release(surf2a); /* Release the other */
1070     todo_wine ok(ref == 0, "Refcount is %u, expected 0\n", ref);
1071
1072     ref = IDirectDrawSurface4_Release(surf4);
1073     todo_wine ok(ref == 0, "Refcount is %u, expected 0\n", ref);
1074
1075     ref = IDirectDrawSurface7_Release(surf7a);
1076     todo_wine ok(ref == 1, "Refcount is %u, expected 1\n", ref);
1077
1078     ref = IDirectDrawSurface7_Release(surf7b);
1079     todo_wine ok(ref == 0, "Refcount is %u, expected 0\n", ref);
1080
1081     ref = IDirectDrawSurface_Release(surf);
1082     ok(ref == 0, "Refcount is %u, expected 0\n", ref);
1083 }
1084
1085 #define MAXEXPECTED 8  /* Can match up to 8 expected surfaces */
1086 struct enumstruct
1087 {
1088     IDirectDrawSurface *expected[MAXEXPECTED];
1089     UINT count;
1090 };
1091
1092 static HRESULT WINAPI enumCB(IDirectDrawSurface *surf, DDSURFACEDESC *desc, void *ctx)
1093 {
1094     int i;
1095     BOOL found = FALSE;
1096
1097     for(i = 0; i < MAXEXPECTED; i++)
1098     {
1099         if(((struct enumstruct *)ctx)->expected[i] == surf) found = TRUE;
1100     }
1101
1102     ok(found, "Unexpected surface %p enumerated\n", surf);
1103     ((struct enumstruct *)ctx)->count++;
1104     IDirectDrawSurface_Release(surf);
1105     return DDENUMRET_OK;
1106 }
1107
1108 static void EnumTest(void)
1109 {
1110     HRESULT rc;
1111     DDSURFACEDESC ddsd;
1112     IDirectDrawSurface *surface;
1113     struct enumstruct ctx;
1114
1115     ddsd.dwSize = sizeof(ddsd);
1116     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT;
1117     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
1118     U2(ddsd).dwMipMapCount = 3;
1119     ddsd.dwWidth = 32;
1120     ddsd.dwHeight = 32;
1121     rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL);
1122     ok(rc==DD_OK,"CreateSurface returned: %x\n",rc);
1123
1124     memset(&ctx, 0, sizeof(ctx));
1125     ctx.expected[0] = surface;
1126     rc = IDirectDrawSurface_GetAttachedSurface(ctx.expected[0], &ddsd.ddsCaps, &ctx.expected[1]);
1127     ok(rc == DD_OK, "GetAttachedSurface returned %08x\n", rc);
1128     rc = IDirectDrawSurface_GetAttachedSurface(ctx.expected[1], &ddsd.ddsCaps, &ctx.expected[2]);
1129     ok(rc == DD_OK, "GetAttachedSurface returned %08x\n", rc);
1130     rc = IDirectDrawSurface_GetAttachedSurface(ctx.expected[2], &ddsd.ddsCaps, &ctx.expected[3]);
1131     ok(rc == DDERR_NOTFOUND, "GetAttachedSurface returned %08x\n", rc);
1132     ok(!ctx.expected[3], "expected NULL pointer\n");
1133     ctx.count = 0;
1134
1135     rc = IDirectDraw_EnumSurfaces(lpDD, DDENUMSURFACES_DOESEXIST | DDENUMSURFACES_ALL, &ddsd, &ctx, enumCB);
1136     ok(rc == DD_OK, "IDirectDraw_EnumSurfaces returned %08x\n", rc);
1137     ok(ctx.count == 3, "%d surfaces enumerated, expected 3\n", ctx.count);
1138
1139     IDirectDrawSurface_Release(ctx.expected[2]);
1140     IDirectDrawSurface_Release(ctx.expected[1]);
1141     IDirectDrawSurface_Release(surface);
1142 }
1143
1144 static HRESULT WINAPI SurfaceCounter(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context)
1145 {
1146     UINT *num = context;
1147     (*num)++;
1148     IDirectDrawSurface_Release(surface);
1149     return DDENUMRET_OK;
1150 }
1151
1152 static void AttachmentTest7(void)
1153 {
1154     HRESULT hr;
1155     IDirectDraw7 *dd7;
1156     IDirectDrawSurface7 *surface1, *surface2, *surface3, *surface4;
1157     DDSURFACEDESC2 ddsd, ddsd2;
1158     UINT num;
1159     DDSCAPS2 caps = {DDSCAPS_TEXTURE, 0, 0, 0}, caps2 = {DDSCAPS_BACKBUFFER,0,0,0};
1160     HWND window = CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1161
1162     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
1163     ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
1164
1165     memset(&ddsd, 0, sizeof(ddsd));
1166     ddsd.dwSize = sizeof(ddsd);
1167     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT;
1168     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
1169     U2(ddsd).dwMipMapCount = 3; /* Will create 128x128, 64x64, 32x32 */
1170     ddsd.dwWidth = 128;
1171     ddsd.dwHeight = 128;
1172     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL);
1173     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1174
1175     /* ROOT */
1176     num = 0;
1177     IDirectDrawSurface7_EnumAttachedSurfaces(surface1, &num, SurfaceCounter);
1178     ok(num == 1, "Mipmap root has %d surfaces attached, expected 1\n", num);
1179     /* DONE ROOT */
1180
1181     /* LEVEL 1 */
1182     hr = IDirectDrawSurface7_GetAttachedSurface(surface1, &caps, &surface2);
1183     ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr);
1184     num = 0;
1185     IDirectDrawSurface7_EnumAttachedSurfaces(surface2, &num, SurfaceCounter);
1186     ok(num == 1, "First mip level has %d surfaces attached, expected 1\n", num);
1187     /* DONE LEVEL 1 */
1188
1189     /* LEVEL 2 */
1190     hr = IDirectDrawSurface7_GetAttachedSurface(surface2, &caps, &surface3);
1191     ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr);
1192     IDirectDrawSurface7_Release(surface2);
1193     num = 0;
1194     IDirectDrawSurface7_EnumAttachedSurfaces(surface3, &num, SurfaceCounter);
1195     ok(num == 0, "Second mip level has %d surfaces attached, expected 1\n", num);
1196     /* Done level 2 */
1197     /* Mip level 3 is still needed */
1198     hr = IDirectDrawSurface7_GetAttachedSurface(surface3, &caps, &surface4);
1199     ok(hr == DDERR_NOTFOUND, "GetAttachedSurface returned %08x\n", hr);
1200     ok(!surface4, "expected NULL pointer\n");
1201
1202     /* Try to attach a 16x16 miplevel - Should not work as far I can see */
1203     memset(&ddsd, 0, sizeof(ddsd));
1204     ddsd.dwSize = sizeof(ddsd);
1205     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1206     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1207     ddsd.dwWidth = 16;
1208     ddsd.dwHeight = 16;
1209     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL);
1210     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1211
1212     hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2);
1213     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr);
1214     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface1);
1215     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr);
1216     hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface2);
1217     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr);
1218     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface3);
1219     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr);
1220
1221     IDirectDrawSurface7_Release(surface2);
1222
1223     memset(&ddsd, 0, sizeof(ddsd));
1224     ddsd.dwSize = sizeof(ddsd);
1225     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1226     ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN;
1227     ddsd.dwWidth = 16;
1228     ddsd.dwHeight = 16;
1229     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL);
1230     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1231
1232     hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2);
1233     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr);
1234     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface1);
1235     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr);
1236     hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface2);
1237     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr);
1238     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface3);
1239     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr);
1240
1241     IDirectDrawSurface7_Release(surface3);
1242     IDirectDrawSurface7_Release(surface2);
1243     IDirectDrawSurface7_Release(surface1);
1244
1245     hr = IDirectDraw7_SetCooperativeLevel(dd7, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1246     ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr);
1247
1248     memset(&ddsd, 0, sizeof(ddsd));
1249     ddsd.dwSize = sizeof(ddsd);
1250     ddsd.dwFlags = DDSD_BACKBUFFERCOUNT | DDSD_CAPS;
1251     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
1252     ddsd.dwBackBufferCount = 2;
1253     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL);
1254     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1255
1256     /* backbuffer surfaces must not have dwBackBufferCount set */
1257     ddsd2.dwSize = sizeof(ddsd2);
1258     hr = IDirectDrawSurface7_GetAttachedSurface(surface1, &caps2, &surface2);
1259     ok(hr==DD_OK,"GetAttachedSurface returned: %x\n", hr);
1260     hr = IDirectDrawSurface7_GetSurfaceDesc(surface2, &ddsd2);
1261     ok(hr==DD_OK,"GetSurfaceDesc returned: %x\n", hr);
1262     ok(ddsd2.dwBackBufferCount==0,"backbuffer surface has dwBackBufferCount==%u\n", ddsd2.dwBackBufferCount);
1263
1264     num = 0;
1265     IDirectDrawSurface7_EnumAttachedSurfaces(surface1, &num, SurfaceCounter);
1266     ok(num == 1, "Primary surface has %d surfaces attached, expected 1\n", num);
1267     IDirectDrawSurface7_Release(surface1);
1268
1269     /* Those are some invalid descriptions, no need to test attachments with them */
1270     memset(&ddsd, 0, sizeof(ddsd));
1271     ddsd.dwSize = sizeof(ddsd);
1272     ddsd.dwFlags = DDSD_CAPS;
1273     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER;
1274     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL);
1275     ok(hr==DDERR_INVALIDCAPS,"CreateSurface returned: %x\n",hr);
1276     memset(&ddsd, 0, sizeof(ddsd));
1277     ddsd.dwSize = sizeof(ddsd);
1278     ddsd.dwFlags = DDSD_CAPS;
1279     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER;
1280     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL);
1281     ok(hr==DDERR_INVALIDCAPS,"CreateSurface returned: %x\n",hr);
1282
1283     /* Try a single primary and two offscreen plain surfaces */
1284     memset(&ddsd, 0, sizeof(ddsd));
1285     ddsd.dwSize = sizeof(ddsd);
1286     ddsd.dwFlags = DDSD_CAPS;
1287     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
1288     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL);
1289     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1290
1291     memset(&ddsd, 0, sizeof(ddsd));
1292     ddsd.dwSize = sizeof(ddsd);
1293     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1294     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1295     ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN);
1296     ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN);
1297     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL);
1298     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1299
1300     memset(&ddsd, 0, sizeof(ddsd));
1301     ddsd.dwSize = sizeof(ddsd);
1302     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1303     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1304     ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN);
1305     ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN);
1306     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface3, NULL);
1307     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1308
1309     /* This one has a different size */
1310     memset(&ddsd, 0, sizeof(ddsd));
1311     ddsd.dwSize = sizeof(ddsd);
1312     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1313     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1314     ddsd.dwWidth = 128;
1315     ddsd.dwHeight = 128;
1316     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface4, NULL);
1317     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1318
1319     hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2);
1320     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr);
1321     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface1);
1322     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr);
1323     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface3);
1324     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr);
1325     hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface4);
1326     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr);
1327     hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface1);
1328     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr);
1329
1330     IDirectDrawSurface7_Release(surface4);
1331     IDirectDrawSurface7_Release(surface3);
1332     IDirectDrawSurface7_Release(surface2);
1333     IDirectDrawSurface7_Release(surface1);
1334
1335     hr =IDirectDraw7_SetCooperativeLevel(dd7, NULL, DDSCL_NORMAL);
1336     ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr);
1337     IDirectDraw7_Release(dd7);
1338 }
1339
1340 static void AttachmentTest(void)
1341 {
1342     HRESULT hr;
1343     IDirectDrawSurface *surface1, *surface2, *surface3, *surface4;
1344     DDSURFACEDESC ddsd;
1345     DDSCAPS caps = {DDSCAPS_TEXTURE};
1346     BOOL refrast = FALSE;
1347     HWND window = CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1348
1349     memset(&ddsd, 0, sizeof(ddsd));
1350     ddsd.dwSize = sizeof(ddsd);
1351     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT;
1352     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
1353     U2(ddsd).dwMipMapCount = 3; /* Will create 128x128, 64x64, 32x32 */
1354     ddsd.dwWidth = 128;
1355     ddsd.dwHeight = 128;
1356     hr = IDirectDraw7_CreateSurface(lpDD, &ddsd, &surface1, NULL);
1357     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1358
1359     hr = IDirectDrawSurface7_GetAttachedSurface(surface1, &caps, &surface2);
1360     ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr);
1361     hr = IDirectDrawSurface7_GetAttachedSurface(surface2, &caps, &surface3);
1362     ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr);
1363
1364     /* Try to attach a 16x16 miplevel - Should not work as far I can see */
1365     memset(&ddsd, 0, sizeof(ddsd));
1366     ddsd.dwSize = sizeof(ddsd);
1367     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1368     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1369     ddsd.dwWidth = 16;
1370     ddsd.dwHeight = 16;
1371     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface4, NULL);
1372     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1373
1374     hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface4);
1375     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr);
1376     hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface1);
1377     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr);
1378     hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface4);
1379     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr);
1380     hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface3);
1381     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr);
1382     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface4);
1383     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 64x64 texture sublevel returned %08x\n", hr);
1384     hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface2);
1385     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 64x64 texture sublevel to a 16x16 texture returned %08x\n", hr);
1386
1387     IDirectDrawSurface7_Release(surface4);
1388
1389     memset(&ddsd, 0, sizeof(ddsd));
1390     ddsd.dwSize = sizeof(ddsd);
1391     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1392     ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN;
1393     ddsd.dwWidth = 16;
1394     ddsd.dwHeight = 16;
1395     hr = IDirectDraw7_CreateSurface(lpDD, &ddsd, &surface4, NULL);
1396     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1397
1398     if (SUCCEEDED(IDirectDrawSurface7_AddAttachedSurface(surface1, surface4)))
1399     {
1400         IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface4);
1401         refrast = TRUE;
1402     }
1403
1404     hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface4); /* Succeeds on refrast */
1405     if (refrast)
1406         ok(hr == S_OK, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr);
1407     else
1408         ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr);
1409     if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface4);
1410
1411     hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface1);  /* Succeeds on refrast */
1412     if (refrast)
1413         ok(hr == S_OK, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr);
1414     else
1415         ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr);
1416     if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface1);
1417
1418     hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface4);  /* Succeeds on refrast */
1419     if (refrast)
1420         ok(hr == S_OK, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr);
1421     else
1422         ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr);
1423     if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface3, 0, surface4);
1424
1425     hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface3);
1426     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr);
1427     if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface4, 0, surface3);
1428
1429     hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface4);  /* Succeeds on refrast */
1430     if (refrast)
1431         ok(hr == S_OK, "Attaching a 16x16 offscreen plain surface to a 64x64 texture sublevel returned %08x\n", hr);
1432     else
1433         ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 64x64 texture sublevel returned %08x\n", hr);
1434     if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface2, 0, surface4);
1435
1436     hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface2);
1437     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 64x64 texture sublevel to a 16x16 offscreen plain surface returned %08x\n", hr);
1438     if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface4, 0, surface2);
1439
1440     IDirectDrawSurface7_Release(surface4);
1441     IDirectDrawSurface7_Release(surface3);
1442     IDirectDrawSurface7_Release(surface2);
1443     IDirectDrawSurface7_Release(surface1);
1444
1445     hr = IDirectDraw_SetCooperativeLevel(lpDD, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1446     ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr);
1447
1448     /* Creating a back buffer as-is, is not allowed. No need to perform attachment tests */
1449     memset(&ddsd, 0, sizeof(ddsd));
1450     ddsd.dwSize = sizeof(ddsd);
1451     ddsd.dwFlags = DDSD_CAPS;
1452     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER;
1453     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface2, NULL);
1454     ok(hr==DDERR_INVALIDCAPS,"CreateSurface returned: %x\n",hr);
1455     /* This old ddraw version happily creates explicit front buffers */
1456     memset(&ddsd, 0, sizeof(ddsd));
1457     ddsd.dwSize = sizeof(ddsd);
1458     ddsd.dwFlags = DDSD_CAPS;
1459     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER;
1460     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface1, NULL);
1461     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1462     IDirectDrawSurface_Release(surface1);
1463
1464     /* Try a single primary and two offscreen plain surfaces */
1465     memset(&ddsd, 0, sizeof(ddsd));
1466     ddsd.dwSize = sizeof(ddsd);
1467     ddsd.dwFlags = DDSD_CAPS;
1468     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
1469     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface1, NULL);
1470     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1471
1472     memset(&ddsd, 0, sizeof(ddsd));
1473     ddsd.dwSize = sizeof(ddsd);
1474     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1475     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1476     ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN);
1477     ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN);
1478     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface2, NULL);
1479     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1480
1481     memset(&ddsd, 0, sizeof(ddsd));
1482     ddsd.dwSize = sizeof(ddsd);
1483     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1484     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1485     ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN);
1486     ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN);
1487     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface3, NULL);
1488     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1489
1490     /* This one has a different size */
1491     memset(&ddsd, 0, sizeof(ddsd));
1492     ddsd.dwSize = sizeof(ddsd);
1493     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1494     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1495     ddsd.dwWidth = 128;
1496     ddsd.dwHeight = 128;
1497     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface4, NULL);
1498     ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
1499
1500     hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface2);
1501     ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE),
1502        "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr);
1503     if(SUCCEEDED(hr))
1504     {
1505         /* Try the reverse without detaching first */
1506         hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface1);
1507         ok(hr == DDERR_SURFACEALREADYATTACHED, "Attaching an attached surface to its attachee returned %08x\n", hr);
1508         hr = IDirectDrawSurface_DeleteAttachedSurface(surface1, 0, surface2);
1509         ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr);
1510     }
1511     hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface1);
1512     ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE),
1513        "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr);
1514     if(SUCCEEDED(hr))
1515     {
1516         /* Try to detach reversed */
1517         hr = IDirectDrawSurface_DeleteAttachedSurface(surface1, 0, surface2);
1518         ok(hr == DDERR_CANNOTDETACHSURFACE, "DeleteAttachedSurface returned %08x\n", hr);
1519         /* Now the proper detach */
1520         hr = IDirectDrawSurface_DeleteAttachedSurface(surface2, 0, surface1);
1521         ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr);
1522     }
1523     hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface3); /* Fails on refrast */
1524     ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE),
1525        "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr);
1526     if(SUCCEEDED(hr))
1527     {
1528         hr = IDirectDrawSurface_DeleteAttachedSurface(surface2, 0, surface3);
1529         ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr);
1530     }
1531     hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface4);
1532     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr);
1533     hr = IDirectDrawSurface_AddAttachedSurface(surface4, surface1);
1534     ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr);
1535
1536     IDirectDrawSurface_Release(surface4);
1537     IDirectDrawSurface_Release(surface3);
1538     IDirectDrawSurface_Release(surface2);
1539     IDirectDrawSurface_Release(surface1);
1540
1541     hr =IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL);
1542     ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr);
1543
1544     DestroyWindow(window);
1545 }
1546
1547 struct compare
1548 {
1549     DWORD width, height;
1550     DWORD caps, caps2;
1551     UINT mips;
1552 };
1553
1554 static HRESULT WINAPI CubeTestLvl2Enum(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context)
1555 {
1556     UINT *mips = context;
1557
1558     (*mips)++;
1559     IDirectDrawSurface7_EnumAttachedSurfaces(surface,
1560                                              context,
1561                                              CubeTestLvl2Enum);
1562
1563     return DDENUMRET_OK;
1564 }
1565
1566 static HRESULT WINAPI CubeTestLvl1Enum(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context)
1567 {
1568     UINT mips = 0;
1569     UINT *num = context;
1570     static const struct compare expected[] =
1571     {
1572         {
1573             128, 128,
1574             DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX,
1575             DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ,
1576             7
1577         },
1578         {
1579             128, 128,
1580             DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX,
1581             DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ,
1582             7
1583         },
1584         {
1585             128, 128,
1586             DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX,
1587             DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY,
1588             7
1589         },
1590         {
1591             128, 128,
1592             DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX,
1593             DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY,
1594             7
1595         },
1596         {
1597             128, 128,
1598             DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX,
1599             DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX,
1600             7
1601         },
1602         {
1603             64, 64, /* This is the first mipmap */
1604             DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX,
1605             DDSCAPS2_MIPMAPSUBLEVEL | DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX,
1606             6
1607         },
1608     };
1609
1610     mips = 0;
1611     IDirectDrawSurface7_EnumAttachedSurfaces(surface,
1612                                              &mips,
1613                                              CubeTestLvl2Enum);
1614
1615     ok(desc->dwWidth == expected[*num].width, "Surface width is %d expected %d\n", desc->dwWidth, expected[*num].width);
1616     ok(desc->dwHeight == expected[*num].height, "Surface height is %d expected %d\n", desc->dwHeight, expected[*num].height);
1617     ok(desc->ddsCaps.dwCaps == expected[*num].caps, "Surface caps are %08x expected %08x\n", desc->ddsCaps.dwCaps, expected[*num].caps);
1618     ok(desc->ddsCaps.dwCaps2 == expected[*num].caps2, "Surface caps2 are %08x expected %08x\n", desc->ddsCaps.dwCaps2, expected[*num].caps2);
1619     ok(mips == expected[*num].mips, "Surface has %d mipmaps, expected %d\n", mips, expected[*num].mips);
1620
1621     (*num)++;
1622
1623     IDirectDrawSurface7_Release(surface);
1624
1625     return DDENUMRET_OK;
1626 }
1627
1628 static void CubeMapTest(void)
1629 {
1630     IDirectDraw7 *dd7 = NULL;
1631     IDirectDrawSurface7 *cubemap = NULL;
1632     DDSURFACEDESC2 ddsd;
1633     HRESULT hr;
1634     UINT num = 0;
1635     struct enumstruct ctx;
1636
1637     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
1638     ok(hr == DD_OK, "IDirectDraw::QueryInterface returned %08x\n", hr);
1639     if (FAILED(hr)) goto err;
1640
1641     memset(&ddsd, 0, sizeof(ddsd));
1642     ddsd.dwSize = sizeof(ddsd);
1643     U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
1644     ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS;
1645     ddsd.dwWidth = 128;
1646     ddsd.dwHeight = 128;
1647     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY;
1648     ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_ALLFACES;
1649
1650     /* D3DFMT_R5G6B5 */
1651     U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB;
1652     U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16;
1653     U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800;
1654     U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0;
1655     U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F;
1656
1657     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL);
1658     if (FAILED(hr))
1659     {
1660         skip("Can't create cubemap surface\n");
1661         goto err;
1662     }
1663
1664     hr = IDirectDrawSurface7_GetSurfaceDesc(cubemap, &ddsd);
1665     ok(hr == DD_OK, "IDirectDrawSurface7_GetSurfaceDesc returned %08x\n", hr);
1666     ok(ddsd.ddsCaps.dwCaps == (DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX),
1667        "Root Caps are %08x\n", ddsd.ddsCaps.dwCaps);
1668     ok(ddsd.ddsCaps.dwCaps2 == (DDSCAPS2_CUBEMAP_POSITIVEX | DDSCAPS2_CUBEMAP),
1669        "Root Caps2 are %08x\n", ddsd.ddsCaps.dwCaps2);
1670
1671     IDirectDrawSurface7_EnumAttachedSurfaces(cubemap,
1672                                              &num,
1673                                              CubeTestLvl1Enum);
1674     ok(num == 6, "Surface has %d attachments\n", num);
1675     IDirectDrawSurface7_Release(cubemap);
1676
1677     /* What happens if I do not specify any faces? */
1678     memset(&ddsd, 0, sizeof(ddsd));
1679     ddsd.dwSize = sizeof(ddsd);
1680     U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
1681     ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS;
1682     ddsd.dwWidth = 128;
1683     ddsd.dwHeight = 128;
1684     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY;
1685     ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP;
1686
1687     /* D3DFMT_R5G6B5 */
1688     U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB;
1689     U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16;
1690     U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800;
1691     U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0;
1692     U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F;
1693
1694     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL);
1695     ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw7::CreateSurface asking for a cube map without faces returned %08x\n", hr);
1696
1697     /* Cube map faces without a cube map? */
1698     memset(&ddsd, 0, sizeof(ddsd));
1699     ddsd.dwSize = sizeof(ddsd);
1700     U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
1701     ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS;
1702     ddsd.dwWidth = 128;
1703     ddsd.dwHeight = 128;
1704     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY;
1705     ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP_ALLFACES;
1706
1707     /* D3DFMT_R5G6B5 */
1708     U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB;
1709     U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16;
1710     U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800;
1711     U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0;
1712     U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F;
1713
1714     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL);
1715     ok(hr == DDERR_INVALIDCAPS, "IDirectDraw7::CreateSurface returned %08x\n", hr);
1716
1717     memset(&ddsd, 0, sizeof(ddsd));
1718     ddsd.dwSize = sizeof(ddsd);
1719     U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
1720     ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS;
1721     ddsd.dwWidth = 128;
1722     ddsd.dwHeight = 128;
1723     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY;
1724     ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP_POSITIVEX;
1725
1726     /* D3DFMT_R5G6B5 */
1727     U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB;
1728     U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16;
1729     U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800;
1730     U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0;
1731     U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F;
1732
1733     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL);
1734     ok(hr == DDERR_INVALIDCAPS, "IDirectDraw7::CreateSurface returned %08x\n", hr);
1735
1736     /* Make sure everything is cleaned up properly. Use the enumSurfaces test infrastructure */
1737     memset(&ctx, 0, sizeof(ctx));
1738     memset(&ddsd, 0, sizeof(ddsd));
1739     ddsd.dwSize = sizeof(DDSURFACEDESC);
1740     hr = IDirectDraw_EnumSurfaces(lpDD, DDENUMSURFACES_DOESEXIST | DDENUMSURFACES_ALL, (DDSURFACEDESC *) &ddsd, (void *) &ctx, enumCB);
1741     ok(hr == DD_OK, "IDirectDraw_EnumSurfaces returned %08x\n", hr);
1742     ok(ctx.count == 0, "%d surfaces enumerated, expected 0\n", ctx.count);
1743
1744     err:
1745     if (dd7) IDirectDraw7_Release(dd7);
1746 }
1747
1748 static void test_lockrect_invalid(void)
1749 {
1750     unsigned int i, j;
1751
1752     RECT valid[] = {
1753         {60, 60, 68, 68},
1754         {60, 60, 60, 68},
1755         {60, 60, 68, 60},
1756         {120, 60, 128, 68},
1757         {60, 120, 68, 128},
1758     };
1759
1760     RECT invalid[] = {
1761         {68, 60, 60, 68},       /* left > right */
1762         {60, 68, 68, 60},       /* top > bottom */
1763         {-8, 60,  0, 68},       /* left < surface */
1764         {60, -8, 68,  0},       /* top < surface */
1765         {-16, 60, -8, 68},      /* right < surface */
1766         {60, -16, 68, -8},      /* bottom < surface */
1767         {60, 60, 136, 68},      /* right > surface */
1768         {60, 60, 68, 136},      /* bottom > surface */
1769         {136, 60, 144, 68},     /* left > surface */
1770         {60, 136, 68, 144},     /* top > surface */
1771     };
1772
1773     const DWORD dds_caps[] = {
1774         DDSCAPS_OFFSCREENPLAIN
1775     };
1776
1777     for (j = 0; j < (sizeof(dds_caps) / sizeof(*dds_caps)); ++j)
1778     {
1779         IDirectDrawSurface *surface = 0;
1780         DDSURFACEDESC surface_desc = {0};
1781         DDSURFACEDESC locked_desc = {0};
1782         HRESULT hr;
1783
1784         surface_desc.dwSize = sizeof(surface_desc);
1785         surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat);
1786         surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
1787         surface_desc.ddsCaps.dwCaps = dds_caps[j];
1788         surface_desc.dwWidth = 128;
1789         surface_desc.dwHeight = 128;
1790         surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
1791         U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32;
1792         U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0xFF0000;
1793         U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x00FF00;
1794         U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x0000FF;
1795
1796         hr = IDirectDraw_CreateSurface(lpDD, &surface_desc, &surface, NULL);
1797         ok(SUCCEEDED(hr), "CreateSurface failed (0x%08x)\n", hr);
1798         if (FAILED(hr)) {
1799             skip("failed to create surface\n");
1800             continue;
1801         }
1802
1803         for (i = 0; i < (sizeof(valid) / sizeof(*valid)); ++i)
1804         {
1805             RECT *rect = &valid[i];
1806
1807             memset(&locked_desc, 0, sizeof(locked_desc));
1808             locked_desc.dwSize = sizeof(locked_desc);
1809
1810             hr = IDirectDrawSurface_Lock(surface, rect, &locked_desc, DDLOCK_WAIT, NULL);
1811             ok(SUCCEEDED(hr), "Lock failed (0x%08x) for rect [%d, %d]->[%d, %d]\n",
1812                     hr, rect->left, rect->top, rect->right, rect->bottom);
1813
1814             hr = IDirectDrawSurface_Unlock(surface, NULL);
1815             ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr);
1816         }
1817
1818         for (i = 0; i < (sizeof(invalid) / sizeof(*invalid)); ++i)
1819         {
1820             RECT *rect = &invalid[i];
1821
1822             memset(&locked_desc, 1, sizeof(locked_desc));
1823             locked_desc.dwSize = sizeof(locked_desc);
1824
1825             hr = IDirectDrawSurface_Lock(surface, rect, &locked_desc, DDLOCK_WAIT, NULL);
1826             ok(hr == DDERR_INVALIDPARAMS, "Lock returned 0x%08x for rect [%d, %d]->[%d, %d]"
1827                     ", expected DDERR_INVALIDPARAMS (0x%08x)\n", hr, rect->left, rect->top,
1828                     rect->right, rect->bottom, DDERR_INVALIDPARAMS);
1829             ok(!locked_desc.lpSurface, "IDirectDrawSurface_Lock did not set lpSurface in the surface desc to zero.\n");
1830         }
1831
1832         hr = IDirectDrawSurface_Lock(surface, NULL, &locked_desc, DDLOCK_WAIT, NULL);
1833         ok(hr == DD_OK, "IDirectDrawSurface_Lock(rect = NULL) failed (0x%08x)\n", hr);
1834         hr = IDirectDrawSurface_Lock(surface, NULL, &locked_desc, DDLOCK_WAIT, NULL);
1835         ok(hr == DDERR_SURFACEBUSY, "Double lock(rect = NULL) returned 0x%08x\n", hr);
1836         if(SUCCEEDED(hr)) {
1837             hr = IDirectDrawSurface_Unlock(surface, NULL);
1838             ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr);
1839         }
1840         hr = IDirectDrawSurface_Unlock(surface, NULL);
1841         ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr);
1842
1843         memset(&locked_desc, 0, sizeof(locked_desc));
1844         locked_desc.dwSize = sizeof(locked_desc);
1845         hr = IDirectDrawSurface_Lock(surface, &valid[0], &locked_desc, DDLOCK_WAIT, NULL);
1846         ok(hr == DD_OK, "IDirectDrawSurface_Lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n",
1847            valid[0].left, valid[0].top, valid[0].right, valid[0].bottom, hr);
1848         hr = IDirectDrawSurface_Lock(surface, &valid[0], &locked_desc, DDLOCK_WAIT, NULL);
1849         ok(hr == DDERR_SURFACEBUSY, "Double lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n",
1850            valid[0].left, valid[0].top, valid[0].right, valid[0].bottom, hr);
1851
1852         /* Locking a different rectangle returns DD_OK, but it seems to break the surface.
1853          * Afterwards unlocking the surface fails(NULL rectangle, and both locked rectangles
1854          */
1855
1856         hr = IDirectDrawSurface_Unlock(surface, NULL);
1857         ok(hr == DD_OK, "Unlock returned (0x%08x)\n", hr);
1858
1859         IDirectDrawSurface_Release(surface);
1860     }
1861 }
1862
1863 static void CompressedTest(void)
1864 {
1865     HRESULT hr;
1866     IDirectDrawSurface7 *surface;
1867     DDSURFACEDESC2 ddsd, ddsd2;
1868     IDirectDraw7 *dd7 = NULL;
1869     RECT r = { 0, 0, 128, 128 };
1870     RECT r2 = { 32, 32, 64, 64 };
1871
1872     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
1873     ok(hr == DD_OK, "IDirectDraw::QueryInterface returned %08x\n", hr);
1874
1875     memset(&ddsd, 0, sizeof(ddsd));
1876     ddsd.dwSize = sizeof(ddsd);
1877     U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
1878     ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS;
1879     ddsd.dwWidth = 128;
1880     ddsd.dwHeight = 128;
1881     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY;
1882     U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_FOURCC;
1883     U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','1');
1884
1885     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
1886     ok(hr == DD_OK, "CreateSurface returned %08x\n", hr);
1887     if (FAILED(hr)) {
1888         skip("failed to create surface\n");
1889         return;
1890     }
1891
1892     memset(&ddsd2, 0, sizeof(ddsd2));
1893     ddsd2.dwSize = sizeof(ddsd2);
1894     U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
1895     hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
1896     ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
1897
1898     ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
1899        "Surface desc flags: %08x\n", ddsd2.dwFlags);
1900     ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
1901     ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
1902     ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
1903        "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
1904     ok(U1(ddsd2).dwLinearSize == 8192, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
1905     ok(ddsd2.ddsCaps.dwCaps2 == 0, "Caps2: %08x\n", ddsd2.ddsCaps.dwCaps2);
1906     IDirectDrawSurface7_Release(surface);
1907
1908     U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','3');
1909     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
1910     ok(hr == DD_OK, "CreateSurface returned %08x\n", hr);
1911     if (FAILED(hr)) {
1912         skip("failed to create surface\n");
1913         return;
1914     }
1915
1916     memset(&ddsd2, 0, sizeof(ddsd2));
1917     ddsd2.dwSize = sizeof(ddsd2);
1918     U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
1919     hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
1920     ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
1921
1922     ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
1923        "Surface desc flags: %08x\n", ddsd2.dwFlags);
1924     ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
1925     ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
1926     ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
1927        "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
1928     ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
1929     IDirectDrawSurface7_Release(surface);
1930
1931     U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','5');
1932     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
1933     ok(hr == DD_OK, "CreateSurface returned %08x\n", hr);
1934     if (FAILED(hr)) {
1935         skip("failed to create surface\n");
1936         return;
1937     }
1938
1939     memset(&ddsd2, 0, sizeof(ddsd2));
1940     ddsd2.dwSize = sizeof(ddsd2);
1941     U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
1942     hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
1943     ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
1944
1945     ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
1946        "Surface desc flags: %08x\n", ddsd2.dwFlags);
1947     ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
1948     ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
1949     ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
1950        "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
1951     ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
1952     ok(ddsd2.lpSurface == 0, "Surface memory is at %p, expected NULL\n", ddsd2.lpSurface);
1953
1954     memset(&ddsd2, 0, sizeof(ddsd2));
1955     ddsd2.dwSize = sizeof(ddsd2);
1956     U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
1957
1958     /* Show that the description is not changed when locking the surface. What is really interesting
1959      * about this is that DDSD_LPSURFACE isn't set.
1960      */
1961     hr = IDirectDrawSurface7_Lock(surface, NULL, &ddsd2, DDLOCK_READONLY, 0);
1962     ok(hr == DD_OK, "Lock returned %08x\n", hr);
1963
1964     ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
1965        "Surface desc flags: %08x\n", ddsd2.dwFlags);
1966     ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
1967     ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
1968     ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
1969        "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
1970     ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
1971     ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
1972
1973     hr = IDirectDrawSurface7_Unlock(surface, NULL);
1974     ok(hr == DD_OK, "Unlock returned %08x\n", hr);
1975
1976     /* Now what about a locking rect?  */
1977     hr = IDirectDrawSurface7_Lock(surface, &r, &ddsd2, DDLOCK_READONLY, 0);
1978     ok(hr == DD_OK, "Lock returned %08x\n", hr);
1979
1980     ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
1981        "Surface desc flags: %08x\n", ddsd2.dwFlags);
1982     ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
1983     ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
1984     ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
1985        "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
1986     ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
1987     ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
1988
1989     hr = IDirectDrawSurface7_Unlock(surface, &r);
1990     ok(hr == DD_OK, "Unlock returned %08x\n", hr);
1991
1992     /* Now what about a different locking offset? */
1993     hr = IDirectDrawSurface7_Lock(surface, &r2, &ddsd2, DDLOCK_READONLY, 0);
1994     ok(hr == DD_OK, "Lock returned %08x\n", hr);
1995
1996     ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
1997        "Surface desc flags: %08x\n", ddsd2.dwFlags);
1998     ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
1999     ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2000     ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
2001        "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2002     ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
2003     ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
2004
2005     hr = IDirectDrawSurface7_Unlock(surface, &r2);
2006     ok(hr == DD_OK, "Unlock returned %08x\n", hr);
2007     IDirectDrawSurface7_Release(surface);
2008
2009     /* Try this with video memory. A kind of surprise. It still has the LINEARSIZE flag set,
2010      * but seems to have a pitch instead.
2011      */
2012     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY;
2013     U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','1');
2014
2015     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
2016     ok(hr == DD_OK || hr == DDERR_NOTEXTUREHW || hr == DDERR_INVALIDPARAMS ||
2017        broken(hr == DDERR_NODIRECTDRAWHW), "CreateSurface returned %08x\n", hr);
2018
2019     /* Not supported everywhere */
2020     if(SUCCEEDED(hr))
2021     {
2022         memset(&ddsd2, 0, sizeof(ddsd2));
2023         ddsd2.dwSize = sizeof(ddsd2);
2024         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2025         hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
2026         ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
2027
2028         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2029         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2030         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2031         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2032         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM),
2033         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2034         /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
2035         ok(ddsd2.ddsCaps.dwCaps2 == 0, "Caps2: %08x\n", ddsd2.ddsCaps.dwCaps2);
2036         IDirectDrawSurface7_Release(surface);
2037
2038         U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','3');
2039         hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
2040         ok(hr == DD_OK, "CreateSurface returned %08x\n", hr);
2041
2042         memset(&ddsd2, 0, sizeof(ddsd2));
2043         ddsd2.dwSize = sizeof(ddsd2);
2044         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2045         hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
2046         ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
2047
2048         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2049         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2050         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2051         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2052         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM),
2053         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2054         /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
2055         IDirectDrawSurface7_Release(surface);
2056
2057         U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','5');
2058         hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
2059         ok(hr == DD_OK, "CreateSurface returned %08x\n", hr);
2060
2061         memset(&ddsd2, 0, sizeof(ddsd2));
2062         ddsd2.dwSize = sizeof(ddsd2);
2063         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2064         hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
2065         ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
2066
2067         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2068         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2069         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2070         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2071         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM),
2072         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2073         /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
2074         ok(ddsd2.lpSurface == 0, "Surface memory is at %p, expected NULL\n", ddsd2.lpSurface);
2075
2076         memset(&ddsd2, 0, sizeof(ddsd2));
2077         ddsd2.dwSize = sizeof(ddsd2);
2078         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2079
2080         /* Show that the description is not changed when locking the surface. What is really interesting
2081         * about this is that DDSD_LPSURFACE isn't set.
2082         */
2083         hr = IDirectDrawSurface7_Lock(surface, NULL, &ddsd2, DDLOCK_READONLY, 0);
2084         ok(hr == DD_OK, "Lock returned %08x\n", hr);
2085
2086         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2087         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2088         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2089         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2090         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM),
2091         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2092         /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
2093         ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
2094
2095         hr = IDirectDrawSurface7_Unlock(surface, NULL);
2096         ok(hr == DD_OK, "Unlock returned %08x\n", hr);
2097
2098         /* Now what about a locking rect?  */
2099         hr = IDirectDrawSurface7_Lock(surface, &r, &ddsd2, DDLOCK_READONLY, 0);
2100         ok(hr == DD_OK, "Lock returned %08x\n", hr);
2101
2102         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2103         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2104         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2105         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2106         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM),
2107         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2108         /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
2109         ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
2110
2111         hr = IDirectDrawSurface7_Unlock(surface, &r);
2112         ok(hr == DD_OK, "Unlock returned %08x\n", hr);
2113
2114         /* Now what about a different locking offset? */
2115         hr = IDirectDrawSurface7_Lock(surface, &r2, &ddsd2, DDLOCK_READONLY, 0);
2116         ok(hr == DD_OK, "Lock returned %08x\n", hr);
2117
2118         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2119         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2120         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2121         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2122         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM),
2123         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2124         /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
2125         ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
2126
2127         hr = IDirectDrawSurface7_Unlock(surface, &r2);
2128         ok(hr == DD_OK, "Unlock returned %08x\n", hr);
2129
2130         IDirectDrawSurface7_Release(surface);
2131     }
2132     else
2133     {
2134         skip("Hardware DXTN textures not supported\n");
2135     }
2136
2137     /* What happens to managed textures? Interestingly, Windows reports them as being in system
2138      * memory. The linear size fits again.
2139      */
2140     ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
2141     ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
2142     U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','1');
2143
2144     hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
2145     ok(hr == DD_OK || hr == DDERR_NOTEXTUREHW, "CreateSurface returned %08x\n", hr);
2146
2147     /* Not supported everywhere */
2148     if(SUCCEEDED(hr))
2149     {
2150         memset(&ddsd2, 0, sizeof(ddsd2));
2151         ddsd2.dwSize = sizeof(ddsd2);
2152         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2153         hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
2154         ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
2155
2156         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2157         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2158         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2159         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2160         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
2161         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2162         ok(U1(ddsd2).dwLinearSize == 8192, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
2163         ok(ddsd2.ddsCaps.dwCaps2 == DDSCAPS2_TEXTUREMANAGE, "Caps2: %08x\n", ddsd2.ddsCaps.dwCaps2);
2164         IDirectDrawSurface7_Release(surface);
2165
2166         U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','3');
2167         hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
2168         ok(hr == DD_OK, "CreateSurface returned %08x\n", hr);
2169
2170         memset(&ddsd2, 0, sizeof(ddsd2));
2171         ddsd2.dwSize = sizeof(ddsd2);
2172         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2173         hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
2174         ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
2175
2176         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2177         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2178         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2179         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2180         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
2181         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2182         ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
2183         IDirectDrawSurface7_Release(surface);
2184
2185         U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','5');
2186         hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
2187         ok(hr == DD_OK, "CreateSurface returned %08x\n", hr);
2188
2189         memset(&ddsd2, 0, sizeof(ddsd2));
2190         ddsd2.dwSize = sizeof(ddsd2);
2191         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2192         hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2);
2193         ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr);
2194
2195         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2196         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2197         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2198         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2199         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
2200         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2201         ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
2202         ok(ddsd2.lpSurface == 0, "Surface memory is at %p, expected NULL\n", ddsd2.lpSurface);
2203
2204         memset(&ddsd2, 0, sizeof(ddsd2));
2205         ddsd2.dwSize = sizeof(ddsd2);
2206         U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat);
2207
2208         /* Show that the description is not changed when locking the surface. What is really interesting
2209         * about this is that DDSD_LPSURFACE isn't set.
2210         */
2211         hr = IDirectDrawSurface7_Lock(surface, NULL, &ddsd2, DDLOCK_READONLY, 0);
2212         ok(hr == DD_OK, "Lock returned %08x\n", hr);
2213
2214         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2215         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2216         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2217         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2218         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
2219         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2220         ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize);
2221         ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
2222
2223         hr = IDirectDrawSurface7_Unlock(surface, NULL);
2224         ok(hr == DD_OK, "Unlock returned %08x\n", hr);
2225
2226         /* Now what about a locking rect?  */
2227         hr = IDirectDrawSurface7_Lock(surface, &r, &ddsd2, DDLOCK_READONLY, 0);
2228         ok(hr == DD_OK, "Lock returned %08x\n", hr);
2229
2230         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2231         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2232         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2233         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2234         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
2235         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2236         ok(U1(ddsd2).dwLinearSize == 16384, "\"Linear\" size is %d\n", U1(ddsd2).dwLinearSize);
2237         ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
2238
2239         hr = IDirectDrawSurface7_Unlock(surface, &r);
2240         ok(hr == DD_OK, "Unlock returned %08x\n", hr);
2241
2242         /* Now what about a different locking offset? */
2243         hr = IDirectDrawSurface7_Lock(surface, &r2, &ddsd2, DDLOCK_READONLY, 0);
2244         ok(hr == DD_OK, "Lock returned %08x\n", hr);
2245
2246         ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE),
2247         "Surface desc flags: %08x\n", ddsd2.dwFlags);
2248         ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags);
2249         ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount);
2250         ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY),
2251         "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps);
2252         ok(U1(ddsd2).dwLinearSize == 16384, "\"Linear\" size is %d\n", U1(ddsd2).dwLinearSize);
2253         ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n");
2254
2255         hr = IDirectDrawSurface7_Unlock(surface, &r2);
2256         ok(hr == DD_OK, "Unlock returned %08x\n", hr);
2257
2258         IDirectDrawSurface7_Release(surface);
2259     }
2260     else
2261     {
2262         skip("Hardware DXTN textures not supported\n");
2263     }
2264
2265     IDirectDraw7_Release(dd7);
2266 }
2267
2268 static void SizeTest(void)
2269 {
2270     LPDIRECTDRAWSURFACE dsurface = NULL;
2271     DDSURFACEDESC desc;
2272     HRESULT ret;
2273     HWND window = CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
2274
2275     /* Create an offscreen surface surface without a size */
2276     ZeroMemory(&desc, sizeof(desc));
2277     desc.dwSize = sizeof(desc);
2278     desc.dwFlags = DDSD_CAPS;
2279     desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN;
2280     ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL);
2281     ok(ret == DDERR_INVALIDPARAMS, "Creating an offscreen plain surface without a size info returned %08x (dsurface=%p)\n", ret, dsurface);
2282     if(dsurface)
2283     {
2284         trace("Surface at %p\n", dsurface);
2285         IDirectDrawSurface_Release(dsurface);
2286         dsurface = NULL;
2287     }
2288
2289     /* Create an offscreen surface surface with only a width parameter */
2290     ZeroMemory(&desc, sizeof(desc));
2291     desc.dwSize = sizeof(desc);
2292     desc.dwFlags = DDSD_CAPS | DDSD_WIDTH;
2293     desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN;
2294     desc.dwWidth = 128;
2295     ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL);
2296     ok(ret == DDERR_INVALIDPARAMS, "Creating an offscreen plain surface without hight info returned %08x\n", ret);
2297     if(dsurface)
2298     {
2299         IDirectDrawSurface_Release(dsurface);
2300         dsurface = NULL;
2301     }
2302
2303     /* Create an offscreen surface surface with only a height parameter */
2304     ZeroMemory(&desc, sizeof(desc));
2305     desc.dwSize = sizeof(desc);
2306     desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT;
2307     desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN;
2308     desc.dwHeight = 128;
2309     ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL);
2310     ok(ret == DDERR_INVALIDPARAMS, "Creating an offscreen plain surface without width info returned %08x\n", ret);
2311     if(dsurface)
2312     {
2313         IDirectDrawSurface_Release(dsurface);
2314         dsurface = NULL;
2315     }
2316
2317     /* Sanity check */
2318     ZeroMemory(&desc, sizeof(desc));
2319     desc.dwSize = sizeof(desc);
2320     desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
2321     desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN;
2322     desc.dwHeight = 128;
2323     desc.dwWidth = 128;
2324     ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL);
2325     ok(ret == DD_OK, "Creating an offscreen plain surface with width and height info returned %08x\n", ret);
2326     if(dsurface)
2327     {
2328         IDirectDrawSurface_Release(dsurface);
2329         dsurface = NULL;
2330     }
2331
2332     /* Test a primary surface size */
2333     ret = IDirectDraw_SetCooperativeLevel(lpDD, window, DDSCL_NORMAL);
2334     ok(ret == DD_OK, "SetCooperativeLevel failed with %08x\n", ret);
2335
2336     ZeroMemory(&desc, sizeof(desc));
2337     desc.dwSize = sizeof(desc);
2338     desc.dwFlags = DDSD_CAPS;
2339     desc.ddsCaps.dwCaps |= DDSCAPS_PRIMARYSURFACE;
2340     desc.dwHeight = 128; /* Keep them set to  check what happens */
2341     desc.dwWidth = 128; /* Keep them set to  check what happens */
2342     ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL);
2343     ok(ret == DD_OK, "Creating a primary surface without width and height info returned %08x\n", ret);
2344     if(dsurface)
2345     {
2346         ret = IDirectDrawSurface_GetSurfaceDesc(dsurface, &desc);
2347         ok(ret == DD_OK, "GetSurfaceDesc returned %x\n", ret);
2348
2349         IDirectDrawSurface_Release(dsurface);
2350         dsurface = NULL;
2351
2352         ok(desc.dwFlags & DDSD_WIDTH, "Primary surface doesn't have width set\n");
2353         ok(desc.dwFlags & DDSD_HEIGHT, "Primary surface doesn't have height set\n");
2354         ok(desc.dwWidth == GetSystemMetrics(SM_CXSCREEN), "Surface width differs from screen width\n");
2355         ok(desc.dwHeight == GetSystemMetrics(SM_CYSCREEN), "Surface height differs from screen height\n");
2356     }
2357     ret = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL);
2358     ok(ret == DD_OK, "SetCooperativeLevel failed with %08x\n", ret);
2359 }
2360
2361 static void PrivateDataTest(void)
2362 {
2363     HRESULT hr;
2364     IDirectDrawSurface7 *surface7 = NULL;
2365     IDirectDrawSurface *surface = NULL;
2366     DDSURFACEDESC desc;
2367     ULONG ref, ref2;
2368     IUnknown *ptr;
2369     DWORD size = sizeof(IUnknown *);
2370
2371     ZeroMemory(&desc, sizeof(desc));
2372     desc.dwSize = sizeof(desc);
2373     desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
2374     desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN;
2375     desc.dwHeight = 128;
2376     desc.dwWidth = 128;
2377     hr = IDirectDraw_CreateSurface(lpDD, &desc, &surface, NULL);
2378     ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr);
2379     if(!surface)
2380     {
2381         return;
2382     }
2383     hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface7, (void **) &surface7);
2384     ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr);
2385     if(!surface7)
2386     {
2387         IDirectDrawSurface_Release(surface);
2388         return;
2389     }
2390
2391     /* This fails */
2392     hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, 0, DDSPD_IUNKNOWNPOINTER);
2393     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr);
2394     hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, 5, DDSPD_IUNKNOWNPOINTER);
2395     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr);
2396     hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, sizeof(IUnknown *) * 2, DDSPD_IUNKNOWNPOINTER);
2397     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr);
2398
2399     ref = getref((IUnknown *) lpDD);
2400     hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER);
2401     ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr);
2402     ref2 = getref((IUnknown *) lpDD);
2403     ok(ref2 == ref + 1, "Object reference is %d, expected %d\n", ref2, ref + 1);
2404     hr = IDirectDrawSurface7_FreePrivateData(surface7, &IID_IDirectDrawSurface7);
2405     ref2 = getref((IUnknown *) lpDD);
2406     ok(ref2 == ref, "Object reference is %d, expected %d\n", ref2, ref);
2407
2408     hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7, lpDD, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER);
2409     ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr);
2410     hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7, surface7, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER);
2411     ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr);
2412     ref2 = getref((IUnknown *) lpDD);
2413     ok(ref2 == ref, "Object reference is %d, expected %d\n", ref2, ref);
2414
2415     hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7, lpDD, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER);
2416     ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr);
2417     hr = IDirectDrawSurface7_GetPrivateData(surface7, &IID_IDirectDrawSurface7, &ptr, &size);
2418     ok(hr == DD_OK, "IDirectDrawSurface7_GetPrivateData failed with %08x\n", hr);
2419     ref2 = getref((IUnknown *) lpDD);
2420     /* Object is NOT being addrefed */
2421     ok(ptr == (IUnknown *) lpDD, "Returned interface pointer is %p, expected %p\n", ptr, lpDD);
2422     ok(ref2 == ref + 1, "Object reference is %d, expected %d. ptr at %p, orig at %p\n", ref2, ref + 1, ptr, lpDD);
2423
2424     IDirectDrawSurface_Release(surface);
2425     IDirectDrawSurface7_Release(surface7);
2426
2427     /* Destroying the surface frees the held reference */
2428     ref2 = getref((IUnknown *) lpDD);
2429     ok(ref2 == ref, "Object reference is %d, expected %d\n", ref2, ref);
2430 }
2431
2432 static void BltParamTest(void)
2433 {
2434     IDirectDrawSurface *surface1 = NULL, *surface2 = NULL;
2435     DDSURFACEDESC desc;
2436     HRESULT hr;
2437     DDBLTFX BltFx;
2438     RECT valid = {10, 10, 20, 20};
2439     RECT invalid1 = {20, 10, 10, 20};
2440     RECT invalid2 = {20, 20, 20, 20};
2441     RECT invalid3 = {-1, -1, 20, 20};
2442     RECT invalid4 = {60, 60, 70, 70};
2443
2444     memset(&desc, 0, sizeof(desc));
2445     desc.dwSize = sizeof(desc);
2446     desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
2447     desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN;
2448     desc.dwHeight = 128;
2449     desc.dwWidth = 128;
2450     hr = IDirectDraw_CreateSurface(lpDD, &desc, &surface1, NULL);
2451     ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr);
2452
2453     desc.dwHeight = 64;
2454     desc.dwWidth = 64;
2455     hr = IDirectDraw_CreateSurface(lpDD, &desc, &surface2, NULL);
2456     ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr);
2457
2458     if(0)
2459     {
2460         /* This crashes */
2461         hr = IDirectDrawSurface_BltFast(surface1, 0, 0, NULL, NULL, 0);
2462         ok(hr == DD_OK, "BltFast from NULL surface returned %08x\n", hr);
2463     }
2464     hr = IDirectDrawSurface_BltFast(surface1, 0, 0, surface2, NULL, 0);
2465     ok(hr == DD_OK, "BltFast from smaller to bigger surface returned %08x\n", hr);
2466     hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, NULL, 0);
2467     ok(hr == DDERR_INVALIDRECT, "BltFast from bigger to smaller surface returned %08x\n", hr);
2468     hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &valid, 0);
2469     ok(hr == DD_OK, "BltFast from bigger to smaller surface using a valid rectangle returned %08x\n", hr);
2470     hr = IDirectDrawSurface_BltFast(surface2, 60, 60, surface1, &valid, 0);
2471     ok(hr == DDERR_INVALIDRECT, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr);
2472     hr = IDirectDrawSurface_BltFast(surface1, 90, 90, surface2, NULL, 0);
2473     ok(hr == DDERR_INVALIDRECT, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr);
2474     hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &invalid1, 0);
2475     ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 1 returned %08x\n", hr);
2476     hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &invalid2, 0);
2477     ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 2 returned %08x\n", hr);
2478     hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &invalid3, 0);
2479     ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 3 returned %08x\n", hr);
2480     hr = IDirectDrawSurface_BltFast(surface1, 0, 0, surface2, &invalid4, 0);
2481     ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 3 returned %08x\n", hr);
2482     hr = IDirectDrawSurface_BltFast(surface1, 0, 0, surface1, NULL, 0);
2483     ok(hr == DD_OK, "BltFast blitting a surface onto itself returned %08x\n", hr);
2484
2485     /* Blt(non-fast) tests */
2486     memset(&BltFx, 0, sizeof(BltFx));
2487     BltFx.dwSize = sizeof(BltFx);
2488     U5(BltFx).dwFillColor = 0xaabbccdd;
2489
2490     hr = IDirectDrawSurface_Blt(surface1, &valid, NULL, NULL, DDBLT_COLORFILL, &BltFx);
2491     ok(hr == DD_OK, "IDirectDrawSurface_Blt with a valid rectangle for color fill returned %08x\n", hr);
2492     hr = IDirectDrawSurface_Blt(surface1, &valid, NULL, &invalid3, DDBLT_COLORFILL, &BltFx);
2493     ok(hr == DD_OK, "IDirectDrawSurface_Blt with a invalid, unused rectangle returned %08x\n", hr);
2494     hr = IDirectDrawSurface_Blt(surface2, &invalid1, NULL, NULL, DDBLT_COLORFILL, &BltFx);
2495     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr);
2496     hr = IDirectDrawSurface_Blt(surface2, &invalid2, NULL, NULL, DDBLT_COLORFILL, &BltFx);
2497     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr);
2498     hr = IDirectDrawSurface_Blt(surface2, &invalid3, NULL, NULL, DDBLT_COLORFILL, &BltFx);
2499     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr);
2500     hr = IDirectDrawSurface_Blt(surface2, &invalid4, NULL, NULL, DDBLT_COLORFILL, &BltFx);
2501     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr);
2502
2503     /* Valid on surface 1 */
2504     hr = IDirectDrawSurface_Blt(surface1, &invalid4, NULL, NULL, DDBLT_COLORFILL, &BltFx);
2505     ok(hr == DD_OK, "IDirectDrawSurface_Blt with a subrectangle fill returned %08x\n", hr);
2506
2507     /* Works - stretched blit */
2508     hr = IDirectDrawSurface_Blt(surface1, NULL, surface2, NULL, 0, NULL);
2509     ok(hr == DD_OK, "IDirectDrawSurface_Blt from a smaller to a bigger surface returned %08x\n", hr);
2510     hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, NULL, 0, NULL);
2511     ok(hr == DD_OK, "IDirectDrawSurface_Blt from a bigger to a smaller surface %08x\n", hr);
2512
2513     /* Invalid dest rects in sourced blits */
2514     hr = IDirectDrawSurface_Blt(surface2, &invalid1, surface1, NULL, 0, NULL);
2515     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr);
2516     hr = IDirectDrawSurface_Blt(surface2, &invalid2, surface1, NULL, 0, NULL);
2517     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr);
2518     hr = IDirectDrawSurface_Blt(surface2, &invalid3, surface1, NULL, 0, NULL);
2519     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr);
2520     hr = IDirectDrawSurface_Blt(surface2, &invalid4, surface1, NULL, 0, NULL);
2521     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr);
2522
2523     /* Invalid src rects */
2524     hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, &invalid1, 0, NULL);
2525     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr);
2526     hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, &invalid2, 0, NULL);
2527     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr);
2528     hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, &invalid3, 0, NULL);
2529     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr);
2530     hr = IDirectDrawSurface_Blt(surface1, NULL, surface2, &invalid4, 0, NULL);
2531     ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr);
2532
2533     IDirectDrawSurface_Release(surface1);
2534     IDirectDrawSurface_Release(surface2);
2535 }
2536
2537 static void PaletteTest(void)
2538 {
2539     HRESULT hr;
2540     LPDIRECTDRAWSURFACE lpSurf = NULL;
2541     DDSURFACEDESC ddsd;
2542     IDirectDrawPalette *palette = NULL;
2543     PALETTEENTRY Table[256];
2544     PALETTEENTRY palEntries[256];
2545     int i;
2546
2547     for(i=0; i<256; i++)
2548     {
2549         Table[i].peRed   = 0xff;
2550         Table[i].peGreen = 0;
2551         Table[i].peBlue  = 0;
2552         Table[i].peFlags = 0;
2553     }
2554
2555     /* Create a 8bit palette without DDPCAPS_ALLOW256 set */
2556     hr = IDirectDraw_CreatePalette(lpDD, DDPCAPS_8BIT, Table, &palette, NULL);
2557     ok(hr == DD_OK, "CreatePalette failed with %08x\n", hr);
2558     if (FAILED(hr)) goto err;
2559     /* Read back the palette and verify the entries. Without DDPCAPS_ALLOW256 set
2560     /  entry 0 and 255 should have been overwritten with black and white */
2561     IDirectDrawPalette_GetEntries(palette , 0, 0, 256, &palEntries[0]);
2562     ok(hr == DD_OK, "GetEntries failed with %08x\n", hr);
2563     if(hr == DD_OK)
2564     {
2565         ok((palEntries[0].peRed == 0) && (palEntries[0].peGreen == 0) && (palEntries[0].peBlue == 0),
2566            "Palette entry 0 of a palette without DDPCAPS_ALLOW256 set should be (0,0,0) but it is (%d,%d,%d)\n",
2567            palEntries[0].peRed, palEntries[0].peGreen, palEntries[0].peBlue);
2568         ok((palEntries[255].peRed == 255) && (palEntries[255].peGreen == 255) && (palEntries[255].peBlue == 255),
2569            "Palette entry 255 of a palette without DDPCAPS_ALLOW256 set should be (255,255,255) but it is (%d,%d,%d)\n",
2570            palEntries[255].peRed, palEntries[255].peGreen, palEntries[255].peBlue);
2571
2572         /* Entry 1-254 should contain red */
2573         for(i=1; i<255; i++)
2574             ok((palEntries[i].peRed == 255) && (palEntries[i].peGreen == 0) && (palEntries[i].peBlue == 0),
2575                "Palette entry %d should have contained (255,0,0) but was set to %d,%d,%d)\n",
2576                i, palEntries[i].peRed, palEntries[i].peGreen, palEntries[i].peBlue);
2577     }
2578
2579     /* CreatePalette without DDPCAPS_ALLOW256 ignores entry 0 and 255,
2580     /  now check we are able to update the entries afterwards. */
2581     IDirectDrawPalette_SetEntries(palette , 0, 0, 256, &Table[0]);
2582     ok(hr == DD_OK, "SetEntries failed with %08x\n", hr);
2583     IDirectDrawPalette_GetEntries(palette , 0, 0, 256, &palEntries[0]);
2584     ok(hr == DD_OK, "GetEntries failed with %08x\n", hr);
2585     if(hr == DD_OK)
2586     {
2587         ok((palEntries[0].peRed == 0) && (palEntries[0].peGreen == 0) && (palEntries[0].peBlue == 0),
2588            "Palette entry 0 should have been set to (0,0,0) but it contains (%d,%d,%d)\n",
2589            palEntries[0].peRed, palEntries[0].peGreen, palEntries[0].peBlue);
2590         ok((palEntries[255].peRed == 255) && (palEntries[255].peGreen == 255) && (palEntries[255].peBlue == 255),
2591            "Palette entry 255 should have been set to (255,255,255) but it contains (%d,%d,%d)\n",
2592            palEntries[255].peRed, palEntries[255].peGreen, palEntries[255].peBlue);
2593     }
2594     IDirectDrawPalette_Release(palette);
2595
2596     /* Create a 8bit palette with DDPCAPS_ALLOW256 set */
2597     hr = IDirectDraw_CreatePalette(lpDD, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL);
2598     ok(hr == DD_OK, "CreatePalette failed with %08x\n", hr);
2599     if (FAILED(hr)) goto err;
2600
2601     IDirectDrawPalette_GetEntries(palette , 0, 0, 256, &palEntries[0]);
2602     ok(hr == DD_OK, "GetEntries failed with %08x\n", hr);
2603     if(hr == DD_OK)
2604     {
2605         /* All entries should contain red */
2606         for(i=0; i<256; i++)
2607             ok((palEntries[i].peRed == 255) && (palEntries[i].peGreen == 0) && (palEntries[i].peBlue == 0),
2608                "Palette entry %d should have contained (255,0,0) but was set to %d,%d,%d)\n",
2609                i, palEntries[i].peRed, palEntries[i].peGreen, palEntries[i].peBlue);
2610     }
2611
2612     /* Try to set palette to a non-palettized surface */
2613     ddsd.dwSize = sizeof(ddsd);
2614     ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
2615     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
2616     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
2617     ddsd.dwWidth = 800;
2618     ddsd.dwHeight = 600;
2619     ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
2620     U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
2621     U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000;
2622     U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00;
2623     U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF;
2624     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSurf, NULL);
2625     ok(hr==DD_OK, "CreateSurface returned: %x\n",hr);
2626     if (FAILED(hr)) {
2627         skip("failed to create surface\n");
2628         goto err;
2629     }
2630
2631     hr = IDirectDrawSurface_SetPalette(lpSurf, palette);
2632     ok(hr == DDERR_INVALIDPIXELFORMAT, "CreateSurface returned: %x\n",hr);
2633
2634     IDirectDrawPalette_Release(palette);
2635     palette = NULL;
2636
2637     hr = IDirectDrawSurface_GetPalette(lpSurf, &palette);
2638     ok(hr == DDERR_NOPALETTEATTACHED, "CreateSurface returned: %x\n",hr);
2639
2640     err:
2641
2642     if (lpSurf) IDirectDrawSurface_Release(lpSurf);
2643     if (palette) IDirectDrawPalette_Release(palette);
2644 }
2645
2646 static void StructSizeTest(void)
2647 {
2648     IDirectDrawSurface *surface1;
2649     IDirectDrawSurface7 *surface7;
2650     union {
2651         DDSURFACEDESC desc1;
2652         DDSURFACEDESC2 desc2;
2653         char blob[1024]; /* To get a bunch of writable memory */
2654     } desc;
2655     DDSURFACEDESC create;
2656     HRESULT hr;
2657
2658     memset(&desc, 0, sizeof(desc));
2659     memset(&create, 0, sizeof(create));
2660
2661     memset(&create, 0, sizeof(create));
2662     create.dwSize = sizeof(create);
2663     create.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
2664     create.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN;
2665     create.dwHeight = 128;
2666     create.dwWidth = 128;
2667     hr = IDirectDraw_CreateSurface(lpDD, &create, &surface1, NULL);
2668     ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr);
2669     hr = IDirectDrawSurface_QueryInterface(surface1, &IID_IDirectDrawSurface7, (void **) &surface7);
2670     ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr);
2671
2672     desc.desc1.dwSize = sizeof(DDSURFACEDESC);
2673     hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1);
2674     ok(hr == DD_OK, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr);
2675     hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2);
2676     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr);
2677
2678     desc.desc2.dwSize = sizeof(DDSURFACEDESC2);
2679     hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1);
2680     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr);
2681     hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2);
2682     ok(hr == DD_OK, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr);
2683
2684     desc.desc2.dwSize = 0;
2685     hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1);
2686     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size 0 returned %08x\n", hr);
2687     hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2);
2688     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size 0 returned %08x\n", hr);
2689
2690     desc.desc1.dwSize = sizeof(DDSURFACEDESC) + 1;
2691     hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1);
2692     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr);
2693     hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2);
2694     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr);
2695
2696     desc.desc2.dwSize = sizeof(DDSURFACEDESC2) + 1;
2697     hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1);
2698     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr);
2699     hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2);
2700     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr);
2701
2702     /* Tests for Lock() */
2703
2704     desc.desc1.dwSize = sizeof(DDSURFACEDESC);
2705     hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0);
2706     ok(hr == DD_OK, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr);
2707     if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL);
2708     ok(desc.desc1.dwSize == sizeof(DDSURFACEDESC), "Destination size was changed to %d\n", desc.desc1.dwSize);
2709     hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0);
2710     ok(hr == DD_OK, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr);
2711     if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL);
2712     ok(desc.desc2.dwSize == sizeof(DDSURFACEDESC), "Destination size was changed to %d\n", desc.desc1.dwSize);
2713
2714     desc.desc2.dwSize = sizeof(DDSURFACEDESC2);
2715     hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0);
2716     ok(hr == DD_OK, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr);
2717     ok(desc.desc1.dwSize == sizeof(DDSURFACEDESC2), "Destination size was changed to %d\n", desc.desc1.dwSize);
2718     if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL);
2719     hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0);
2720     ok(hr == DD_OK, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr);
2721     if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL);
2722     ok(desc.desc2.dwSize == sizeof(DDSURFACEDESC2), "Destination size was changed to %d\n", desc.desc1.dwSize);
2723
2724     desc.desc2.dwSize = 0;
2725     hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0);
2726     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Lock with desc size 0 returned %08x\n", hr);
2727     if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL);
2728     hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0);
2729     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_Lock with desc size 0 returned %08x\n", hr);
2730     if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL);
2731
2732     desc.desc1.dwSize = sizeof(DDSURFACEDESC) + 1;
2733     hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0);
2734     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr);
2735     if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL);
2736     hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0);
2737     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr);
2738     if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL);
2739
2740     desc.desc2.dwSize = sizeof(DDSURFACEDESC2) + 1;
2741     hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0);
2742     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr);
2743     if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL);
2744     hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0);
2745     ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr);
2746     if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL);
2747
2748     IDirectDrawSurface7_Release(surface7);
2749     IDirectDrawSurface_Release(surface1);
2750 }
2751
2752 static void SurfaceCapsTest(void)
2753 {
2754     DDSURFACEDESC create;
2755     DDSURFACEDESC desc;
2756     HRESULT hr;
2757     IDirectDrawSurface *surface1 = NULL;
2758     DDSURFACEDESC2 create2, desc2;
2759     IDirectDrawSurface7 *surface7 = NULL;
2760     IDirectDraw7 *dd7 = NULL;
2761     DWORD create_caps[] = {
2762         DDSCAPS_OFFSCREENPLAIN,
2763         DDSCAPS_TEXTURE,
2764         DDSCAPS_TEXTURE | DDSCAPS_ALLOCONLOAD,
2765         0,
2766         DDSCAPS_TEXTURE | DDSCAPS_ALLOCONLOAD | DDSCAPS_SYSTEMMEMORY,
2767         DDSCAPS_PRIMARYSURFACE,
2768         DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY
2769     };
2770     DWORD expected_caps[] = {
2771         DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM,
2772         DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM,
2773         DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM | DDSCAPS_ALLOCONLOAD,
2774         DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM,
2775         DDSCAPS_TEXTURE | DDSCAPS_ALLOCONLOAD | DDSCAPS_SYSTEMMEMORY,
2776         DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM | DDSCAPS_VISIBLE,
2777         DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_VISIBLE
2778     };
2779     UINT i;
2780     DDCAPS ddcaps;
2781
2782     /* Tests various surface flags, what changes do they undergo during surface creation. Forsaken
2783      * engine expects texture surfaces without memory flag to get a video memory flag right after
2784      * creation. Currently, Wine adds DDSCAPS_FRONTBUFFER to primary surface, but native doesn't do this
2785      * for single buffered primaries. Because of this primary surface creation tests are todo_wine. No real
2786      * app is known so far to care about this. */
2787     ddcaps.dwSize = sizeof(DDCAPS);
2788     hr = IDirectDraw_GetCaps(lpDD, &ddcaps, NULL);
2789     ok(hr == DD_OK, "IDirectDraw_GetCaps failed with %08x\n", hr);
2790
2791     if (!(ddcaps.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
2792     {
2793         skip("DDraw reported no VIDEOMEMORY cap. Broken video driver? Skipping surface caps tests.\n");
2794         return ;
2795     }
2796
2797     for (i = 0; i < sizeof(create_caps) / sizeof(DWORD); i++)
2798     {
2799         memset(&create, 0, sizeof(create));
2800         create.dwSize = sizeof(create);
2801         create.ddsCaps.dwCaps = create_caps[i];
2802         create.dwFlags = DDSD_CAPS;
2803
2804         if (!(create.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
2805         {
2806             create.dwFlags |= DDSD_HEIGHT | DDSD_WIDTH;
2807             create.dwHeight = 128;
2808             create.dwWidth = 128;
2809         }
2810
2811         hr = IDirectDraw_CreateSurface(lpDD, &create, &surface1, NULL);
2812         ok(hr == DD_OK, "IDirectDraw_CreateSurface failed with %08x\n", hr);
2813
2814         if (SUCCEEDED(hr))
2815         {
2816             memset(&desc, 0, sizeof(desc));
2817             desc.dwSize = sizeof(DDSURFACEDESC);
2818             hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc);
2819             ok(hr == DD_OK, "IDirectDrawSurface_GetSurfaceDesc failed with %08x\n", hr);
2820
2821             if (!(create_caps[i] & DDSCAPS_PRIMARYSURFACE))
2822                 ok(desc.ddsCaps.dwCaps == expected_caps[i],
2823                     "GetSurfaceDesc returned caps %x, expected %x\n", desc.ddsCaps.dwCaps,
2824                     expected_caps[i]);
2825             else
2826                 todo_wine ok(desc.ddsCaps.dwCaps == expected_caps[i],
2827                                 "GetSurfaceDesc returned caps %x, expected %x\n", desc.ddsCaps.dwCaps,
2828                                 expected_caps[i]);
2829
2830             IDirectDrawSurface_Release(surface1);
2831         }
2832     }
2833
2834     /* Test for differences in ddraw 7 */
2835     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
2836     ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
2837     if (FAILED(hr))
2838     {
2839         skip("Failed to get IDirectDraw7 interface, skipping tests\n");
2840     }
2841     else
2842     {
2843         for (i = 0; i < sizeof(create_caps) / sizeof(DWORD); i++)
2844         {
2845             memset(&create2, 0, sizeof(create2));
2846             create2.dwSize = sizeof(create2);
2847             create2.ddsCaps.dwCaps = create_caps[i];
2848             create2.dwFlags = DDSD_CAPS;
2849
2850             if (!(create2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
2851             {
2852                 create2.dwFlags |= DDSD_HEIGHT | DDSD_WIDTH;
2853                 create2.dwHeight = 128;
2854                 create2.dwWidth = 128;
2855             }
2856
2857             hr = IDirectDraw7_CreateSurface(dd7, &create2, &surface7, NULL);
2858             ok(hr==DD_OK,"CreateSurface returned: %x\n",hr);
2859
2860             if (SUCCEEDED(hr))
2861             {
2862                 memset(&desc2, 0, sizeof(desc2));
2863                 desc2.dwSize = sizeof(DDSURFACEDESC2);
2864                 hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc2);
2865                 ok(hr == DD_OK, "IDirectDrawSurface_GetSurfaceDesc failed with %08x\n", hr);
2866
2867                 if (!(create_caps[i] & DDSCAPS_PRIMARYSURFACE))
2868                     ok(desc2.ddsCaps.dwCaps == expected_caps[i],
2869                         "GetSurfaceDesc returned caps %x, expected %x\n", desc2.ddsCaps.dwCaps,
2870                         expected_caps[i]);
2871                 else
2872                     todo_wine ok(desc2.ddsCaps.dwCaps == expected_caps[i],
2873                                     "GetSurfaceDesc returned caps %x, expected %x\n", desc2.ddsCaps.dwCaps,
2874                                     expected_caps[i]);
2875
2876                 IDirectDrawSurface7_Release(surface7);
2877             }
2878         }
2879
2880         IDirectDraw7_Release(dd7);
2881     }
2882
2883     memset(&create, 0, sizeof(create));
2884     create.dwSize = sizeof(create);
2885     create.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
2886     create.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_VIDEOMEMORY;
2887     create.dwWidth = 64;
2888     create.dwHeight = 64;
2889     hr = IDirectDraw_CreateSurface(lpDD, &create, &surface1, NULL);
2890     ok(hr == DDERR_INVALIDCAPS, "Creating a SYSMEM | VIDMEM surface returned 0x%08x, expected DDERR_INVALIDCAPS\n", hr);
2891     if(surface1) IDirectDrawSurface_Release(surface1);
2892 }
2893
2894 static BOOL can_create_primary_surface(void)
2895 {
2896     DDSURFACEDESC ddsd;
2897     IDirectDrawSurface *surface;
2898     HRESULT hr;
2899
2900     memset(&ddsd, 0, sizeof(ddsd));
2901     ddsd.dwSize = sizeof(ddsd);
2902     ddsd.dwFlags = DDSD_CAPS;
2903     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2904     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL);
2905     if(FAILED(hr)) return FALSE;
2906     IDirectDrawSurface_Release(surface);
2907     return TRUE;
2908 }
2909
2910 static void dctest_surf(IDirectDrawSurface *surf, int ddsdver) {
2911     HRESULT hr;
2912     HDC dc, dc2 = (HDC) 0x1234;
2913     DDSURFACEDESC ddsd;
2914     DDSURFACEDESC2 ddsd2;
2915
2916     memset(&ddsd, 0, sizeof(ddsd));
2917     ddsd.dwSize = sizeof(ddsd);
2918     memset(&ddsd2, 0, sizeof(ddsd2));
2919     ddsd2.dwSize = sizeof(ddsd2);
2920
2921     hr = IDirectDrawSurface_GetDC(surf, &dc);
2922     ok(hr == DD_OK, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr);
2923
2924     hr = IDirectDrawSurface_GetDC(surf, &dc2);
2925     ok(hr == DDERR_DCALREADYCREATED, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr);
2926     ok(dc2 == (HDC) 0x1234, "The failed GetDC call changed the dc: %p\n", dc2);
2927
2928     hr = IDirectDrawSurface_Lock(surf, NULL, ddsdver == 1 ? &ddsd : ((DDSURFACEDESC *) &ddsd2), 0, NULL);
2929     ok(hr == DDERR_SURFACEBUSY, "IDirectDrawSurface_Lock returned 0x%08x, expected DDERR_ALREADYLOCKED\n", hr);
2930
2931     hr = IDirectDrawSurface_ReleaseDC(surf, dc);
2932     ok(hr == DD_OK, "IDirectDrawSurface_ReleaseDC failed: 0x%08x\n", hr);
2933     hr = IDirectDrawSurface_ReleaseDC(surf, dc);
2934     ok(hr == DDERR_NODC, "IDirectDrawSurface_ReleaseDC returned 0x%08x, expected DDERR_NODC\n", hr);
2935 }
2936
2937 static void GetDCTest(void)
2938 {
2939     DDSURFACEDESC ddsd;
2940     DDSURFACEDESC2 ddsd2;
2941     IDirectDrawSurface *surf;
2942     IDirectDrawSurface2 *surf2;
2943     IDirectDrawSurface4 *surf4;
2944     IDirectDrawSurface7 *surf7;
2945     HRESULT hr;
2946     IDirectDraw2 *dd2;
2947     IDirectDraw4 *dd4;
2948     IDirectDraw7 *dd7;
2949
2950     memset(&ddsd, 0, sizeof(ddsd));
2951     ddsd.dwSize = sizeof(ddsd);
2952     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
2953     ddsd.dwWidth = 64;
2954     ddsd.dwHeight = 64;
2955     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
2956     memset(&ddsd2, 0, sizeof(ddsd2));
2957     ddsd2.dwSize = sizeof(ddsd2);
2958     ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
2959     ddsd2.dwWidth = 64;
2960     ddsd2.dwHeight = 64;
2961     ddsd2.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
2962
2963     hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surf, NULL);
2964     ok(hr == DD_OK, "IDirectDraw_CreateSurface failed: 0x%08x\n", hr);
2965     dctest_surf(surf, 1);
2966     IDirectDrawSurface_Release(surf);
2967
2968     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2);
2969     ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr);
2970
2971     hr = IDirectDraw2_CreateSurface(dd2, &ddsd, &surf, NULL);
2972     ok(hr == DD_OK, "IDirectDraw2_CreateSurface failed: 0x%08x\n", hr);
2973     dctest_surf(surf, 1);
2974
2975     hr = IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface2, (void **) &surf2);
2976     ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed: 0x%08x\n", hr);
2977     dctest_surf((IDirectDrawSurface *) surf2, 1);
2978
2979     IDirectDrawSurface2_Release(surf2);
2980     IDirectDrawSurface_Release(surf);
2981     IDirectDraw2_Release(dd2);
2982
2983     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4);
2984     ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr);
2985
2986     surf = NULL;
2987     hr = IDirectDraw4_CreateSurface(dd4, &ddsd2, &surf4, NULL);
2988     ok(hr == DD_OK, "IDirectDraw4_CreateSurface failed: 0x%08x\n", hr);
2989     dctest_surf((IDirectDrawSurface *) surf4, 2);
2990
2991     IDirectDrawSurface4_Release(surf4);
2992     IDirectDraw4_Release(dd4);
2993
2994     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
2995     ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr);
2996     surf = NULL;
2997     hr = IDirectDraw7_CreateSurface(dd7, &ddsd2, &surf7, NULL);
2998     ok(hr == DD_OK, "IDirectDraw7_CreateSurface failed: 0x%08x\n", hr);
2999     dctest_surf((IDirectDrawSurface *) surf7, 2);
3000
3001     IDirectDrawSurface7_Release(surf7);
3002     IDirectDraw7_Release(dd7);
3003 }
3004
3005 static void GetDCFormatTest(void)
3006 {
3007     DDSURFACEDESC2 ddsd;
3008     unsigned int i;
3009     IDirectDrawSurface7 *surface;
3010     IDirectDraw7 *dd7;
3011     HRESULT hr;
3012     HDC dc;
3013
3014     struct
3015     {
3016         const char *name;
3017         DDPIXELFORMAT fmt;
3018         BOOL getdc_capable;
3019     } testdata[] = {
3020         {
3021             "D3DFMT_A8R8G8B8",
3022             {
3023                 sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0,
3024                 {32}, {0x00ff0000}, {0x0000ff00}, {0x000000ff}, {0xff000000}
3025             },
3026             TRUE
3027         },
3028         {
3029             "D3DFMT_X8R8G8B8",
3030             {
3031                 sizeof(DDPIXELFORMAT), DDPF_RGB, 0,
3032                 {32}, {0x00ff0000}, {0x0000ff00}, {0x000000ff}, {0x00000000}
3033             },
3034             TRUE
3035         },
3036         {
3037             "D3DFMT_X8B8G8R8",
3038             {
3039                 sizeof(DDPIXELFORMAT), DDPF_RGB, 0,
3040                 {32}, {0x000000ff}, {0x0000ff00}, {0x00ff0000}, {0x00000000}
3041             },
3042             TRUE
3043         },
3044         {
3045             "D3DFMT_X8B8G8R8",
3046             {
3047                 sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0,
3048                        {32}, {0x000000ff}, {0x0000ff00}, {0x00ff0000}, {0xff000000}
3049             },
3050             TRUE
3051         },
3052         {
3053             "D3DFMT_A4R4G4B4",
3054             {
3055                 sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0,
3056                        {16}, {0x00000f00}, {0x000000f0}, {0x0000000f}, {0x0000f000}
3057             },
3058             TRUE
3059         },
3060         {
3061             "D3DFMT_X4R4G4B4",
3062             {
3063                 sizeof(DDPIXELFORMAT), DDPF_RGB, 0,
3064                        {16}, {0x00000f00}, {0x000000f0}, {0x0000000f}, {0x00000000}
3065             },
3066             TRUE
3067         },
3068         {
3069             "D3DFMT_R5G6B5",
3070             {
3071                 sizeof(DDPIXELFORMAT), DDPF_RGB, 0,
3072                        {16}, {0x0000F800}, {0x000007E0}, {0x0000001F}, {0x00000000}
3073             },
3074             TRUE
3075         },
3076         {
3077             "D3DFMT_A1R5G5B5",
3078             {
3079                 sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0,
3080                        {16}, {0x00007C00}, {0x000003E0}, {0x0000001F}, {0x00008000}
3081             },
3082             TRUE
3083         },
3084         {
3085             "D3DFMT_X1R5G5B5",
3086             {
3087                 sizeof(DDPIXELFORMAT), DDPF_RGB, 0,
3088                        {16}, {0x00007C00}, {0x000003E0}, {0x0000001F}, {0x00000000}
3089             },
3090             TRUE
3091         },
3092         {
3093             "D3DFMT_R3G3B2",
3094             {
3095                 sizeof(DDPIXELFORMAT), DDPF_RGB, 0,
3096                        { 8}, {0x000000E0}, {0x0000001C}, {0x00000003}, {0x00000000}
3097             },
3098             FALSE
3099         },
3100         {
3101             /* Untested, windows test machine didn't support this format */
3102             "D3DFMT_A2R10G10B10",
3103             {
3104                 sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0,
3105                        {32}, {0xC0000000}, {0x3FF00000}, {0x000FFC00}, {0x000003FF}
3106             },
3107             FALSE
3108         },
3109         /*
3110          * GetDC on a P8 surface fails unless the display mode is 8 bpp. This is not
3111          * implemented in wine yet, so disable the test for now. Succeeding P8 getDC
3112          * calls are tested in the ddraw.visual test.
3113          *
3114         {
3115             "D3DFMT_P8",
3116             {
3117                 sizeof(DDPIXELFORMAT), DDPF_PALETTEINDEXED8 | DDPF_RGB, 0,
3118                 {8 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000}
3119             },
3120             FALSE
3121         },
3122          */
3123         {
3124             "D3DFMT_L8",
3125             {
3126                 sizeof(DDPIXELFORMAT), DDPF_LUMINANCE, 0,
3127                 {8 }, {0x000000ff}, {0x00000000}, {0x00000000}, {0x00000000}
3128             },
3129             FALSE
3130         },
3131         {
3132             "D3DFMT_A8L8",
3133             {
3134                 sizeof(DDPIXELFORMAT), DDPF_ALPHAPIXELS | DDPF_LUMINANCE, 0,
3135                 {16}, {0x000000ff}, {0x00000000}, {0x00000000}, {0x0000ff00}
3136             },
3137             FALSE
3138         },
3139         {
3140             "D3DFMT_DXT1",
3141             {
3142                 sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','1'),
3143                 {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000}
3144             },
3145             FALSE
3146         },
3147         {
3148             "D3DFMT_DXT2",
3149             {
3150                 sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','2'),
3151                 {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000}
3152             },
3153             FALSE
3154         },
3155         {
3156             "D3DFMT_DXT3",
3157             {
3158                 sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','3'),
3159                 {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000}
3160             },
3161             FALSE
3162         },
3163         {
3164             "D3DFMT_DXT4",
3165             {
3166                 sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','4'),
3167                 {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000}
3168             },
3169             FALSE
3170         },
3171         {
3172             "D3DFMT_DXT5",
3173             {
3174                 sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','5'),
3175                 {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000}
3176             },
3177             FALSE
3178         },
3179     };
3180
3181     hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
3182     ok(hr == DD_OK, "IDirectDraw_QueryInterface failed, hr = 0x%08x\n", hr);
3183
3184     for(i = 0; i < (sizeof(testdata) / sizeof(testdata[0])); i++)
3185     {
3186         memset(&ddsd, 0, sizeof(ddsd));
3187         ddsd.dwSize = sizeof(ddsd);
3188         ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
3189         ddsd.dwWidth = 64;
3190         ddsd.dwHeight = 64;
3191         ddsd.ddpfPixelFormat = testdata[i].fmt;
3192         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
3193
3194         hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
3195         hr = E_FAIL;
3196         if(FAILED(hr))
3197         {
3198             ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
3199             ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
3200             hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL);
3201             if(FAILED(hr))
3202             {
3203                 skip("IDirectDraw7_CreateSurface failed, hr = 0x%08x, format %s\n", hr, testdata[i].name);
3204                 continue;
3205             }
3206         }
3207
3208         dc = (void *) 0x1234;
3209         hr = IDirectDrawSurface7_GetDC(surface, &dc);
3210         if(testdata[i].getdc_capable)
3211         {
3212             ok(SUCCEEDED(hr), "GetDC on a %s surface failed(0x%08x), expected it to work\n",
3213                testdata[i].name, hr);
3214         }
3215         else
3216         {
3217             ok(FAILED(hr), "GetDC on a %s surface succeeded(0x%08x), expected it to fail\n",
3218                testdata[i].name, hr);
3219         }
3220
3221         if(SUCCEEDED(hr))
3222         {
3223             IDirectDrawSurface7_ReleaseDC(surface, dc);
3224             ok(hr == DD_OK, "IDirectDrawSurface7_ReleaseDC failed, hr = 0x%08x\n", hr);
3225             dc = 0;
3226         }
3227         else
3228         {
3229             ok(dc == NULL, "After failed GetDC dc is %p\n", dc);
3230         }
3231
3232         IDirectDrawSurface7_Release(surface);
3233     }
3234
3235     IDirectDraw7_Release(dd7);
3236 }
3237
3238 START_TEST(dsurface)
3239 {
3240     HRESULT ret;
3241     IDirectDraw4 *dd4;
3242
3243     if (!CreateDirectDraw())
3244         return;
3245
3246     ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4);
3247     if (ret == E_NOINTERFACE)
3248     {
3249         win_skip("DirectDraw4 and higher are not supported\n");
3250         ReleaseDirectDraw();
3251         return;
3252     }
3253     IDirectDraw_Release(dd4);
3254
3255     if(!can_create_primary_surface())
3256     {
3257         skip("Unable to create primary surface\n");
3258         return;
3259     }
3260
3261     MipMapCreationTest();
3262     SrcColorKey32BlitTest();
3263     QueryInterface();
3264     GetDDInterface_1();
3265     GetDDInterface_2();
3266     GetDDInterface_4();
3267     GetDDInterface_7();
3268     IFaceRefCount();
3269     EnumTest();
3270     AttachmentTest();
3271     AttachmentTest7();
3272     CubeMapTest();
3273     test_lockrect_invalid();
3274     CompressedTest();
3275     SizeTest();
3276     PrivateDataTest();
3277     BltParamTest();
3278     StructSizeTest();
3279     PaletteTest();
3280     SurfaceCapsTest();
3281     GetDCTest();
3282     GetDCFormatTest();
3283     ReleaseDirectDraw();
3284 }