/* * Unit tests for (a few) ddraw surface functions * * Copyright (C) 2005 Antoine Chavasse (a.chavasse@gmail.com) * Copyright (C) 2005 Christian Costa * Copyright 2005 Ivan Leo Puoti * Copyright (C) 2007-2009, 2011 Stefan Dösinger for CodeWeavers * Copyright (C) 2008 Alexander Dorofeyev * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #define COBJMACROS #include "wine/test.h" #include "wine/exception.h" #include "ddraw.h" #include "d3d.h" #include "unknwn.h" static HRESULT (WINAPI *pDirectDrawCreateEx)(GUID *, void **, REFIID, IUnknown *); static LPDIRECTDRAW lpDD = NULL; static DDCAPS ddcaps; static BOOL CreateDirectDraw(void) { HRESULT rc; rc = DirectDrawCreate(NULL, &lpDD, NULL); ok(rc==DD_OK || rc==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", rc); if (!lpDD) { trace("DirectDrawCreateEx() failed with an error %x\n", rc); return FALSE; } rc = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL); ok(rc==DD_OK,"SetCooperativeLevel returned: %x\n",rc); return TRUE; } static void ReleaseDirectDraw(void) { if( lpDD != NULL ) { IDirectDraw_Release(lpDD); lpDD = NULL; } } static void MipMapCreationTest(void) { LPDIRECTDRAWSURFACE lpDDSMipMapTest; DDSURFACEDESC ddsd; HRESULT rc; /* First mipmap creation test: create a surface with DDSCAPS_COMPLEX, DDSCAPS_MIPMAP, and DDSD_MIPMAPCOUNT. This create the number of requested mipmap levels. */ ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; U2(ddsd).dwMipMapCount = 3; ddsd.dwWidth = 128; ddsd.dwHeight = 32; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); if (FAILED(rc)) { skip("failed to create surface\n"); return; } /* Check the number of created mipmaps */ memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd); ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc); ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT, "GetSurfaceDesc returned no mipmapcount.\n"); ok(U2(ddsd).dwMipMapCount == 3, "Incorrect mipmap count: %d.\n", U2(ddsd).dwMipMapCount); /* Destroy the surface. */ IDirectDrawSurface_Release(lpDDSMipMapTest); /* Second mipmap creation test: create a surface without a mipmap count, with DDSCAPS_MIPMAP and without DDSCAPS_COMPLEX. This creates a single mipmap level. */ memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP; ddsd.dwWidth = 128; ddsd.dwHeight = 32; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); if (FAILED(rc)) { skip("failed to create surface\n"); return; } /* Check the number of created mipmaps */ memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd); ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc); ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT, "GetSurfaceDesc returned no mipmapcount.\n"); ok(U2(ddsd).dwMipMapCount == 1, "Incorrect mipmap count: %d.\n", U2(ddsd).dwMipMapCount); /* Destroy the surface. */ IDirectDrawSurface_Release(lpDDSMipMapTest); /* Third mipmap creation test: create a surface with DDSCAPS_MIPMAP, DDSCAPS_COMPLEX and without DDSD_MIPMAPCOUNT. It's an undocumented features where a chain of mipmaps, starting from he specified size and down to the smallest size, is automatically created. Anarchy Online needs this feature to work. */ memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; ddsd.dwWidth = 128; ddsd.dwHeight = 32; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); if (FAILED(rc)) { skip("failed to create surface\n"); return; } /* Check the number of created mipmaps */ memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd); ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc); ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT, "GetSurfaceDesc returned no mipmapcount.\n"); ok(U2(ddsd).dwMipMapCount == 6, "Incorrect mipmap count: %d.\n", U2(ddsd).dwMipMapCount); /* Destroy the surface. */ IDirectDrawSurface_Release(lpDDSMipMapTest); /* Fourth mipmap creation test: same as above with a different texture size. The purpose is to verify that the number of generated mipmaps is dependent on the smallest dimension. */ memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; ddsd.dwWidth = 32; ddsd.dwHeight = 64; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); if (FAILED(rc)) { skip("failed to create surface\n"); return; } /* Check the number of created mipmaps */ memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); rc = IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest, &ddsd); ok(rc==DD_OK,"GetSurfaceDesc returned: %x\n",rc); ok(ddsd.dwFlags & DDSD_MIPMAPCOUNT, "GetSurfaceDesc returned no mipmapcount.\n"); ok(U2(ddsd).dwMipMapCount == 6, "Incorrect mipmap count: %d.\n", U2(ddsd).dwMipMapCount); /* Destroy the surface. */ IDirectDrawSurface_Release(lpDDSMipMapTest); /* Fifth mipmap creation test: try to create a surface with DDSCAPS_COMPLEX, DDSCAPS_MIPMAP, DDSD_MIPMAPCOUNT, where dwMipMapCount = 0. This should fail. */ ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; U2(ddsd).dwMipMapCount = 0; ddsd.dwWidth = 128; ddsd.dwHeight = 32; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSMipMapTest, NULL); ok(rc==DDERR_INVALIDPARAMS,"CreateSurface returned: %x\n",rc); /* Destroy the surface. */ if( rc == DD_OK ) IDirectDrawSurface_Release(lpDDSMipMapTest); } static void SrcColorKey32BlitTest(void) { LPDIRECTDRAWSURFACE lpSrc; LPDIRECTDRAWSURFACE lpDst; DDSURFACEDESC ddsd, ddsd2, ddsd3; DDCOLORKEY DDColorKey; LPDWORD lpData; HRESULT rc; DDBLTFX fx; ddsd2.dwSize = sizeof(ddsd2); ddsd2.ddpfPixelFormat.dwSize = sizeof(ddsd2.ddpfPixelFormat); ddsd.dwSize = sizeof(ddsd); ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 800; ddsd.dwHeight = 600; ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDst, NULL); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); if (FAILED(rc)) { skip("failed to create surface\n"); return; } ddsd.dwFlags |= DDSD_CKSRCBLT; ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0xFF00FF; ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0xFF00FF; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSrc, NULL); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); if (FAILED(rc)) { skip("failed to create surface\n"); return; } rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); lpData = ddsd2.lpSurface; lpData[0] = 0xCCCCCCCC; lpData[1] = 0xCCCCCCCC; lpData[2] = 0xCCCCCCCC; lpData[3] = 0xCCCCCCCC; memset(&ddsd3, 0, sizeof(ddsd3)); ddsd3.dwSize = sizeof(ddsd3); ddsd3.ddpfPixelFormat.dwSize = sizeof(ddsd3.ddpfPixelFormat); rc = IDirectDrawSurface_GetSurfaceDesc(lpDst, &ddsd3); ok(rc == DD_OK, "IDirectDrawSurface_GetSurfaceDesc between a lock/unlock pair returned %08x\n", rc); ok(ddsd3.lpSurface == ddsd3.lpSurface, "lpSurface from GetSurfaceDesc(%p) differs from the one returned by Lock(%p)\n", ddsd3.lpSurface, ddsd2.lpSurface); rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); memset(&ddsd3, 0, sizeof(ddsd3)); ddsd3.dwSize = sizeof(ddsd3); ddsd3.ddpfPixelFormat.dwSize = sizeof(ddsd3.ddpfPixelFormat); rc = IDirectDrawSurface_GetSurfaceDesc(lpDst, &ddsd3); ok(rc == DD_OK, "IDirectDrawSurface_GetSurfaceDesc between a lock/unlock pair returned %08x\n", rc); ok(ddsd3.lpSurface == NULL, "lpSurface from GetSurfaceDesc(%p) is not NULL after unlock\n", ddsd3.lpSurface); rc = IDirectDrawSurface_Lock(lpSrc, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; lpData[0] = 0x77010203; lpData[1] = 0x00010203; lpData[2] = 0x77FF00FF; lpData[3] = 0x00FF00FF; rc = IDirectDrawSurface_Unlock(lpSrc, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC, NULL); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; /* Different behavior on some drivers / windows versions. Some versions ignore the X channel when * color keying, but copy it to the destination surface. Others apply it for color keying, but * do not copy it into the destination surface. */ if(lpData[0]==0x00010203) { trace("X channel was not copied into the destination surface\n"); ok((lpData[0]==0x00010203)&&(lpData[1]==0x00010203)&&(lpData[2]==0x00FF00FF)&&(lpData[3]==0xCCCCCCCC), "Destination data after blitting is not correct\n"); } else { ok((lpData[0]==0x77010203)&&(lpData[1]==0x00010203)&&(lpData[2]==0xCCCCCCCC)&&(lpData[3]==0xCCCCCCCC), "Destination data after blitting is not correct\n"); } rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Below we repeat the same test as above but now using BltFast instead of Blt. Before * we can carry out the test we need to restore the color of the destination surface. */ rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); lpData = ddsd2.lpSurface; lpData[0] = 0xCCCCCCCC; lpData[1] = 0xCCCCCCCC; lpData[2] = 0xCCCCCCCC; lpData[3] = 0xCCCCCCCC; rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); IDirectDrawSurface_BltFast(lpDst, 0, 0, lpSrc, NULL, DDBLTFAST_SRCCOLORKEY); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; /* Different behavior on some drivers / windows versions. Some versions ignore the X channel when * color keying, but copy it to the destination surface. Others apply it for color keying, but * do not copy it into the destination surface. */ if(lpData[0]==0x00010203) { trace("X channel was not copied into the destination surface\n"); ok((lpData[0]==0x00010203)&&(lpData[1]==0x00010203)&&(lpData[2]==0x00FF00FF)&&(lpData[3]==0xCCCCCCCC), "Destination data after blitting is not correct\n"); } else { ok((lpData[0]==0x77010203)&&(lpData[1]==0x00010203)&&(lpData[2]==0xCCCCCCCC)&&(lpData[3]==0xCCCCCCCC), "Destination data after blitting is not correct\n"); } rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Also test SetColorKey */ IDirectDrawSurface_GetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); ok(DDColorKey.dwColorSpaceLowValue == 0xFF00FF && DDColorKey.dwColorSpaceHighValue == 0xFF00FF, "GetColorKey does not return the colorkey used at surface creation\n"); DDColorKey.dwColorSpaceLowValue = 0x00FF00; DDColorKey.dwColorSpaceHighValue = 0x00FF00; IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); DDColorKey.dwColorSpaceLowValue = 0; DDColorKey.dwColorSpaceHighValue = 0; IDirectDrawSurface_GetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); ok(DDColorKey.dwColorSpaceLowValue == 0x00FF00 && DDColorKey.dwColorSpaceHighValue == 0x00FF00, "GetColorKey does not return the colorkey set with SetColorKey\n"); ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0; ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0; IDirectDrawSurface_GetSurfaceDesc(lpSrc, &ddsd); ok(ddsd.ddckCKSrcBlt.dwColorSpaceLowValue == 0x00FF00 && ddsd.ddckCKSrcBlt.dwColorSpaceHighValue == 0x00FF00, "GetSurfaceDesc does not return the colorkey set with SetColorKey\n"); /* Test SetColorKey with dwColorSpaceHighValue < dwColorSpaceLowValue */ DDColorKey.dwColorSpaceLowValue = 0x0000FF; DDColorKey.dwColorSpaceHighValue = 0x000000; IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); DDColorKey.dwColorSpaceLowValue = 0; DDColorKey.dwColorSpaceHighValue = 0; IDirectDrawSurface_GetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); ok(DDColorKey.dwColorSpaceLowValue == 0x0000FF && DDColorKey.dwColorSpaceHighValue == 0x0000FF, "GetColorKey does not return the colorkey set with SetColorKey (%x %x)\n", DDColorKey.dwColorSpaceLowValue, DDColorKey.dwColorSpaceHighValue); DDColorKey.dwColorSpaceLowValue = 0x0000FF; DDColorKey.dwColorSpaceHighValue = 0x000001; IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); DDColorKey.dwColorSpaceLowValue = 0; DDColorKey.dwColorSpaceHighValue = 0; IDirectDrawSurface_GetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); ok(DDColorKey.dwColorSpaceLowValue == 0x0000FF && DDColorKey.dwColorSpaceHighValue == 0x0000FF, "GetColorKey does not return the colorkey set with SetColorKey (%x %x)\n", DDColorKey.dwColorSpaceLowValue, DDColorKey.dwColorSpaceHighValue); DDColorKey.dwColorSpaceLowValue = 0x0000FF; DDColorKey.dwColorSpaceHighValue = 0x0000FE; IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); DDColorKey.dwColorSpaceLowValue = 0; DDColorKey.dwColorSpaceHighValue = 0; IDirectDrawSurface_GetColorKey(lpSrc, DDCKEY_SRCBLT, &DDColorKey); ok(DDColorKey.dwColorSpaceLowValue == 0x0000FF && DDColorKey.dwColorSpaceHighValue == 0x0000FF, "GetColorKey does not return the colorkey set with SetColorKey (%x %x)\n", DDColorKey.dwColorSpaceLowValue, DDColorKey.dwColorSpaceHighValue); IDirectDrawSurface_Release(lpSrc); IDirectDrawSurface_Release(lpDst); /* start with a new set of surfaces to test the color keying parameters to blit */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT | DDSD_CKDESTBLT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 800; ddsd.dwHeight = 600; ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF; ddsd.ddckCKDestBlt.dwColorSpaceLowValue = 0xFF0000; ddsd.ddckCKDestBlt.dwColorSpaceHighValue = 0xFF0000; ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0x00FF00; ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0x00FF00; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDst, NULL); ok(rc==DD_OK || rc == DDERR_NOCOLORKEYHW,"CreateSurface returned: %x\n",rc); if(FAILED(rc)) { skip("Failed to create surface\n"); return; } /* start with a new set of surfaces to test the color keying parameters to blit */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT | DDSD_CKDESTBLT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 800; ddsd.dwHeight = 600; ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF; ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0x0000FF; ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0x0000FF; ddsd.ddckCKDestBlt.dwColorSpaceLowValue = 0x000000; ddsd.ddckCKDestBlt.dwColorSpaceHighValue = 0x000000; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSrc, NULL); ok(rc==DD_OK || rc == DDERR_NOCOLORKEYHW,"CreateSurface returned: %x\n",rc); if(FAILED(rc)) { skip("Failed to create surface\n"); IDirectDrawSurface_Release(lpDst); return; } memset(&fx, 0, sizeof(fx)); fx.dwSize = sizeof(fx); fx.ddckSrcColorkey.dwColorSpaceHighValue = 0x110000; fx.ddckSrcColorkey.dwColorSpaceLowValue = 0x110000; fx.ddckDestColorkey.dwColorSpaceHighValue = 0x001100; fx.ddckDestColorkey.dwColorSpaceLowValue = 0x001100; rc = IDirectDrawSurface_Lock(lpSrc, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; lpData[0] = 0x000000FF; /* Applies to src blt key in src surface */ lpData[1] = 0x00000000; /* Applies to dst blt key in src surface */ lpData[2] = 0x00FF0000; /* Dst color key in dst surface */ lpData[3] = 0x0000FF00; /* Src color key in dst surface */ lpData[4] = 0x00001100; /* Src color key in ddbltfx */ lpData[5] = 0x00110000; /* Dst color key in ddbltfx */ rc = IDirectDrawSurface_Unlock(lpSrc, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; lpData[0] = 0x55555555; lpData[1] = 0x55555555; lpData[2] = 0x55555555; lpData[3] = 0x55555555; lpData[4] = 0x55555555; lpData[5] = 0x55555555; rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Test a blit without keying */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, 0, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; /* Should have copied src data unmodified to dst */ ok(lpData[0] == 0x000000FF && lpData[1] == 0x00000000 && lpData[2] == 0x00FF0000 && lpData[3] == 0x0000FF00 && lpData[4] == 0x00001100 && lpData[5] == 0x00110000, "Surface data after unkeyed blit does not match\n"); lpData[0] = 0x55555555; lpData[1] = 0x55555555; lpData[2] = 0x55555555; lpData[3] = 0x55555555; lpData[4] = 0x55555555; lpData[5] = 0x55555555; rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Src key */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; ok(lpData[0] == 0x55555555 && /* Here the src key applied */ lpData[1] == 0x00000000 && lpData[2] == 0x00FF0000 && lpData[3] == 0x0000FF00 && lpData[4] == 0x00001100 && lpData[5] == 0x00110000, "Surface data after srckey blit does not match\n"); lpData[0] = 0x55555555; lpData[1] = 0x55555555; lpData[2] = 0x55555555; lpData[3] = 0x55555555; lpData[4] = 0x55555555; lpData[5] = 0x55555555; rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Src override */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRCOVERRIDE, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; ok(lpData[0] == 0x000000FF && lpData[1] == 0x00000000 && lpData[2] == 0x00FF0000 && lpData[3] == 0x0000FF00 && lpData[4] == 0x00001100 && lpData[5] == 0x55555555, /* Override key applies here */ "Surface data after src override key blit does not match\n"); lpData[0] = 0x55555555; lpData[1] = 0x55555555; lpData[2] = 0x55555555; lpData[3] = 0x55555555; lpData[4] = 0x55555555; lpData[5] = 0x55555555; rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Src override AND src key. That is not supposed to work */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC | DDBLT_KEYSRCOVERRIDE, &fx); ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc); /* Verify that the destination is unchanged */ rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; ok(lpData[0] == 0x55555555 && lpData[1] == 0x55555555 && lpData[2] == 0x55555555 && lpData[3] == 0x55555555 && lpData[4] == 0x55555555 && lpData[5] == 0x55555555, /* Override key applies here */ "Surface data after src key blit with override does not match\n"); lpData[0] = 0x00FF0000; /* Dest key in dst surface */ lpData[1] = 0x00FF0000; /* Dest key in dst surface */ lpData[2] = 0x00001100; /* Dest key in override */ lpData[3] = 0x00001100; /* Dest key in override */ lpData[4] = 0x00000000; /* Dest key in src surface */ lpData[5] = 0x00000000; /* Dest key in src surface */ rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Dest key blit */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; /* DirectDraw uses the dest blit key from the SOURCE surface ! */ ok(lpData[0] == 0x00ff0000 && lpData[1] == 0x00ff0000 && lpData[2] == 0x00001100 && lpData[3] == 0x00001100 && lpData[4] == 0x00001100 && /* Key applies here */ lpData[5] == 0x00110000, /* Key applies here */ "Surface data after dest key blit does not match\n"); lpData[0] = 0x00FF0000; /* Dest key in dst surface */ lpData[1] = 0x00FF0000; /* Dest key in dst surface */ lpData[2] = 0x00001100; /* Dest key in override */ lpData[3] = 0x00001100; /* Dest key in override */ lpData[4] = 0x00000000; /* Dest key in src surface */ lpData[5] = 0x00000000; /* Dest key in src surface */ rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Dest override key blit */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDESTOVERRIDE, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; ok(lpData[0] == 0x00FF0000 && lpData[1] == 0x00FF0000 && lpData[2] == 0x00FF0000 && /* Key applies here */ lpData[3] == 0x0000FF00 && /* Key applies here */ lpData[4] == 0x00000000 && lpData[5] == 0x00000000, "Surface data after dest key override blit does not match\n"); lpData[0] = 0x00FF0000; /* Dest key in dst surface */ lpData[1] = 0x00FF0000; /* Dest key in dst surface */ lpData[2] = 0x00001100; /* Dest key in override */ lpData[3] = 0x00001100; /* Dest key in override */ lpData[4] = 0x00000000; /* Dest key in src surface */ lpData[5] = 0x00000000; /* Dest key in src surface */ rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Dest override key blit. Supposed to fail too */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST | DDBLT_KEYDESTOVERRIDE, &fx); ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc); /* Check for unchanged data */ rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; ok(lpData[0] == 0x00FF0000 && lpData[1] == 0x00FF0000 && lpData[2] == 0x00001100 && /* Key applies here */ lpData[3] == 0x00001100 && /* Key applies here */ lpData[4] == 0x00000000 && lpData[5] == 0x00000000, "Surface data with dest key and dest override does not match\n"); lpData[0] = 0x00FF0000; /* Dest key in dst surface */ lpData[1] = 0x00FF0000; /* Dest key in dst surface */ lpData[2] = 0x00001100; /* Dest key in override */ lpData[3] = 0x00001100; /* Dest key in override */ lpData[4] = 0x00000000; /* Dest key in src surface */ lpData[5] = 0x00000000; /* Dest key in src surface */ rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Modify the source data a bit to give some more conclusive results */ rc = IDirectDrawSurface_Lock(lpSrc, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; lpData[5] = 0x000000FF; /* Applies to src blt key in src surface */ rc = IDirectDrawSurface_Unlock(lpSrc, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Source and destination key */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST | DDBLT_KEYSRC, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Lock(lpDst, NULL, &ddsd2, DDLOCK_WAIT, NULL); ok(rc==DD_OK,"Lock returned: %x\n",rc); ok((ddsd2.dwFlags & DDSD_LPSURFACE) == 0, "Surface desc has LPSURFACE Flags set\n"); lpData = ddsd2.lpSurface; ok(lpData[0] == 0x00FF0000 && /* Masked by Destination key */ lpData[1] == 0x00FF0000 && /* Masked by Destination key */ lpData[2] == 0x00001100 && /* Masked by Destination key */ lpData[3] == 0x00001100 && /* Masked by Destination key */ lpData[4] == 0x00001100 && /* Allowed by destination key, not masked by source key */ lpData[5] == 0x00000000, /* Allowed by dst key, but masked by source key */ "Surface data with src key and dest key blit does not match\n"); lpData[0] = 0x00FF0000; /* Dest key in dst surface */ lpData[1] = 0x00FF0000; /* Dest key in dst surface */ lpData[2] = 0x00001100; /* Dest key in override */ lpData[3] = 0x00001100; /* Dest key in override */ lpData[4] = 0x00000000; /* Dest key in src surface */ lpData[5] = 0x00000000; /* Dest key in src surface */ rc = IDirectDrawSurface_Unlock(lpDst, NULL); ok(rc==DD_OK,"Unlock returned: %x\n",rc); /* Override keys without ddbltfx parameter fail */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDESTOVERRIDE, NULL); ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRCOVERRIDE, NULL); ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc); /* Try blitting without keys in the source surface*/ rc = IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_SRCBLT, NULL); ok(rc == DD_OK, "SetColorKey returned %x\n", rc); rc = IDirectDrawSurface_SetColorKey(lpSrc, DDCKEY_DESTBLT, NULL); ok(rc == DD_OK, "SetColorKey returned %x\n", rc); /* That fails now. Do not bother to check that the data is unmodified */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRC, &fx); ok(rc == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned %08x\n", rc); /* Dest key blit still works. Which key is used this time??? */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDEST, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); /* With correctly passed override keys no key in the surface is needed. * Again, the result was checked before, no need to do that again */ rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYDESTOVERRIDE, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); rc = IDirectDrawSurface_Blt(lpDst, NULL, lpSrc, NULL, DDBLT_KEYSRCOVERRIDE, &fx); ok(rc == DD_OK, "IDirectDrawSurface_Blt returned %08x\n", rc); IDirectDrawSurface_Release(lpSrc); IDirectDrawSurface_Release(lpDst); } static void QueryInterface(void) { LPDIRECTDRAWSURFACE dsurface; DDSURFACEDESC surface; LPVOID object; HRESULT ret; /* Create a surface */ ZeroMemory(&surface, sizeof(surface)); surface.dwSize = sizeof(surface); surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; surface.dwHeight = 10; surface.dwWidth = 10; ret = IDirectDraw_CreateSurface(lpDD, &surface, &dsurface, NULL); if(ret != DD_OK) { ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret); return; } /* Call IUnknown::QueryInterface */ ret = IDirectDrawSurface_QueryInterface(dsurface, 0, &object); ok(ret == DDERR_INVALIDPARAMS, "IDirectDrawSurface::QueryInterface returned %x\n", ret); IDirectDrawSurface_Release(dsurface); } /* The following tests test which interface is returned by IDirectDrawSurfaceX::GetDDInterface. * It uses refcounts to test that and compares the interface addresses. Partially fits here, and * partially in the refcount test */ static ULONG getref(IUnknown *iface) { IUnknown_AddRef(iface); return IUnknown_Release(iface); } static void GetDDInterface_1(void) { LPDIRECTDRAWSURFACE dsurface; LPDIRECTDRAWSURFACE2 dsurface2; DDSURFACEDESC surface; HRESULT ret; IDirectDraw2 *dd2; IDirectDraw4 *dd4; IDirectDraw7 *dd7; ULONG ref1, ref2, ref4, ref7; void *dd; /* Create a surface */ ZeroMemory(&surface, sizeof(surface)); surface.dwSize = sizeof(surface); surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; surface.dwHeight = 10; surface.dwWidth = 10; ret = IDirectDraw_CreateSurface(lpDD, &surface, &dsurface, NULL); if(ret != DD_OK) { ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret); return; } ret = IDirectDrawSurface_QueryInterface(dsurface, &IID_IDirectDrawSurface2, (void **) &dsurface2); ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ref1 = getref((IUnknown *) lpDD); ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1); ref2 = getref((IUnknown *) dd2); ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2); ref4 = getref((IUnknown *) dd4); ok(ref4 == 1, "IDirectDraw4 refcount is %d\n", ref4); ref7 = getref((IUnknown *) dd7); ok(ref7 == 1, "IDirectDraw7 refcount is %d\n", ref7); ret = IDirectDrawSurface2_GetDDInterface(dsurface2, &dd); ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret); ok(getref((IUnknown *) lpDD) == ref1 + 1, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1); ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2); ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4); ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7); ok(dd == lpDD, "Returned interface pointer is not equal to the creation interface\n"); IUnknown_Release((IUnknown *) dd); /* try a NULL pointer */ ret = IDirectDrawSurface2_GetDDInterface(dsurface2, NULL); ok(ret == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret); IDirectDraw_Release(dd2); IDirectDraw_Release(dd4); IDirectDraw_Release(dd7); IDirectDrawSurface2_Release(dsurface2); IDirectDrawSurface_Release(dsurface); } static void GetDDInterface_2(void) { LPDIRECTDRAWSURFACE dsurface; LPDIRECTDRAWSURFACE2 dsurface2; DDSURFACEDESC surface; HRESULT ret; IDirectDraw2 *dd2; IDirectDraw4 *dd4; IDirectDraw7 *dd7; ULONG ref1, ref2, ref4, ref7; void *dd; ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); /* Create a surface */ ZeroMemory(&surface, sizeof(surface)); surface.dwSize = sizeof(surface); surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; surface.dwHeight = 10; surface.dwWidth = 10; ret = IDirectDraw2_CreateSurface(dd2, &surface, &dsurface, NULL); if(ret != DD_OK) { ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret); return; } ret = IDirectDrawSurface_QueryInterface(dsurface, &IID_IDirectDrawSurface2, (void **) &dsurface2); ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret); ref1 = getref((IUnknown *) lpDD); ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1); ref2 = getref((IUnknown *) dd2); ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2); ref4 = getref((IUnknown *) dd4); ok(ref4 == 1, "IDirectDraw4 refcount is %d\n", ref4); ref7 = getref((IUnknown *) dd7); ok(ref7 == 1, "IDirectDraw7 refcount is %d\n", ref7); ret = IDirectDrawSurface2_GetDDInterface(dsurface2, &dd); ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret); ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1); ok(getref((IUnknown *) dd2) == ref2 + 1, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2); ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4); ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7); ok(dd == dd2, "Returned interface pointer is not equal to the creation interface\n"); IUnknown_Release((IUnknown *) dd); IDirectDraw_Release(dd2); IDirectDraw_Release(dd4); IDirectDraw_Release(dd7); IDirectDrawSurface2_Release(dsurface2); IDirectDrawSurface_Release(dsurface); } static void GetDDInterface_4(void) { LPDIRECTDRAWSURFACE2 dsurface2; LPDIRECTDRAWSURFACE4 dsurface4; DDSURFACEDESC2 surface; HRESULT ret; IDirectDraw2 *dd2; IDirectDraw4 *dd4; IDirectDraw7 *dd7; ULONG ref1, ref2, ref4, ref7; void *dd; ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); /* Create a surface */ ZeroMemory(&surface, sizeof(surface)); surface.dwSize = sizeof(surface); surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; surface.dwHeight = 10; surface.dwWidth = 10; ret = IDirectDraw4_CreateSurface(dd4, &surface, &dsurface4, NULL); if(ret != DD_OK) { ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret); return; } ret = IDirectDrawSurface4_QueryInterface(dsurface4, &IID_IDirectDrawSurface2, (void **) &dsurface2); ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret); ref1 = getref((IUnknown *) lpDD); ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1); ref2 = getref((IUnknown *) dd2); ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2); ref4 = getref((IUnknown *) dd4); ok(ref4 == 2, "IDirectDraw4 refcount is %d\n", ref4); ref7 = getref((IUnknown *) dd7); ok(ref7 == 1, "IDirectDraw7 refcount is %d\n", ref7); ret = IDirectDrawSurface4_GetDDInterface(dsurface4, &dd); ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret); ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1); ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2); ok(getref((IUnknown *) dd4) == ref4 + 1, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4); ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7); ok(dd == dd4, "Returned interface pointer is not equal to the creation interface\n"); IUnknown_Release((IUnknown *) dd); /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */ ret = IDirectDrawSurface2_GetDDInterface(dsurface2, &dd); ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret); ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1); ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2); ok(getref((IUnknown *) dd4) == ref4 + 1, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4); ok(getref((IUnknown *) dd7) == ref7 + 0, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7); ok(dd == dd4, "Returned interface pointer is not equal to the creation interface\n"); IUnknown_Release((IUnknown *) dd); IDirectDraw_Release(dd2); IDirectDraw_Release(dd4); IDirectDraw_Release(dd7); IDirectDrawSurface4_Release(dsurface4); IDirectDrawSurface2_Release(dsurface2); } static void GetDDInterface_7(void) { LPDIRECTDRAWSURFACE4 dsurface4; LPDIRECTDRAWSURFACE7 dsurface7; DDSURFACEDESC2 surface; HRESULT ret; IDirectDraw2 *dd2; IDirectDraw4 *dd4; IDirectDraw7 *dd7; ULONG ref1, ref2, ref4, ref7; void *dd; ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(ret == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", ret); /* Create a surface */ ZeroMemory(&surface, sizeof(surface)); surface.dwSize = sizeof(surface); surface.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; surface.dwHeight = 10; surface.dwWidth = 10; ret = IDirectDraw7_CreateSurface(dd7, &surface, &dsurface7, NULL); if(ret != DD_OK) { ok(FALSE, "IDirectDraw::CreateSurface failed with error %x\n", ret); return; } ret = IDirectDrawSurface7_QueryInterface(dsurface7, &IID_IDirectDrawSurface4, (void **) &dsurface4); ok(ret == DD_OK, "IDirectDrawSurface_QueryInterface returned %08x\n", ret); ref1 = getref((IUnknown *) lpDD); ok(ref1 == 1, "IDirectDraw refcount is %d\n", ref1); ref2 = getref((IUnknown *) dd2); ok(ref2 == 1, "IDirectDraw2 refcount is %d\n", ref2); ref4 = getref((IUnknown *) dd4); ok(ref4 == 1, "IDirectDraw4 refcount is %d\n", ref4); ref7 = getref((IUnknown *) dd7); ok(ref7 == 2, "IDirectDraw7 refcount is %d\n", ref7); ret = IDirectDrawSurface7_GetDDInterface(dsurface7, &dd); ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret); ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1); ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2); ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4); ok(getref((IUnknown *) dd7) == ref7 + 1, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7); ok(dd == dd7, "Returned interface pointer is not equal to the creation interface\n"); IUnknown_Release((IUnknown *) dd); /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */ ret = IDirectDrawSurface4_GetDDInterface(dsurface4, &dd); ok(ret == DD_OK, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret); ok(getref((IUnknown *) lpDD) == ref1 + 0, "IDirectDraw refcount was increased by %d\n", getref((IUnknown *) lpDD) - ref1); ok(getref((IUnknown *) dd2) == ref2 + 0, "IDirectDraw2 refcount was increased by %d\n", getref((IUnknown *) dd2) - ref2); ok(getref((IUnknown *) dd4) == ref4 + 0, "IDirectDraw4 refcount was increased by %d\n", getref((IUnknown *) dd4) - ref4); ok(getref((IUnknown *) dd7) == ref7 + 1, "IDirectDraw7 refcount was increased by %d\n", getref((IUnknown *) dd7) - ref7); ok(dd == dd7, "Returned interface pointer is not equal to the creation interface\n"); IUnknown_Release((IUnknown *) dd); IDirectDraw_Release(dd2); IDirectDraw_Release(dd4); IDirectDraw_Release(dd7); IDirectDrawSurface4_Release(dsurface4); IDirectDrawSurface7_Release(dsurface7); } static ULONG getRefcount(IUnknown *iface) { IUnknown_AddRef(iface); return IUnknown_Release(iface); } #define MAXEXPECTED 8 /* Can match up to 8 expected surfaces */ struct enumstruct { IDirectDrawSurface *expected[MAXEXPECTED]; UINT count; }; static HRESULT WINAPI enumCB(IDirectDrawSurface *surf, DDSURFACEDESC *desc, void *ctx) { int i; BOOL found = FALSE; for(i = 0; i < MAXEXPECTED; i++) { if(((struct enumstruct *)ctx)->expected[i] == surf) found = TRUE; } ok(found, "Unexpected surface %p enumerated\n", surf); ((struct enumstruct *)ctx)->count++; IDirectDrawSurface_Release(surf); return DDENUMRET_OK; } static void EnumTest(void) { HRESULT rc; DDSURFACEDESC ddsd; IDirectDrawSurface *surface; struct enumstruct ctx; ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; U2(ddsd).dwMipMapCount = 3; ddsd.dwWidth = 32; ddsd.dwHeight = 32; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); memset(&ctx, 0, sizeof(ctx)); ctx.expected[0] = surface; rc = IDirectDrawSurface_GetAttachedSurface(ctx.expected[0], &ddsd.ddsCaps, &ctx.expected[1]); ok(rc == DD_OK, "GetAttachedSurface returned %08x\n", rc); rc = IDirectDrawSurface_GetAttachedSurface(ctx.expected[1], &ddsd.ddsCaps, &ctx.expected[2]); ok(rc == DD_OK, "GetAttachedSurface returned %08x\n", rc); rc = IDirectDrawSurface_GetAttachedSurface(ctx.expected[2], &ddsd.ddsCaps, &ctx.expected[3]); ok(rc == DDERR_NOTFOUND, "GetAttachedSurface returned %08x\n", rc); ok(!ctx.expected[3], "expected NULL pointer\n"); ctx.count = 0; rc = IDirectDraw_EnumSurfaces(lpDD, DDENUMSURFACES_DOESEXIST | DDENUMSURFACES_ALL, &ddsd, &ctx, enumCB); ok(rc == DD_OK, "IDirectDraw_EnumSurfaces returned %08x\n", rc); ok(ctx.count == 3, "%d surfaces enumerated, expected 3\n", ctx.count); ctx.count = 0; rc = IDirectDraw_EnumSurfaces(lpDD, DDENUMSURFACES_DOESEXIST | DDENUMSURFACES_ALL, NULL, &ctx, enumCB); ok(rc == DD_OK, "IDirectDraw_EnumSurfaces returned %08x\n", rc); ok(ctx.count == 3, "%d surfaces enumerated, expected 3\n", ctx.count); IDirectDrawSurface_Release(ctx.expected[2]); IDirectDrawSurface_Release(ctx.expected[1]); IDirectDrawSurface_Release(surface); } static HRESULT WINAPI SurfaceCounter(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context) { UINT *num = context; (*num)++; IDirectDrawSurface_Release(surface); return DDENUMRET_OK; } static void AttachmentTest7(void) { HRESULT hr; IDirectDraw7 *dd7; IDirectDrawSurface7 *surface1, *surface2, *surface3, *surface4; IDirectDrawSurface *surface1v1, *surface2v1; DDSURFACEDESC2 ddsd, ddsd2; DWORD ref; UINT num; DDSCAPS2 caps = {DDSCAPS_TEXTURE, 0, 0, 0}, caps2 = {DDSCAPS_BACKBUFFER,0,0,0}; HWND window = CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL ); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; U2(ddsd).dwMipMapCount = 3; /* Will create 128x128, 64x64, 32x32 */ ddsd.dwWidth = 128; ddsd.dwHeight = 128; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); /* ROOT */ num = 0; IDirectDrawSurface7_EnumAttachedSurfaces(surface1, &num, SurfaceCounter); ok(num == 1, "Mipmap root has %d surfaces attached, expected 1\n", num); /* DONE ROOT */ /* LEVEL 1 */ hr = IDirectDrawSurface7_GetAttachedSurface(surface1, &caps, &surface2); ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr); num = 0; IDirectDrawSurface7_EnumAttachedSurfaces(surface2, &num, SurfaceCounter); ok(num == 1, "First mip level has %d surfaces attached, expected 1\n", num); /* DONE LEVEL 1 */ /* LEVEL 2 */ hr = IDirectDrawSurface7_GetAttachedSurface(surface2, &caps, &surface3); ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr); IDirectDrawSurface7_Release(surface2); num = 0; IDirectDrawSurface7_EnumAttachedSurfaces(surface3, &num, SurfaceCounter); ok(num == 0, "Second mip level has %d surfaces attached, expected 1\n", num); /* Done level 2 */ /* Mip level 3 is still needed */ hr = IDirectDrawSurface7_GetAttachedSurface(surface3, &caps, &surface4); ok(hr == DDERR_NOTFOUND, "GetAttachedSurface returned %08x\n", hr); ok(!surface4, "expected NULL pointer\n"); /* Try to attach a 16x16 miplevel - Should not work as far I can see */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE; ddsd.dwWidth = 16; ddsd.dwHeight = 16; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface1); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface2); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface3); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr); IDirectDrawSurface7_Release(surface2); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 16; ddsd.dwHeight = 16; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface1); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface2); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface3); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr); IDirectDrawSurface7_Release(surface3); IDirectDrawSurface7_Release(surface2); IDirectDrawSurface7_Release(surface1); hr = IDirectDraw7_SetCooperativeLevel(dd7, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_BACKBUFFERCOUNT | DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; ddsd.dwBackBufferCount = 2; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); /* backbuffer surfaces must not have dwBackBufferCount set */ ddsd2.dwSize = sizeof(ddsd2); hr = IDirectDrawSurface7_GetAttachedSurface(surface1, &caps2, &surface2); ok(hr==DD_OK,"GetAttachedSurface returned: %x\n", hr); hr = IDirectDrawSurface7_GetSurfaceDesc(surface2, &ddsd2); ok(hr==DD_OK,"GetSurfaceDesc returned: %x\n", hr); ok(ddsd2.dwBackBufferCount==0,"backbuffer surface has dwBackBufferCount==%u\n", ddsd2.dwBackBufferCount); num = 0; IDirectDrawSurface7_EnumAttachedSurfaces(surface1, &num, SurfaceCounter); ok(num == 1, "Primary surface has %d surfaces attached, expected 1\n", num); IDirectDrawSurface7_Release(surface1); /* Those are some invalid descriptions, no need to test attachments with them */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL); ok(hr==DDERR_INVALIDCAPS,"CreateSurface returned: %x\n",hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL); ok(hr==DDERR_INVALIDCAPS,"CreateSurface returned: %x\n",hr); /* Try a single primary and two offscreen plain surfaces */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN); ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface2, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN); ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface3, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); /* This one has a different size */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 128; ddsd.dwHeight = 128; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface4, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface1); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface3); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface4); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface1); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr); IDirectDrawSurface7_Release(surface4); IDirectDrawSurface7_Release(surface3); IDirectDrawSurface7_Release(surface2); IDirectDrawSurface7_Release(surface1); /* Test DeleteAttachedSurface and automatic detachment of attached surfaces on release */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.dwWidth = 64; ddsd.dwHeight = 64; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE; U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB; /* D3DFMT_R5G6B5 */ U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16; U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800; U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0; U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F; memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd2.dwWidth = ddsd.dwWidth; ddsd2.dwHeight = ddsd.dwHeight; ddsd2.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); U4(ddsd2).ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; U1(U4(ddsd2).ddpfPixelFormat).dwZBufferBitDepth = 16; U3(U4(ddsd2).ddpfPixelFormat).dwZBitMask = 0x0000FFFF; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface1, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDraw7_CreateSurface(dd7, &ddsd2, &surface2, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_QueryInterface(surface1, &IID_IDirectDrawSurface, (void **)&surface1v1); ok(hr == DD_OK, "IDirectDrawSurface7_QueryInterface returned %08x\n", hr); hr = IDirectDrawSurface7_QueryInterface(surface2, &IID_IDirectDrawSurface, (void **)&surface2v1); ok(hr == DD_OK, "IDirectDrawSurface7_QueryInterface returned %08x\n", hr); /* DeleteAttachedSurface when attaching via IDirectDrawSurface7 */ hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2); ok(hr == DD_OK, "AddAttachedSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { ref = getRefcount((IUnknown *)surface2); ok(ref == 2, "Got refcount %d, expected 2\n", ref); ref = getRefcount((IUnknown *)surface2v1); ok(ref == 1, "Got refcount %d, expected 1\n", ref); /* Try reattach */ hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface2); ok(hr == DDERR_SURFACEALREADYATTACHED, "AddAttachedSurface returned %08x\n", hr); /* Attachment / detachment on another interface */ hr = IDirectDrawSurface_AddAttachedSurface(surface1v1, surface2v1); todo_wine ok(hr == DDERR_CANNOTATTACHSURFACE, "AddAttachedSurface returned %08x\n", hr); hr = IDirectDrawSurface_DeleteAttachedSurface(surface1v1, 0, surface2v1); ok(hr == DDERR_SURFACENOTATTACHED, "DeleteAttachedSurface returned %08x\n", hr); /* Attaching while already attached to other surface */ hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface3, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface2); todo_wine ok(hr == DD_OK, "AddAttachedSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_DeleteAttachedSurface(surface3, 0, surface2); ok(hr == DD_OK, "DeleteAttachedSurface returned %08x\n", hr); } IDirectDrawSurface7_Release(surface3); } hr = IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface2); ok(hr == DD_OK, "DeleteAttachedSurface returned %08x\n", hr); ref = getRefcount((IUnknown *)surface2); ok(ref == 1, "Got refcount %d, expected 1\n", ref); ref = getRefcount((IUnknown *)surface2v1); ok(ref == 1, "Got refcount %d, expected 1\n", ref); } /* DeleteAttachedSurface when attaching via IDirectDrawSurface */ hr = IDirectDrawSurface_AddAttachedSurface(surface1v1, surface2v1); ok(hr == DD_OK, "AddAttachedSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface2); ok(hr == DDERR_SURFACENOTATTACHED, "DeleteAttachedSurface returned %08x\n", hr); hr = IDirectDrawSurface_DeleteAttachedSurface(surface1v1, 0, surface2v1); ok(hr == DD_OK, "DeleteAttachedSurface returned %08x\n", hr); } ref = IDirectDrawSurface7_Release(surface2); ok(!ref, "Got refcount %d, expected 0\n", ref); ref = IDirectDrawSurface7_Release(surface1); ok(!ref, "Got refcount %d, expected 0\n", ref); /* Automatic detachment on release */ hr = IDirectDrawSurface_AddAttachedSurface(surface1v1, surface2v1); ok(hr == DD_OK, "AddAttachedSurface returned %08x\n", hr); ref = getRefcount((IUnknown *)surface2v1); ok(ref == 2, "Got refcount %d, expected 2\n", ref); ref = IDirectDrawSurface_Release(surface1v1); ok(!ref, "Got refcount %d, expected 0\n", ref); ref = getRefcount((IUnknown *)surface2v1); ok(ref == 1, "Got refcount %d, expected 1\n", ref); ref = IDirectDrawSurface_Release(surface2v1); ok(!ref, "Got refcount %d, expected 0\n", ref); } else IDirectDrawSurface7_Release(surface1); } hr =IDirectDraw7_SetCooperativeLevel(dd7, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr); IDirectDraw7_Release(dd7); } static void AttachmentTest(void) { HRESULT hr; IDirectDrawSurface *surface1, *surface2, *surface3, *surface4; DDSURFACEDESC ddsd, ddsd2; DWORD ref; DDSCAPS caps = {DDSCAPS_TEXTURE}; BOOL refrast = FALSE; HWND window = CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL ); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_MIPMAPCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; U2(ddsd).dwMipMapCount = 3; /* Will create 128x128, 64x64, 32x32 */ ddsd.dwWidth = 128; ddsd.dwHeight = 128; hr = IDirectDraw7_CreateSurface(lpDD, &ddsd, &surface1, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); hr = IDirectDrawSurface7_GetAttachedSurface(surface1, &caps, &surface2); ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr); hr = IDirectDrawSurface7_GetAttachedSurface(surface2, &caps, &surface3); ok(hr == DD_OK, "GetAttachedSurface returned %08x\n", hr); /* Try to attach a 16x16 miplevel - Should not work as far I can see */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE; ddsd.dwWidth = 16; ddsd.dwHeight = 16; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface4, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface4); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface1); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface4); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface3); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface4); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 surface to a 64x64 texture sublevel returned %08x\n", hr); hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface2); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 64x64 texture sublevel to a 16x16 texture returned %08x\n", hr); IDirectDrawSurface7_Release(surface4); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 16; ddsd.dwHeight = 16; hr = IDirectDraw7_CreateSurface(lpDD, &ddsd, &surface4, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); if (SUCCEEDED(IDirectDrawSurface7_AddAttachedSurface(surface1, surface4))) { IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface4); refrast = TRUE; } hr = IDirectDrawSurface7_AddAttachedSurface(surface1, surface4); /* Succeeds on refrast */ if (refrast) ok(hr == S_OK, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr); else ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface4); hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface1); /* Succeeds on refrast */ if (refrast) ok(hr == S_OK, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr); else ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface1, 0, surface1); hr = IDirectDrawSurface7_AddAttachedSurface(surface3, surface4); /* Succeeds on refrast */ if (refrast) ok(hr == S_OK, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr); else ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface3, 0, surface4); hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface3); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface4, 0, surface3); hr = IDirectDrawSurface7_AddAttachedSurface(surface2, surface4); /* Succeeds on refrast */ if (refrast) ok(hr == S_OK, "Attaching a 16x16 offscreen plain surface to a 64x64 texture sublevel returned %08x\n", hr); else ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 16x16 offscreen plain surface to a 64x64 texture sublevel returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface2, 0, surface4); hr = IDirectDrawSurface7_AddAttachedSurface(surface4, surface2); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a 64x64 texture sublevel to a 16x16 offscreen plain surface returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_DeleteAttachedSurface(surface4, 0, surface2); IDirectDrawSurface7_Release(surface4); IDirectDrawSurface7_Release(surface3); IDirectDrawSurface7_Release(surface2); IDirectDrawSurface7_Release(surface1); hr = IDirectDraw_SetCooperativeLevel(lpDD, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr); /* Creating a back buffer as-is, is not allowed. No need to perform attachment tests */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface2, NULL); ok(hr==DDERR_INVALIDCAPS,"CreateSurface returned: %x\n",hr); /* This old ddraw version happily creates explicit front buffers */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface1, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); IDirectDrawSurface_Release(surface1); /* Try a single primary and two offscreen plain surfaces */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface1, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN); ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN); hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface2, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN); ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN); hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface3, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); /* This one has a different size */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 128; ddsd.dwHeight = 128; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface4, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface2); ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE), "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr); if(SUCCEEDED(hr)) { /* Try the reverse without detaching first */ hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface1); ok(hr == DDERR_SURFACEALREADYATTACHED, "Attaching an attached surface to its attachee returned %08x\n", hr); hr = IDirectDrawSurface_DeleteAttachedSurface(surface1, 0, surface2); ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr); } hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface1); ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE), "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr); if(SUCCEEDED(hr)) { /* Try to detach reversed */ hr = IDirectDrawSurface_DeleteAttachedSurface(surface1, 0, surface2); ok(hr == DDERR_CANNOTDETACHSURFACE, "DeleteAttachedSurface returned %08x\n", hr); /* Now the proper detach */ hr = IDirectDrawSurface_DeleteAttachedSurface(surface2, 0, surface1); ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr); } hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface3); /* Fails on refrast */ ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE), "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr); if(SUCCEEDED(hr)) { hr = IDirectDrawSurface_DeleteAttachedSurface(surface2, 0, surface3); ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr); } hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface4); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr); hr = IDirectDrawSurface_AddAttachedSurface(surface4, surface1); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr); IDirectDrawSurface_Release(surface4); IDirectDrawSurface_Release(surface3); IDirectDrawSurface_Release(surface2); IDirectDrawSurface_Release(surface1); /* Test DeleteAttachedSurface and automatic detachment of attached surfaces on release */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.dwWidth = 64; ddsd.dwHeight = 64; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; /* D3DFMT_R5G6B5 */ U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 16; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xF800; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x07E0; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x001F; memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd2.dwWidth = ddsd.dwWidth; ddsd2.dwHeight = ddsd.dwHeight; ddsd2.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; ddsd2.ddpfPixelFormat.dwSize = sizeof(ddsd2.ddpfPixelFormat); ddsd2.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; U1(ddsd2.ddpfPixelFormat).dwZBufferBitDepth = 16; U3(ddsd2.ddpfPixelFormat).dwZBitMask = 0x0000FFFF; hr = IDirectDraw_CreateSurface(lpDD, (DDSURFACEDESC *)&ddsd, &surface1, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDraw_CreateSurface(lpDD, (DDSURFACEDESC *)&ddsd2, &surface2, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { /* DeleteAttachedSurface */ hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface2); ok(hr == DD_OK, "AddAttachedSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { ref = getRefcount((IUnknown *)surface2); ok(ref == 2, "Got refcount %d, expected 2\n", ref); /* Try reattach */ hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface2); ok(hr == DDERR_SURFACEALREADYATTACHED, "AddAttachedSurface returned %08x\n", hr); /* Attaching while already attached to other surface */ hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface3, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface_AddAttachedSurface(surface3, surface2); todo_wine ok(hr == DD_OK, "AddAttachedSurface returned %08x\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface_DeleteAttachedSurface(surface3, 0, surface2); ok(hr == DD_OK, "DeleteAttachedSurface returned %08x\n", hr); } IDirectDrawSurface_Release(surface3); } hr = IDirectDrawSurface_DeleteAttachedSurface(surface1, 0, surface2); ok(hr == DD_OK, "DeleteAttachedSurface returned %08x\n", hr); ref = getRefcount((IUnknown *)surface2); ok(ref == 1, "Got refcount %d, expected 2\n", ref); } /* Automatic detachment on release */ hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface2); ok(hr == DD_OK, "AddAttachedSurface returned %08x\n", hr); ref = getRefcount((IUnknown *)surface2); ok(ref == 2, "Got refcount %d, expected 2\n", ref); ref = IDirectDrawSurface_Release(surface1); ok(!ref, "Got refcount %d, expected 0\n", ref); ref = getRefcount((IUnknown *)surface2); ok(ref == 1, "Got refcount %d, expected 1\n", ref); ref = IDirectDrawSurface_Release(surface2); ok(!ref, "Got refcount %d, expected 0\n", ref); } else IDirectDrawSurface_Release(surface1); } hr =IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr); DestroyWindow(window); } struct compare { DWORD width, height; DWORD caps, caps2; UINT mips; }; static HRESULT WINAPI CubeTestPaletteEnum(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context) { HRESULT hr; hr = IDirectDrawSurface7_SetPalette(surface, context); if (desc->dwWidth == 64) /* This is for first mimpmap */ ok(hr == DDERR_NOTONMIPMAPSUBLEVEL, "SetPalette returned: %x\n",hr); else ok(hr == DD_OK, "SetPalette returned: %x\n",hr); IDirectDrawSurface7_Release(surface); return DDENUMRET_OK; } static HRESULT WINAPI CubeTestLvl2Enum(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context) { UINT *mips = context; (*mips)++; IDirectDrawSurface7_EnumAttachedSurfaces(surface, context, CubeTestLvl2Enum); return DDENUMRET_OK; } static HRESULT WINAPI CubeTestLvl1Enum(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context) { UINT mips = 0; UINT *num = context; static const struct compare expected[] = { { 128, 128, DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX, DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ, 7 }, { 128, 128, DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX, DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ, 7 }, { 128, 128, DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX, DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY, 7 }, { 128, 128, DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX, DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY, 7 }, { 128, 128, DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX, DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX, 7 }, { 64, 64, /* This is the first mipmap */ DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX, DDSCAPS2_MIPMAPSUBLEVEL | DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX, 6 }, }; mips = 0; IDirectDrawSurface7_EnumAttachedSurfaces(surface, &mips, CubeTestLvl2Enum); ok(desc->dwWidth == expected[*num].width, "Surface width is %d expected %d\n", desc->dwWidth, expected[*num].width); ok(desc->dwHeight == expected[*num].height, "Surface height is %d expected %d\n", desc->dwHeight, expected[*num].height); ok(desc->ddsCaps.dwCaps == expected[*num].caps, "Surface caps are %08x expected %08x\n", desc->ddsCaps.dwCaps, expected[*num].caps); ok(desc->ddsCaps.dwCaps2 == expected[*num].caps2, "Surface caps2 are %08x expected %08x\n", desc->ddsCaps.dwCaps2, expected[*num].caps2); ok(mips == expected[*num].mips, "Surface has %d mipmaps, expected %d\n", mips, expected[*num].mips); (*num)++; IDirectDrawSurface7_Release(surface); return DDENUMRET_OK; } static void CubeMapTest(void) { IDirectDraw7 *dd7 = NULL; IDirectDrawSurface7 *cubemap = NULL; IDirectDrawPalette *palette = NULL; DDSURFACEDESC2 ddsd; HRESULT hr; PALETTEENTRY Table[256]; int i; UINT num = 0; UINT ref; struct enumstruct ctx; for(i=0; i<256; i++) { Table[i].peRed = 0xff; Table[i].peGreen = 0; Table[i].peBlue = 0; Table[i].peFlags = 0; } hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(hr == DD_OK, "IDirectDraw::QueryInterface returned %08x\n", hr); if (FAILED(hr)) goto err; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY; ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_ALLFACES; /* D3DFMT_R5G6B5 */ U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB; U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16; U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800; U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0; U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL); if (FAILED(hr)) { skip("Can't create cubemap surface\n"); goto err; } hr = IDirectDrawSurface7_GetSurfaceDesc(cubemap, &ddsd); ok(hr == DD_OK, "IDirectDrawSurface7_GetSurfaceDesc returned %08x\n", hr); ok(ddsd.ddsCaps.dwCaps == (DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_COMPLEX), "Root Caps are %08x\n", ddsd.ddsCaps.dwCaps); ok(ddsd.ddsCaps.dwCaps2 == (DDSCAPS2_CUBEMAP_POSITIVEX | DDSCAPS2_CUBEMAP), "Root Caps2 are %08x\n", ddsd.ddsCaps.dwCaps2); IDirectDrawSurface7_EnumAttachedSurfaces(cubemap, &num, CubeTestLvl1Enum); ok(num == 6, "Surface has %d attachments\n", num); IDirectDrawSurface7_Release(cubemap); /* What happens if I do not specify any faces? */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY; ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP; /* D3DFMT_R5G6B5 */ U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB; U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16; U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800; U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0; U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw7::CreateSurface asking for a cube map without faces returned %08x\n", hr); /* Cube map faces without a cube map? */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY; ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP_ALLFACES; /* D3DFMT_R5G6B5 */ U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB; U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16; U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800; U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0; U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL); ok(hr == DDERR_INVALIDCAPS, "IDirectDraw7::CreateSurface returned %08x\n", hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY; ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP_POSITIVEX; /* D3DFMT_R5G6B5 */ U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB; U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 16; U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0xF800; U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x07E0; U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x001F; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL); ok(hr == DDERR_INVALIDCAPS, "IDirectDraw7::CreateSurface returned %08x\n", hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP | DDSCAPS_SYSTEMMEMORY; ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_ALLFACES; U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8; U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 8; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &cubemap, NULL); if (FAILED(hr)) { skip("Can't create palletized cubemap surface\n"); goto err; } hr = IDirectDraw7_CreatePalette(dd7, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette failed with %08x\n", hr); hr = IDirectDrawSurface7_EnumAttachedSurfaces(cubemap, palette, CubeTestPaletteEnum); ok(hr == DD_OK, "EnumAttachedSurfaces failed\n"); ref = getRefcount((IUnknown *) palette); ok(ref == 6, "Refcount is %u, expected 1\n", ref); IDirectDrawSurface7_Release(cubemap); ref = getRefcount((IUnknown *) palette); ok(ref == 1, "Refcount is %u, expected 1\n", ref); IDirectDrawPalette_Release(palette); /* Make sure everything is cleaned up properly. Use the enumSurfaces test infrastructure */ memset(&ctx, 0, sizeof(ctx)); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDraw_EnumSurfaces(lpDD, DDENUMSURFACES_DOESEXIST | DDENUMSURFACES_ALL, (DDSURFACEDESC *) &ddsd, (void *) &ctx, enumCB); ok(hr == DD_OK, "IDirectDraw_EnumSurfaces returned %08x\n", hr); ok(ctx.count == 0, "%d surfaces enumerated, expected 0\n", ctx.count); err: if (dd7) IDirectDraw7_Release(dd7); } static void test_lockrect_invalid(void) { unsigned int i, j; RECT valid[] = { {60, 60, 68, 68}, {60, 60, 60, 68}, {60, 60, 68, 60}, {120, 60, 128, 68}, {60, 120, 68, 128}, }; RECT invalid[] = { {68, 60, 60, 68}, /* left > right */ {60, 68, 68, 60}, /* top > bottom */ {-8, 60, 0, 68}, /* left < surface */ {60, -8, 68, 0}, /* top < surface */ {-16, 60, -8, 68}, /* right < surface */ {60, -16, 68, -8}, /* bottom < surface */ {60, 60, 136, 68}, /* right > surface */ {60, 60, 68, 136}, /* bottom > surface */ {136, 60, 144, 68}, /* left > surface */ {60, 136, 68, 144}, /* top > surface */ }; const DWORD dds_caps[] = { DDSCAPS_OFFSCREENPLAIN }; for (j = 0; j < (sizeof(dds_caps) / sizeof(*dds_caps)); ++j) { IDirectDrawSurface *surface = 0; DDSURFACEDESC surface_desc = {0}; DDSURFACEDESC locked_desc = {0}; HRESULT hr; surface_desc.dwSize = sizeof(surface_desc); surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat); surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; surface_desc.ddsCaps.dwCaps = dds_caps[j]; surface_desc.dwWidth = 128; surface_desc.dwHeight = 128; surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32; U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0xFF0000; U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x00FF00; U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x0000FF; hr = IDirectDraw_CreateSurface(lpDD, &surface_desc, &surface, NULL); ok(SUCCEEDED(hr), "CreateSurface failed (0x%08x)\n", hr); if (FAILED(hr)) { skip("failed to create surface\n"); continue; } hr = IDirectDrawSurface_Lock(surface, NULL, NULL, DDLOCK_WAIT, NULL); ok(hr == DDERR_INVALIDPARAMS, "Lock returned 0x%08x for NULL DDSURFACEDESC," " expected DDERR_INVALIDPARAMS (0x%08x)\n", hr, DDERR_INVALIDPARAMS); for (i = 0; i < (sizeof(valid) / sizeof(*valid)); ++i) { RECT *rect = &valid[i]; memset(&locked_desc, 0, sizeof(locked_desc)); locked_desc.dwSize = sizeof(locked_desc); hr = IDirectDrawSurface_Lock(surface, rect, &locked_desc, DDLOCK_WAIT, NULL); ok(SUCCEEDED(hr), "Lock failed (0x%08x) for rect [%d, %d]->[%d, %d]\n", hr, rect->left, rect->top, rect->right, rect->bottom); hr = IDirectDrawSurface_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr); } for (i = 0; i < (sizeof(invalid) / sizeof(*invalid)); ++i) { RECT *rect = &invalid[i]; memset(&locked_desc, 1, sizeof(locked_desc)); locked_desc.dwSize = sizeof(locked_desc); hr = IDirectDrawSurface_Lock(surface, rect, &locked_desc, DDLOCK_WAIT, NULL); ok(hr == DDERR_INVALIDPARAMS, "Lock returned 0x%08x for rect [%d, %d]->[%d, %d]" ", expected DDERR_INVALIDPARAMS (0x%08x)\n", hr, rect->left, rect->top, rect->right, rect->bottom, DDERR_INVALIDPARAMS); ok(!locked_desc.lpSurface, "IDirectDrawSurface_Lock did not set lpSurface in the surface desc to zero.\n"); } hr = IDirectDrawSurface_Lock(surface, NULL, &locked_desc, DDLOCK_WAIT, NULL); ok(hr == DD_OK, "IDirectDrawSurface_Lock(rect = NULL) failed (0x%08x)\n", hr); hr = IDirectDrawSurface_Lock(surface, NULL, &locked_desc, DDLOCK_WAIT, NULL); ok(hr == DDERR_SURFACEBUSY, "Double lock(rect = NULL) returned 0x%08x\n", hr); if(SUCCEEDED(hr)) { hr = IDirectDrawSurface_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr); } hr = IDirectDrawSurface_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr); memset(&locked_desc, 0, sizeof(locked_desc)); locked_desc.dwSize = sizeof(locked_desc); hr = IDirectDrawSurface_Lock(surface, &valid[0], &locked_desc, DDLOCK_WAIT, NULL); ok(hr == DD_OK, "IDirectDrawSurface_Lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n", valid[0].left, valid[0].top, valid[0].right, valid[0].bottom, hr); hr = IDirectDrawSurface_Lock(surface, &valid[0], &locked_desc, DDLOCK_WAIT, NULL); ok(hr == DDERR_SURFACEBUSY, "Double lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n", valid[0].left, valid[0].top, valid[0].right, valid[0].bottom, hr); /* Locking a different rectangle returns DD_OK, but it seems to break the surface. * Afterwards unlocking the surface fails(NULL rectangle, and both locked rectangles */ hr = IDirectDrawSurface_Unlock(surface, NULL); ok(hr == DD_OK, "Unlock returned (0x%08x)\n", hr); IDirectDrawSurface_Release(surface); } } static void CompressedTest(void) { HRESULT hr; IDirectDrawSurface7 *surface; DDSURFACEDESC2 ddsd, ddsd2; IDirectDraw7 *dd7 = NULL; RECT r = { 0, 0, 128, 128 }; RECT r2 = { 32, 32, 64, 64 }; hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(hr == DD_OK, "IDirectDraw::QueryInterface returned %08x\n", hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY; U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_FOURCC; U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','1'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (FAILED(hr)) { skip("failed to create surface\n"); return; } memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 8192, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.ddsCaps.dwCaps2 == 0, "Caps2: %08x\n", ddsd2.ddsCaps.dwCaps2); IDirectDrawSurface7_Release(surface); U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','3'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (FAILED(hr)) { skip("failed to create surface\n"); return; } memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); IDirectDrawSurface7_Release(surface); U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','5'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); if (FAILED(hr)) { skip("failed to create surface\n"); return; } memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface == 0, "Surface memory is at %p, expected NULL\n", ddsd2.lpSurface); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); /* Show that the description is not changed when locking the surface. What is really interesting * about this is that DDSD_LPSURFACE isn't set. */ hr = IDirectDrawSurface7_Lock(surface, NULL, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(hr == DD_OK, "Unlock returned %08x\n", hr); /* Now what about a locking rect? */ hr = IDirectDrawSurface7_Lock(surface, &r, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, &r); ok(hr == DD_OK, "Unlock returned %08x\n", hr); /* Now what about a different locking offset? */ hr = IDirectDrawSurface7_Lock(surface, &r2, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, &r2); ok(hr == DD_OK, "Unlock returned %08x\n", hr); IDirectDrawSurface7_Release(surface); /* Try this with video memory. A kind of surprise. It still has the LINEARSIZE flag set, * but seems to have a pitch instead. */ ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY; U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','1'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK || hr == DDERR_NOTEXTUREHW || hr == DDERR_INVALIDPARAMS || broken(hr == DDERR_NODIRECTDRAWHW), "CreateSurface returned %08x\n", hr); /* Not supported everywhere */ if(SUCCEEDED(hr)) { memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */ ok(ddsd2.ddsCaps.dwCaps2 == 0, "Caps2: %08x\n", ddsd2.ddsCaps.dwCaps2); IDirectDrawSurface7_Release(surface); U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','3'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */ IDirectDrawSurface7_Release(surface); U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','5'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */ ok(ddsd2.lpSurface == 0, "Surface memory is at %p, expected NULL\n", ddsd2.lpSurface); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); /* Show that the description is not changed when locking the surface. What is really interesting * about this is that DDSD_LPSURFACE isn't set. */ hr = IDirectDrawSurface7_Lock(surface, NULL, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */ ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(hr == DD_OK, "Unlock returned %08x\n", hr); /* Now what about a locking rect? */ hr = IDirectDrawSurface7_Lock(surface, &r, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */ ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, &r); ok(hr == DD_OK, "Unlock returned %08x\n", hr); /* Now what about a different locking offset? */ hr = IDirectDrawSurface7_Lock(surface, &r2, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */ ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, &r2); ok(hr == DD_OK, "Unlock returned %08x\n", hr); IDirectDrawSurface7_Release(surface); } else { skip("Hardware DXTN textures not supported\n"); } /* What happens to managed textures? Interestingly, Windows reports them as being in system * memory. The linear size fits again. */ ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE; ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE; U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','1'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK || hr == DDERR_NOTEXTUREHW, "CreateSurface returned %08x\n", hr); /* Not supported everywhere */ if(SUCCEEDED(hr)) { memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 8192, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.ddsCaps.dwCaps2 == DDSCAPS2_TEXTUREMANAGE, "Caps2: %08x\n", ddsd2.ddsCaps.dwCaps2); IDirectDrawSurface7_Release(surface); U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','3'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); IDirectDrawSurface7_Release(surface); U4(ddsd).ddpfPixelFormat.dwFourCC = MAKEFOURCC('D','X','T','5'); hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); hr = IDirectDrawSurface7_GetSurfaceDesc(surface, &ddsd2); ok(hr == DD_OK, "GetSurfaceDesc returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface == 0, "Surface memory is at %p, expected NULL\n", ddsd2.lpSurface); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); U4(ddsd2).ddpfPixelFormat.dwSize = sizeof(U4(ddsd2).ddpfPixelFormat); /* Show that the description is not changed when locking the surface. What is really interesting * about this is that DDSD_LPSURFACE isn't set. */ hr = IDirectDrawSurface7_Lock(surface, NULL, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "Linear size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(hr == DD_OK, "Unlock returned %08x\n", hr); /* Now what about a locking rect? */ hr = IDirectDrawSurface7_Lock(surface, &r, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "\"Linear\" size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, &r); ok(hr == DD_OK, "Unlock returned %08x\n", hr); /* Now what about a different locking offset? */ hr = IDirectDrawSurface7_Lock(surface, &r2, &ddsd2, DDLOCK_READONLY, 0); ok(hr == DD_OK, "Lock returned %08x\n", hr); ok(ddsd2.dwFlags == (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_LINEARSIZE), "Surface desc flags: %08x\n", ddsd2.dwFlags); ok(U4(ddsd2).ddpfPixelFormat.dwFlags == DDPF_FOURCC, "Pixel format flags: %08x\n", U4(ddsd2).ddpfPixelFormat.dwFlags); ok(U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount == 0, "RGB bitcount: %08x\n", U1(U4(ddsd2).ddpfPixelFormat).dwRGBBitCount); ok(ddsd2.ddsCaps.dwCaps == (DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY), "Surface caps flags: %08x\n", ddsd2.ddsCaps.dwCaps); ok(U1(ddsd2).dwLinearSize == 16384, "\"Linear\" size is %d\n", U1(ddsd2).dwLinearSize); ok(ddsd2.lpSurface != 0, "Surface memory is at NULL\n"); hr = IDirectDrawSurface7_Unlock(surface, &r2); ok(hr == DD_OK, "Unlock returned %08x\n", hr); IDirectDrawSurface7_Release(surface); } else { skip("Hardware DXTN textures not supported\n"); } IDirectDraw7_Release(dd7); } static void SizeTest(void) { LPDIRECTDRAWSURFACE dsurface = NULL; DDSURFACEDESC desc; HRESULT ret; HWND window = CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL ); /* Create an offscreen surface surface without a size */ ZeroMemory(&desc, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS; desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN; ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL); ok(ret == DDERR_INVALIDPARAMS, "Creating an offscreen plain surface without a size info returned %08x (dsurface=%p)\n", ret, dsurface); if(dsurface) { trace("Surface at %p\n", dsurface); IDirectDrawSurface_Release(dsurface); dsurface = NULL; } /* Create an offscreen surface surface with only a width parameter */ ZeroMemory(&desc, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_WIDTH; desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN; desc.dwWidth = 128; ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL); ok(ret == DDERR_INVALIDPARAMS, "Creating an offscreen plain surface without height info returned %08x\n", ret); if(dsurface) { IDirectDrawSurface_Release(dsurface); dsurface = NULL; } /* Create an offscreen surface surface with only a height parameter */ ZeroMemory(&desc, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT; desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN; desc.dwHeight = 128; ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL); ok(ret == DDERR_INVALIDPARAMS, "Creating an offscreen plain surface without width info returned %08x\n", ret); if(dsurface) { IDirectDrawSurface_Release(dsurface); dsurface = NULL; } /* Test 0 height. */ memset(&desc, 0, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; desc.dwWidth = 1; desc.dwHeight = 0; ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL); ok(ret == DDERR_INVALIDPARAMS, "Creating a 0 height surface returned %#x, expected DDERR_INVALIDPARAMS.\n", ret); if (SUCCEEDED(ret)) IDirectDrawSurface_Release(dsurface); dsurface = NULL; /* Test 0 width. */ memset(&desc, 0, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; desc.dwWidth = 0; desc.dwHeight = 1; ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL); ok(ret == DDERR_INVALIDPARAMS, "Creating a 0 width surface returned %#x, expected DDERR_INVALIDPARAMS.\n", ret); if (SUCCEEDED(ret)) IDirectDrawSurface_Release(dsurface); dsurface = NULL; /* Sanity check */ ZeroMemory(&desc, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN; desc.dwHeight = 128; desc.dwWidth = 128; ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL); ok(ret == DD_OK, "Creating an offscreen plain surface with width and height info returned %08x\n", ret); if(dsurface) { IDirectDrawSurface_Release(dsurface); dsurface = NULL; } /* Test a primary surface size */ ret = IDirectDraw_SetCooperativeLevel(lpDD, window, DDSCL_NORMAL); ok(ret == DD_OK, "SetCooperativeLevel failed with %08x\n", ret); ZeroMemory(&desc, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS; desc.ddsCaps.dwCaps |= DDSCAPS_PRIMARYSURFACE; desc.dwHeight = 128; /* Keep them set to check what happens */ desc.dwWidth = 128; /* Keep them set to check what happens */ ret = IDirectDraw_CreateSurface(lpDD, &desc, &dsurface, NULL); ok(ret == DD_OK, "Creating a primary surface without width and height info returned %08x\n", ret); if(dsurface) { ret = IDirectDrawSurface_GetSurfaceDesc(dsurface, &desc); ok(ret == DD_OK, "GetSurfaceDesc returned %x\n", ret); IDirectDrawSurface_Release(dsurface); dsurface = NULL; ok(desc.dwFlags & DDSD_WIDTH, "Primary surface doesn't have width set\n"); ok(desc.dwFlags & DDSD_HEIGHT, "Primary surface doesn't have height set\n"); ok(desc.dwWidth == GetSystemMetrics(SM_CXSCREEN), "Surface width differs from screen width\n"); ok(desc.dwHeight == GetSystemMetrics(SM_CYSCREEN), "Surface height differs from screen height\n"); } ret = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL); ok(ret == DD_OK, "SetCooperativeLevel failed with %08x\n", ret); } static void PrivateDataTest(void) { HRESULT hr; IDirectDrawSurface7 *surface7 = NULL; IDirectDrawSurface *surface = NULL; DDSURFACEDESC desc; ULONG ref, ref2; IUnknown *ptr; DWORD size = sizeof(IUnknown *); ZeroMemory(&desc, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN; desc.dwHeight = 128; desc.dwWidth = 128; hr = IDirectDraw_CreateSurface(lpDD, &desc, &surface, NULL); ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr); if(!surface) { return; } hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface7, (void **) &surface7); ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr); if(!surface7) { IDirectDrawSurface_Release(surface); return; } /* This fails */ hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, 0, DDSPD_IUNKNOWNPOINTER); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr); hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, 5, DDSPD_IUNKNOWNPOINTER); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr); hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, sizeof(IUnknown *) * 2, DDSPD_IUNKNOWNPOINTER); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr); ref = getref((IUnknown *) lpDD); hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7 /* Abuse this tag */, lpDD, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER); ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr); ref2 = getref((IUnknown *) lpDD); ok(ref2 == ref + 1, "Object reference is %d, expected %d\n", ref2, ref + 1); hr = IDirectDrawSurface7_FreePrivateData(surface7, &IID_IDirectDrawSurface7); ok(SUCCEEDED(hr), "IDirectDrawSurface7_FreePrivateData returned %#x.\n", hr); ref2 = getref((IUnknown *) lpDD); ok(ref2 == ref, "Object reference is %d, expected %d\n", ref2, ref); hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7, lpDD, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER); ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr); hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7, surface7, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER); ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr); ref2 = getref((IUnknown *) lpDD); ok(ref2 == ref, "Object reference is %d, expected %d\n", ref2, ref); hr = IDirectDrawSurface7_SetPrivateData(surface7, &IID_IDirectDrawSurface7, lpDD, sizeof(IUnknown *), DDSPD_IUNKNOWNPOINTER); ok(hr == DD_OK, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr); hr = IDirectDrawSurface7_GetPrivateData(surface7, &IID_IDirectDrawSurface7, &ptr, &size); ok(hr == DD_OK, "IDirectDrawSurface7_GetPrivateData failed with %08x\n", hr); ref2 = getref((IUnknown *) lpDD); /* Object is NOT being addrefed */ ok(ptr == (IUnknown *) lpDD, "Returned interface pointer is %p, expected %p\n", ptr, lpDD); ok(ref2 == ref + 1, "Object reference is %d, expected %d. ptr at %p, orig at %p\n", ref2, ref + 1, ptr, lpDD); IDirectDrawSurface_Release(surface); IDirectDrawSurface7_Release(surface7); /* Destroying the surface frees the held reference */ ref2 = getref((IUnknown *) lpDD); ok(ref2 == ref, "Object reference is %d, expected %d\n", ref2, ref); } static void BltParamTest(void) { IDirectDrawSurface *surface1 = NULL, *surface2 = NULL; DDSURFACEDESC desc; HRESULT hr; DDBLTFX BltFx; RECT valid = {10, 10, 20, 20}; RECT invalid1 = {20, 10, 10, 20}; RECT invalid2 = {20, 20, 20, 20}; RECT invalid3 = {-1, -1, 20, 20}; RECT invalid4 = {60, 60, 70, 70}; memset(&desc, 0, sizeof(desc)); desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; desc.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN; desc.dwHeight = 128; desc.dwWidth = 128; hr = IDirectDraw_CreateSurface(lpDD, &desc, &surface1, NULL); ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr); desc.dwHeight = 64; desc.dwWidth = 64; hr = IDirectDraw_CreateSurface(lpDD, &desc, &surface2, NULL); ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr); if(0) { /* This crashes */ hr = IDirectDrawSurface_BltFast(surface1, 0, 0, NULL, NULL, 0); ok(hr == DD_OK, "BltFast from NULL surface returned %08x\n", hr); } hr = IDirectDrawSurface_BltFast(surface1, 0, 0, surface2, NULL, 0); ok(hr == DD_OK, "BltFast from smaller to bigger surface returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, NULL, 0); ok(hr == DDERR_INVALIDRECT, "BltFast from bigger to smaller surface returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &valid, 0); ok(hr == DD_OK, "BltFast from bigger to smaller surface using a valid rectangle returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface2, 60, 60, surface1, &valid, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface1, 90, 90, surface2, NULL, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface1, -10, 0, surface2, NULL, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with an offset resulting in an off-surface write returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface1, 0, -10, surface2, NULL, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with an offset resulting in an off-surface write returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface2, 20, 20, surface1, &valid, 0); ok(hr == DD_OK, "BltFast from bigger to smaller surface using a valid rectangle and offset returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &invalid1, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 1 returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &invalid2, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 2 returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface2, 0, 0, surface1, &invalid3, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 3 returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface1, 0, 0, surface2, &invalid4, 0); ok(hr == DDERR_INVALIDRECT, "BltFast with invalid rectangle 3 returned %08x\n", hr); hr = IDirectDrawSurface_BltFast(surface1, 0, 0, surface1, NULL, 0); ok(hr == DD_OK, "BltFast blitting a surface onto itself returned %08x\n", hr); /* Blt(non-fast) tests */ memset(&BltFx, 0, sizeof(BltFx)); BltFx.dwSize = sizeof(BltFx); U5(BltFx).dwFillColor = 0xaabbccdd; hr = IDirectDrawSurface_Blt(surface1, &valid, NULL, NULL, DDBLT_COLORFILL, &BltFx); ok(hr == DD_OK, "IDirectDrawSurface_Blt with a valid rectangle for color fill returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface1, &valid, NULL, &invalid3, DDBLT_COLORFILL, &BltFx); ok(hr == DD_OK, "IDirectDrawSurface_Blt with a invalid, unused rectangle returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, &invalid1, NULL, NULL, DDBLT_COLORFILL, &BltFx); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, &invalid2, NULL, NULL, DDBLT_COLORFILL, &BltFx); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, &invalid3, NULL, NULL, DDBLT_COLORFILL, &BltFx); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, &invalid4, NULL, NULL, DDBLT_COLORFILL, &BltFx); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr); /* Valid on surface 1 */ hr = IDirectDrawSurface_Blt(surface1, &invalid4, NULL, NULL, DDBLT_COLORFILL, &BltFx); ok(hr == DD_OK, "IDirectDrawSurface_Blt with a subrectangle fill returned %08x\n", hr); /* Works - stretched blit */ hr = IDirectDrawSurface_Blt(surface1, NULL, surface2, NULL, 0, NULL); ok(hr == DD_OK, "IDirectDrawSurface_Blt from a smaller to a bigger surface returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, NULL, 0, NULL); ok(hr == DD_OK, "IDirectDrawSurface_Blt from a bigger to a smaller surface %08x\n", hr); /* Invalid dest rects in sourced blits */ hr = IDirectDrawSurface_Blt(surface2, &invalid1, surface1, NULL, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, &invalid2, surface1, NULL, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, &invalid3, surface1, NULL, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, &invalid4, surface1, NULL, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr); /* Invalid src rects */ hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, &invalid1, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, &invalid2, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface2, NULL, surface1, &invalid3, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr); hr = IDirectDrawSurface_Blt(surface1, NULL, surface2, &invalid4, 0, NULL); ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr); IDirectDrawSurface_Release(surface1); IDirectDrawSurface_Release(surface2); } static void PaletteTest(void) { HRESULT hr; LPDIRECTDRAWSURFACE lpSurf = NULL; IDirectDrawSurface *backbuffer = NULL; DDSCAPS ddscaps; DDSURFACEDESC ddsd; IDirectDrawPalette *palette = NULL; PALETTEENTRY Table[256]; PALETTEENTRY palEntries[256]; int i; for(i=0; i<256; i++) { Table[i].peRed = 0xff; Table[i].peGreen = 0; Table[i].peBlue = 0; Table[i].peFlags = 0; } /* Create a 8bit palette without DDPCAPS_ALLOW256 set */ hr = IDirectDraw_CreatePalette(lpDD, DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette failed with %08x\n", hr); if (FAILED(hr)) goto err; /* Read back the palette and verify the entries. Without DDPCAPS_ALLOW256 set / entry 0 and 255 should have been overwritten with black and white */ hr = IDirectDrawPalette_GetEntries(palette , 0, 0, 256, &palEntries[0]); ok(hr == DD_OK, "GetEntries failed with %08x\n", hr); if(hr == DD_OK) { ok((palEntries[0].peRed == 0) && (palEntries[0].peGreen == 0) && (palEntries[0].peBlue == 0), "Palette entry 0 of a palette without DDPCAPS_ALLOW256 set should be (0,0,0) but it is (%d,%d,%d)\n", palEntries[0].peRed, palEntries[0].peGreen, palEntries[0].peBlue); ok((palEntries[255].peRed == 255) && (palEntries[255].peGreen == 255) && (palEntries[255].peBlue == 255), "Palette entry 255 of a palette without DDPCAPS_ALLOW256 set should be (255,255,255) but it is (%d,%d,%d)\n", palEntries[255].peRed, palEntries[255].peGreen, palEntries[255].peBlue); /* Entry 1-254 should contain red */ for(i=1; i<255; i++) ok((palEntries[i].peRed == 255) && (palEntries[i].peGreen == 0) && (palEntries[i].peBlue == 0), "Palette entry %d should have contained (255,0,0) but was set to %d,%d,%d)\n", i, palEntries[i].peRed, palEntries[i].peGreen, palEntries[i].peBlue); } /* CreatePalette without DDPCAPS_ALLOW256 ignores entry 0 and 255, / now check we are able to update the entries afterwards. */ hr = IDirectDrawPalette_SetEntries(palette , 0, 0, 256, &Table[0]); ok(hr == DD_OK, "SetEntries failed with %08x\n", hr); hr = IDirectDrawPalette_GetEntries(palette , 0, 0, 256, &palEntries[0]); ok(hr == DD_OK, "GetEntries failed with %08x\n", hr); if(hr == DD_OK) { ok((palEntries[0].peRed == 0) && (palEntries[0].peGreen == 0) && (palEntries[0].peBlue == 0), "Palette entry 0 should have been set to (0,0,0) but it contains (%d,%d,%d)\n", palEntries[0].peRed, palEntries[0].peGreen, palEntries[0].peBlue); ok((palEntries[255].peRed == 255) && (palEntries[255].peGreen == 255) && (palEntries[255].peBlue == 255), "Palette entry 255 should have been set to (255,255,255) but it contains (%d,%d,%d)\n", palEntries[255].peRed, palEntries[255].peGreen, palEntries[255].peBlue); } IDirectDrawPalette_Release(palette); /* Create a 8bit palette with DDPCAPS_ALLOW256 set */ hr = IDirectDraw_CreatePalette(lpDD, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette failed with %08x\n", hr); if (FAILED(hr)) goto err; hr = IDirectDrawPalette_GetEntries(palette , 0, 0, 256, &palEntries[0]); ok(hr == DD_OK, "GetEntries failed with %08x\n", hr); if(hr == DD_OK) { /* All entries should contain red */ for(i=0; i<256; i++) ok((palEntries[i].peRed == 255) && (palEntries[i].peGreen == 0) && (palEntries[i].peBlue == 0), "Palette entry %d should have contained (255,0,0) but was set to %d,%d,%d)\n", i, palEntries[i].peRed, palEntries[i].peGreen, palEntries[i].peBlue); } /* Try to set palette to a non-palettized surface */ ddsd.dwSize = sizeof(ddsd); ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = 800; ddsd.dwHeight = 600; ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xFF0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x00FF00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x0000FF; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSurf, NULL); ok(hr==DD_OK, "CreateSurface returned: %x\n",hr); if (FAILED(hr)) { skip("failed to create surface\n"); goto err; } hr = IDirectDrawSurface_SetPalette(lpSurf, palette); ok(hr == DDERR_INVALIDPIXELFORMAT, "CreateSurface returned: %x\n",hr); IDirectDrawPalette_Release(palette); palette = NULL; hr = IDirectDrawSurface_GetPalette(lpSurf, &palette); ok(hr == DDERR_NOPALETTEATTACHED, "CreateSurface returned: %x\n",hr); err: if (lpSurf) IDirectDrawSurface_Release(lpSurf); if (palette) IDirectDrawPalette_Release(palette); hr = IDirectDraw_CreatePalette(lpDD, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette failed with %08x\n", hr); ddsd.dwSize = sizeof(ddsd); ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_BACKBUFFERCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_COMPLEX | DDSCAPS_FLIP; ddsd.dwWidth = 64; ddsd.dwHeight = 64; ddsd.dwBackBufferCount = 1; ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 8; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSurf, NULL); ok(hr==DD_OK, "CreateSurface returned: %x\n",hr); if (FAILED(hr)) { skip("failed to create surface\n"); return; } ddscaps.dwCaps = DDSCAPS_BACKBUFFER; hr = IDirectDrawSurface_GetAttachedSurface(lpSurf, &ddscaps, &backbuffer); ok(hr == DD_OK, "GetAttachedSurface returned: %x\n",hr); hr = IDirectDrawSurface_SetPalette(backbuffer, palette); ok(hr == DD_OK, "SetPalette returned: %x\n",hr); IDirectDrawPalette_Release(palette); palette = NULL; hr = IDirectDrawSurface_GetPalette(backbuffer, &palette); ok(hr == DD_OK, "CreateSurface returned: %x\n",hr); IDirectDrawSurface_Release(backbuffer); IDirectDrawSurface_Release(lpSurf); } static void StructSizeTest(void) { IDirectDrawSurface *surface1; IDirectDrawSurface7 *surface7; union { DDSURFACEDESC desc1; DDSURFACEDESC2 desc2; char blob[1024]; /* To get a bunch of writable memory */ } desc; DDSURFACEDESC create; HRESULT hr; memset(&desc, 0, sizeof(desc)); memset(&create, 0, sizeof(create)); memset(&create, 0, sizeof(create)); create.dwSize = sizeof(create); create.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; create.ddsCaps.dwCaps |= DDSCAPS_OFFSCREENPLAIN; create.dwHeight = 128; create.dwWidth = 128; hr = IDirectDraw_CreateSurface(lpDD, &create, &surface1, NULL); ok(hr == DD_OK, "Creating an offscreen plain surface failed with %08x\n", hr); hr = IDirectDrawSurface_QueryInterface(surface1, &IID_IDirectDrawSurface7, (void **) &surface7); ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr); desc.desc1.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1); ok(hr == DD_OK, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr); hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr); desc.desc2.dwSize = sizeof(DDSURFACEDESC2); hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr); hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2); ok(hr == DD_OK, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr); desc.desc2.dwSize = 0; hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size 0 returned %08x\n", hr); hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size 0 returned %08x\n", hr); desc.desc1.dwSize = sizeof(DDSURFACEDESC) + 1; hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr); hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr); desc.desc2.dwSize = sizeof(DDSURFACEDESC2) + 1; hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc.desc1); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr); hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc.desc2); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr); /* Tests for Lock() */ desc.desc1.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0); ok(hr == DD_OK, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL); ok(desc.desc1.dwSize == sizeof(DDSURFACEDESC), "Destination size was changed to %d\n", desc.desc1.dwSize); hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0); ok(hr == DD_OK, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL); ok(desc.desc2.dwSize == sizeof(DDSURFACEDESC), "Destination size was changed to %d\n", desc.desc1.dwSize); desc.desc2.dwSize = sizeof(DDSURFACEDESC2); hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0); ok(hr == DD_OK, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr); ok(desc.desc1.dwSize == sizeof(DDSURFACEDESC2), "Destination size was changed to %d\n", desc.desc1.dwSize); if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL); hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0); ok(hr == DD_OK, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL); ok(desc.desc2.dwSize == sizeof(DDSURFACEDESC2), "Destination size was changed to %d\n", desc.desc1.dwSize); desc.desc2.dwSize = 0; hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Lock with desc size 0 returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL); hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_Lock with desc size 0 returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL); desc.desc1.dwSize = sizeof(DDSURFACEDESC) + 1; hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL); hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL); desc.desc2.dwSize = sizeof(DDSURFACEDESC2) + 1; hr = IDirectDrawSurface_Lock(surface1, NULL, &desc.desc1, 0, 0); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface_Unlock(surface1, NULL); hr = IDirectDrawSurface7_Lock(surface7, NULL, &desc.desc2, 0, 0); ok(hr == DDERR_INVALIDPARAMS, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr); if(SUCCEEDED(hr)) IDirectDrawSurface7_Unlock(surface7, NULL); IDirectDrawSurface7_Release(surface7); IDirectDrawSurface_Release(surface1); } static void SurfaceCapsTest(void) { DDSURFACEDESC create; DDSURFACEDESC desc; HRESULT hr; IDirectDrawSurface *surface1 = NULL; DDSURFACEDESC2 create2, desc2; IDirectDrawSurface7 *surface7 = NULL; IDirectDraw7 *dd7 = NULL; DWORD create_caps[] = { DDSCAPS_OFFSCREENPLAIN, DDSCAPS_TEXTURE, DDSCAPS_TEXTURE | DDSCAPS_ALLOCONLOAD, 0, DDSCAPS_TEXTURE | DDSCAPS_ALLOCONLOAD | DDSCAPS_SYSTEMMEMORY, DDSCAPS_PRIMARYSURFACE, DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY, DDSCAPS_3DDEVICE, DDSCAPS_ZBUFFER, DDSCAPS_3DDEVICE | DDSCAPS_OFFSCREENPLAIN }; DWORD expected_caps[] = { DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM, DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM, DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM | DDSCAPS_ALLOCONLOAD, DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM, DDSCAPS_TEXTURE | DDSCAPS_ALLOCONLOAD | DDSCAPS_SYSTEMMEMORY, DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM | DDSCAPS_VISIBLE, DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_VISIBLE, DDSCAPS_3DDEVICE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM, DDSCAPS_ZBUFFER | DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY, DDSCAPS_3DDEVICE | DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM }; UINT i; /* Tests various surface flags, what changes do they undergo during surface creation. Forsaken * engine expects texture surfaces without memory flag to get a video memory flag right after * creation. Currently, Wine adds DDSCAPS_FRONTBUFFER to primary surface, but native doesn't do this * for single buffered primaries. Because of this primary surface creation tests are todo_wine. No real * app is known so far to care about this. */ if (!(ddcaps.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) { skip("DDraw reported no VIDEOMEMORY cap. Broken video driver? Skipping surface caps tests.\n"); return ; } for (i = 0; i < sizeof(create_caps) / sizeof(DWORD); i++) { memset(&create, 0, sizeof(create)); create.dwSize = sizeof(create); create.ddsCaps.dwCaps = create_caps[i]; create.dwFlags = DDSD_CAPS; if (!(create.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) { create.dwFlags |= DDSD_HEIGHT | DDSD_WIDTH; create.dwHeight = 128; create.dwWidth = 128; } if (create.ddsCaps.dwCaps & DDSCAPS_ZBUFFER) { create.dwFlags |= DDSD_PIXELFORMAT; create.ddpfPixelFormat.dwSize = sizeof(create.ddpfPixelFormat); create.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; U1(create.ddpfPixelFormat).dwZBufferBitDepth = 16; U3(create.ddpfPixelFormat).dwZBitMask = 0x0000FFFF; } hr = IDirectDraw_CreateSurface(lpDD, &create, &surface1, NULL); ok(hr == DD_OK, "IDirectDraw_CreateSurface failed with %08x\n", hr); if (SUCCEEDED(hr)) { memset(&desc, 0, sizeof(desc)); desc.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDrawSurface_GetSurfaceDesc(surface1, &desc); ok(hr == DD_OK, "IDirectDrawSurface_GetSurfaceDesc failed with %08x\n", hr); if (!(create_caps[i] & DDSCAPS_PRIMARYSURFACE)) ok(desc.ddsCaps.dwCaps == expected_caps[i], "GetSurfaceDesc test %d returned caps %x, expected %x\n", i, desc.ddsCaps.dwCaps, expected_caps[i]); else todo_wine ok(desc.ddsCaps.dwCaps == expected_caps[i], "GetSurfaceDesc test %d returned caps %x, expected %x\n", i, desc.ddsCaps.dwCaps, expected_caps[i]); IDirectDrawSurface_Release(surface1); } } /* Test for differences in ddraw 7 */ hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr); if (FAILED(hr)) { skip("Failed to get IDirectDraw7 interface, skipping tests\n"); } else { for (i = 0; i < sizeof(create_caps) / sizeof(DWORD); i++) { memset(&create2, 0, sizeof(create2)); create2.dwSize = sizeof(create2); create2.ddsCaps.dwCaps = create_caps[i]; create2.dwFlags = DDSD_CAPS; if (!(create2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) { create2.dwFlags |= DDSD_HEIGHT | DDSD_WIDTH; create2.dwHeight = 128; create2.dwWidth = 128; } if (create2.ddsCaps.dwCaps & DDSCAPS_ZBUFFER) { create2.dwFlags |= DDSD_PIXELFORMAT; U4(create2).ddpfPixelFormat.dwSize = sizeof(U4(create2).ddpfPixelFormat); U4(create2).ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; U1(U4(create2).ddpfPixelFormat).dwZBufferBitDepth = 16; U3(U4(create2).ddpfPixelFormat).dwZBitMask = 0x0000FFFF; } hr = IDirectDraw7_CreateSurface(dd7, &create2, &surface7, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); if (SUCCEEDED(hr)) { memset(&desc2, 0, sizeof(desc2)); desc2.dwSize = sizeof(DDSURFACEDESC2); hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &desc2); ok(hr == DD_OK, "IDirectDrawSurface_GetSurfaceDesc failed with %08x\n", hr); if (!(create_caps[i] & DDSCAPS_PRIMARYSURFACE)) ok(desc2.ddsCaps.dwCaps == expected_caps[i], "GetSurfaceDesc test %d returned caps %x, expected %x\n", i, desc2.ddsCaps.dwCaps, expected_caps[i]); else todo_wine ok(desc2.ddsCaps.dwCaps == expected_caps[i], "GetSurfaceDesc test %d returned caps %x, expected %x\n", i, desc2.ddsCaps.dwCaps, expected_caps[i]); IDirectDrawSurface7_Release(surface7); } } IDirectDraw7_Release(dd7); } memset(&create, 0, sizeof(create)); create.dwSize = sizeof(create); create.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; create.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_VIDEOMEMORY; create.dwWidth = 64; create.dwHeight = 64; hr = IDirectDraw_CreateSurface(lpDD, &create, &surface1, NULL); ok(hr == DDERR_INVALIDCAPS, "Creating a SYSMEM | VIDMEM surface returned 0x%08x, expected DDERR_INVALIDCAPS\n", hr); if(surface1) IDirectDrawSurface_Release(surface1); } static BOOL can_create_primary_surface(void) { DDSURFACEDESC ddsd; IDirectDrawSurface *surface; HRESULT hr; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); if(FAILED(hr)) return FALSE; IDirectDrawSurface_Release(surface); return TRUE; } static void dctest_surf(IDirectDrawSurface *surf, int ddsdver) { HRESULT hr; HDC dc, dc2 = (HDC) 0x1234; DDSURFACEDESC ddsd; DDSURFACEDESC2 ddsd2; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); hr = IDirectDrawSurface_GetDC(surf, &dc); ok(hr == DD_OK, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr); hr = IDirectDrawSurface_GetDC(surf, &dc2); ok(hr == DDERR_DCALREADYCREATED, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr); ok(dc2 == (HDC) 0x1234, "The failed GetDC call changed the dc: %p\n", dc2); hr = IDirectDrawSurface_Lock(surf, NULL, ddsdver == 1 ? &ddsd : ((DDSURFACEDESC *) &ddsd2), 0, NULL); ok(hr == DDERR_SURFACEBUSY, "IDirectDrawSurface_Lock returned 0x%08x, expected DDERR_ALREADYLOCKED\n", hr); hr = IDirectDrawSurface_ReleaseDC(surf, dc); ok(hr == DD_OK, "IDirectDrawSurface_ReleaseDC failed: 0x%08x\n", hr); hr = IDirectDrawSurface_ReleaseDC(surf, dc); ok(hr == DDERR_NODC, "IDirectDrawSurface_ReleaseDC returned 0x%08x, expected DDERR_NODC\n", hr); } static void GetDCTest(void) { DDSURFACEDESC ddsd; DDSURFACEDESC2 ddsd2; IDirectDrawSurface *surf; IDirectDrawSurface2 *surf2; IDirectDrawSurface4 *surf4; IDirectDrawSurface7 *surf7; IDirectDrawSurface *tmp; IDirectDrawSurface7 *tmp7; HRESULT hr; IDirectDraw2 *dd2; IDirectDraw4 *dd4; IDirectDraw7 *dd7; HDC dc; ULONG ref; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = 64; ddsd.dwHeight = 64; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd2.dwWidth = 64; ddsd2.dwHeight = 64; ddsd2.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surf, NULL); ok(hr == DD_OK, "IDirectDraw_CreateSurface failed: 0x%08x\n", hr); dctest_surf(surf, 1); IDirectDrawSurface_Release(surf); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2); ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw2_CreateSurface(dd2, &ddsd, &surf, NULL); ok(hr == DD_OK, "IDirectDraw2_CreateSurface failed: 0x%08x\n", hr); dctest_surf(surf, 1); hr = IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface2, (void **) &surf2); ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed: 0x%08x\n", hr); dctest_surf((IDirectDrawSurface *) surf2, 1); IDirectDrawSurface2_Release(surf2); IDirectDrawSurface_Release(surf); IDirectDraw2_Release(dd2); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); surf = NULL; hr = IDirectDraw4_CreateSurface(dd4, &ddsd2, &surf4, NULL); ok(hr == DD_OK, "IDirectDraw4_CreateSurface failed: 0x%08x\n", hr); dctest_surf((IDirectDrawSurface *) surf4, 2); hr = IDirectDrawSurface4_QueryInterface(surf4, &IID_IDirectDrawSurface, (void **)&surf); ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr); ref = getRefcount((IUnknown *) surf); ok(ref == 1, "Refcount is %u, expected 1\n", ref); ref = getRefcount((IUnknown *) surf4); ok(ref == 1, "Refcount is %u, expected 1\n", ref); hr = IDirectDrawSurface4_GetDC(surf4, &dc); ok(SUCCEEDED(hr), "GetDC failed, hr %#x.\n", hr); hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, NULL); ok(hr == E_INVALIDARG, "Expected hr E_INVALIDARG, got %#x.\n", hr); hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, (IDirectDrawSurface4 **)&tmp); ok(SUCCEEDED(hr), "GetSurfaceFromDC failed, hr %#x.\n", hr); ok(tmp == surf, "Expected surface %p, got %p.\n\n", surf, tmp); ref = getRefcount((IUnknown *) surf); ok(ref == 2, "Refcount is %u, expected 2\n", ref); ref = getRefcount((IUnknown *) tmp); ok(ref == 2, "Refcount is %u, expected 2\n", ref); ref = getRefcount((IUnknown *) surf4); ok(ref == 1, "Refcount is %u, expected 1\n", ref); hr = IDirectDrawSurface4_ReleaseDC(surf4, dc); ok(SUCCEEDED(hr), "ReleaseDC failed, hr %#x.\n", hr); IDirectDrawSurface_Release(tmp); dc = CreateCompatibleDC(NULL); ok(!!dc, "CreateCompatibleDC failed.\n"); tmp = (IDirectDrawSurface *)0xdeadbeef; hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, (IDirectDrawSurface4 **)&tmp); ok(hr == DDERR_NOTFOUND, "GetSurfaceFromDC failed, hr %#x.\n", hr); ok(!tmp, "Expected surface NULL, got %p.\n", tmp); ok(DeleteDC(dc), "DeleteDC failed.\n"); tmp = (IDirectDrawSurface *)0xdeadbeef; hr = IDirectDraw4_GetSurfaceFromDC(dd4, NULL, (IDirectDrawSurface4 **)&tmp); ok(hr == DDERR_NOTFOUND, "GetSurfaceFromDC failed, hr %#x.\n", hr); ok(!tmp, "Expected surface NULL, got %p.\n", tmp); IDirectDrawSurface4_Release(surf4); IDirectDrawSurface_Release(surf); IDirectDraw4_Release(dd4); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw7_CreateSurface(dd7, &ddsd2, &surf7, NULL); ok(hr == DD_OK, "IDirectDraw7_CreateSurface failed: 0x%08x\n", hr); dctest_surf((IDirectDrawSurface *) surf7, 2); hr = IDirectDrawSurface7_GetDC(surf7, &dc); ok(SUCCEEDED(hr), "GetDC failed, hr %#x.\n", hr); hr = IDirectDraw7_GetSurfaceFromDC(dd7, dc, NULL); ok(hr == E_INVALIDARG, "Expected hr E_INVALIDARG, got %#x.\n", hr); hr = IDirectDraw7_GetSurfaceFromDC(dd7, dc, &tmp7); ok(SUCCEEDED(hr), "GetSurfaceFromDC failed, hr %#x.\n", hr); ok(tmp7 == surf7, "Expected surface %p, got %p.\n\n", surf7, tmp7); IDirectDrawSurface7_Release(tmp7); hr = IDirectDrawSurface7_ReleaseDC(surf7, dc); ok(SUCCEEDED(hr), "ReleaseDC failed, hr %#x.\n", hr); dc = CreateCompatibleDC(NULL); ok(!!dc, "CreateCompatibleDC failed.\n"); tmp7 = (IDirectDrawSurface7 *)0xdeadbeef; hr = IDirectDraw7_GetSurfaceFromDC(dd7, dc, &tmp7); ok(hr == DDERR_NOTFOUND, "GetSurfaceFromDC failed, hr %#x.\n", hr); ok(!tmp7, "Expected surface NULL, got %p.\n", tmp7); ok(DeleteDC(dc), "DeleteDC failed.\n"); tmp7 = (IDirectDrawSurface7 *)0xdeadbeef; hr = IDirectDraw7_GetSurfaceFromDC(dd7, NULL, (IDirectDrawSurface7 **)&tmp7); ok(hr == DDERR_NOTFOUND, "GetSurfaceFromDC failed, hr %#x.\n", hr); ok(!tmp7, "Expected surface NULL, got %p.\n", tmp7); IDirectDrawSurface7_Release(surf7); IDirectDraw7_Release(dd7); } static void GetDCFormatTest(void) { DDSURFACEDESC2 ddsd; unsigned int i; IDirectDrawSurface7 *surface; IDirectDraw7 *dd7; HRESULT hr; HDC dc; struct { const char *name; DDPIXELFORMAT fmt; BOOL getdc_capable; HRESULT alt_result; } testdata[] = { { "D3DFMT_A8R8G8B8", { sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0, {32}, {0x00ff0000}, {0x0000ff00}, {0x000000ff}, {0xff000000} }, TRUE }, { "D3DFMT_X8R8G8B8", { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, {32}, {0x00ff0000}, {0x0000ff00}, {0x000000ff}, {0x00000000} }, TRUE }, { "D3DFMT_X8B8G8R8", { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, {32}, {0x000000ff}, {0x0000ff00}, {0x00ff0000}, {0x00000000} }, TRUE, DDERR_CANTCREATEDC /* Vista+ */ }, { "D3DFMT_X8B8G8R8", { sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0, {32}, {0x000000ff}, {0x0000ff00}, {0x00ff0000}, {0xff000000} }, TRUE, DDERR_CANTCREATEDC /* Vista+ */ }, { "D3DFMT_A4R4G4B4", { sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0, {16}, {0x00000f00}, {0x000000f0}, {0x0000000f}, {0x0000f000} }, TRUE, DDERR_CANTCREATEDC /* Vista+ */ }, { "D3DFMT_X4R4G4B4", { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, {16}, {0x00000f00}, {0x000000f0}, {0x0000000f}, {0x00000000} }, TRUE, DDERR_CANTCREATEDC /* Vista+ */ }, { "D3DFMT_R5G6B5", { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, {16}, {0x0000F800}, {0x000007E0}, {0x0000001F}, {0x00000000} }, TRUE }, { "D3DFMT_A1R5G5B5", { sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0, {16}, {0x00007C00}, {0x000003E0}, {0x0000001F}, {0x00008000} }, TRUE }, { "D3DFMT_X1R5G5B5", { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, {16}, {0x00007C00}, {0x000003E0}, {0x0000001F}, {0x00000000} }, TRUE }, { "D3DFMT_R3G3B2", { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, { 8}, {0x000000E0}, {0x0000001C}, {0x00000003}, {0x00000000} }, FALSE }, { /* Untested, windows test machine didn't support this format */ "D3DFMT_A2R10G10B10", { sizeof(DDPIXELFORMAT), DDPF_RGB | DDPF_ALPHAPIXELS, 0, {32}, {0xC0000000}, {0x3FF00000}, {0x000FFC00}, {0x000003FF} }, TRUE }, /* * GetDC on a P8 surface fails unless the display mode is 8 bpp. This is not * implemented in wine yet, so disable the test for now. Succeeding P8 getDC * calls are tested in the ddraw.visual test. * { "D3DFMT_P8", { sizeof(DDPIXELFORMAT), DDPF_PALETTEINDEXED8 | DDPF_RGB, 0, {8 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000} }, FALSE }, */ { "D3DFMT_L8", { sizeof(DDPIXELFORMAT), DDPF_LUMINANCE, 0, {8 }, {0x000000ff}, {0x00000000}, {0x00000000}, {0x00000000} }, FALSE }, { "D3DFMT_A8L8", { sizeof(DDPIXELFORMAT), DDPF_ALPHAPIXELS | DDPF_LUMINANCE, 0, {16}, {0x000000ff}, {0x00000000}, {0x00000000}, {0x0000ff00} }, FALSE }, { "D3DFMT_DXT1", { sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','1'), {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000} }, FALSE }, { "D3DFMT_DXT2", { sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','2'), {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000} }, FALSE }, { "D3DFMT_DXT3", { sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','3'), {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000} }, FALSE }, { "D3DFMT_DXT4", { sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','4'), {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000} }, FALSE }, { "D3DFMT_DXT5", { sizeof(DDPIXELFORMAT), DDPF_FOURCC, MAKEFOURCC('D','X','T','5'), {0 }, {0x00000000}, {0x00000000}, {0x00000000}, {0x00000000} }, FALSE }, }; hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(hr == DD_OK, "IDirectDraw_QueryInterface failed, hr = 0x%08x\n", hr); for(i = 0; i < (sizeof(testdata) / sizeof(testdata[0])); i++) { memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.dwWidth = 64; ddsd.dwHeight = 64; U4(ddsd).ddpfPixelFormat = testdata[i].fmt; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); if(FAILED(hr)) { ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE; ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); if(FAILED(hr)) { skip("IDirectDraw7_CreateSurface failed, hr = 0x%08x, format %s\n", hr, testdata[i].name); continue; } } dc = (void *) 0x1234; hr = IDirectDrawSurface7_GetDC(surface, &dc); if(testdata[i].getdc_capable) { ok(SUCCEEDED(hr) || (testdata[i].alt_result && hr == testdata[i].alt_result), "GetDC on a %s surface failed(0x%08x), expected it to work\n", testdata[i].name, hr); } else { ok(FAILED(hr), "GetDC on a %s surface succeeded(0x%08x), expected it to fail\n", testdata[i].name, hr); } if(SUCCEEDED(hr)) { hr = IDirectDrawSurface7_ReleaseDC(surface, dc); ok(hr == DD_OK, "IDirectDrawSurface7_ReleaseDC failed, hr = 0x%08x\n", hr); dc = 0; } else { ok(dc == NULL, "After failed GetDC dc is %p\n", dc); } IDirectDrawSurface7_Release(surface); } IDirectDraw7_Release(dd7); } static void BackBufferCreateSurfaceTest(void) { DDSURFACEDESC ddsd; DDSURFACEDESC created_ddsd; DDSURFACEDESC2 ddsd2; IDirectDrawSurface *surf; IDirectDrawSurface4 *surf4; IDirectDrawSurface7 *surf7; HRESULT hr; IDirectDraw2 *dd2; IDirectDraw4 *dd4; IDirectDraw7 *dd7; const DWORD caps = DDSCAPS_BACKBUFFER; const DWORD expected_caps = DDSCAPS_BACKBUFFER | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM; if (!(ddcaps.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) { skip("DDraw reported no VIDEOMEMORY cap. Broken video driver? Skipping surface caps tests.\n"); return ; } memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = 64; ddsd.dwHeight = 64; ddsd.ddsCaps.dwCaps = caps; memset(&ddsd2, 0, sizeof(ddsd2)); ddsd2.dwSize = sizeof(ddsd2); ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd2.dwWidth = 64; ddsd2.dwHeight = 64; ddsd2.ddsCaps.dwCaps = caps; memset(&created_ddsd, 0, sizeof(created_ddsd)); created_ddsd.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surf, NULL); ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed: 0x%08x\n", hr); if (surf != NULL) { hr = IDirectDrawSurface_GetSurfaceDesc(surf, &created_ddsd); ok(SUCCEEDED(hr), "IDirectDraw_GetSurfaceDesc failed: 0x%08x\n", hr); ok(created_ddsd.ddsCaps.dwCaps == expected_caps, "GetSurfaceDesc returned caps %x, expected %x\n", created_ddsd.ddsCaps.dwCaps, expected_caps); IDirectDrawSurface_Release(surf); } hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2); ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw2_CreateSurface(dd2, &ddsd, &surf, NULL); ok(hr == DDERR_INVALIDCAPS, "IDirectDraw2_CreateSurface didn't return %x08x, but %x08x\n", DDERR_INVALIDCAPS, hr); IDirectDraw2_Release(dd2); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw4_CreateSurface(dd4, &ddsd2, &surf4, NULL); ok(hr == DDERR_INVALIDCAPS, "IDirectDraw4_CreateSurface didn't return %x08x, but %x08x\n", DDERR_INVALIDCAPS, hr); IDirectDraw4_Release(dd4); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw7_CreateSurface(dd7, &ddsd2, &surf7, NULL); ok(hr == DDERR_INVALIDCAPS, "IDirectDraw7_CreateSurface didn't return %x08x, but %x08x\n", DDERR_INVALIDCAPS, hr); IDirectDraw7_Release(dd7); } static void BackBufferAttachmentFlipTest(void) { HRESULT hr; IDirectDrawSurface *surface1, *surface2, *surface3, *surface4; DDSURFACEDESC ddsd; HWND window = CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL ); hr = IDirectDraw_SetCooperativeLevel(lpDD, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr); /* Perform attachment tests on a back-buffer */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN); ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN); hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface2, NULL); ok(SUCCEEDED(hr), "CreateSurface returned: %x\n",hr); if (surface2 != NULL) { /* Try a single primary and a two back buffers */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface1, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; ddsd.dwWidth = GetSystemMetrics(SM_CXSCREEN); ddsd.dwHeight = GetSystemMetrics(SM_CYSCREEN); hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface3, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); /* This one has a different size */ memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; ddsd.dwWidth = 128; ddsd.dwHeight = 128; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface4, NULL); ok(hr==DD_OK,"CreateSurface returned: %x\n",hr); hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface2); todo_wine ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE), "Attaching a back buffer to a front buffer returned %08x\n", hr); if(SUCCEEDED(hr)) { /* Try flipping the surfaces */ hr = IDirectDrawSurface_Flip(surface1, NULL, DDFLIP_WAIT); todo_wine ok(hr == DD_OK, "IDirectDrawSurface_Flip returned 0x%08x\n", hr); hr = IDirectDrawSurface_Flip(surface2, NULL, DDFLIP_WAIT); todo_wine ok(hr == DDERR_NOTFLIPPABLE, "IDirectDrawSurface_Flip returned 0x%08x\n", hr); /* Try the reverse without detaching first */ hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface1); ok(hr == DDERR_SURFACEALREADYATTACHED, "Attaching an attached surface to its attachee returned %08x\n", hr); hr = IDirectDrawSurface_DeleteAttachedSurface(surface1, 0, surface2); ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr); } hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface1); todo_wine ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE), "Attaching a front buffer to a back buffer returned %08x\n", hr); if(SUCCEEDED(hr)) { /* Try flipping the surfaces */ hr = IDirectDrawSurface_Flip(surface1, NULL, DDFLIP_WAIT); todo_wine ok(hr == DD_OK, "IDirectDrawSurface_Flip returned 0x%08x\n", hr); hr = IDirectDrawSurface_Flip(surface2, NULL, DDFLIP_WAIT); todo_wine ok(hr == DDERR_NOTFLIPPABLE, "IDirectDrawSurface_Flip returned 0x%08x\n", hr); /* Try to detach reversed */ hr = IDirectDrawSurface_DeleteAttachedSurface(surface1, 0, surface2); ok(hr == DDERR_CANNOTDETACHSURFACE, "DeleteAttachedSurface returned %08x\n", hr); /* Now the proper detach */ hr = IDirectDrawSurface_DeleteAttachedSurface(surface2, 0, surface1); ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr); } hr = IDirectDrawSurface_AddAttachedSurface(surface2, surface3); todo_wine ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE), "Attaching a back buffer to another back buffer returned %08x\n", hr); if(SUCCEEDED(hr)) { /* Try flipping the surfaces */ hr = IDirectDrawSurface_Flip(surface3, NULL, DDFLIP_WAIT); todo_wine ok(hr == DD_OK, "IDirectDrawSurface_Flip returned 0x%08x\n", hr); hr = IDirectDrawSurface_Flip(surface2, NULL, DDFLIP_WAIT); todo_wine ok(hr == DDERR_NOTFLIPPABLE, "IDirectDrawSurface_Flip returned 0x%08x\n", hr); hr = IDirectDrawSurface_Flip(surface1, NULL, DDFLIP_WAIT); ok(hr == DDERR_NOTFLIPPABLE, "IDirectDrawSurface_Flip returned 0x%08x\n", hr); hr = IDirectDrawSurface_DeleteAttachedSurface(surface2, 0, surface3); ok(hr == DD_OK, "DeleteAttachedSurface failed with %08x\n", hr); } hr = IDirectDrawSurface_AddAttachedSurface(surface1, surface4); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a back buffer to a front buffer of different size returned %08x\n", hr); hr = IDirectDrawSurface_AddAttachedSurface(surface4, surface1); ok(hr == DDERR_CANNOTATTACHSURFACE, "Attaching a front buffer to a back buffer of different size returned %08x\n", hr); IDirectDrawSurface_Release(surface4); IDirectDrawSurface_Release(surface3); IDirectDrawSurface_Release(surface2); IDirectDrawSurface_Release(surface1); } hr =IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "SetCooperativeLevel returned %08x\n", hr); DestroyWindow(window); } static void CreateSurfaceBadCapsSizeTest(void) { DDSURFACEDESC ddsd_ok; DDSURFACEDESC ddsd_bad1; DDSURFACEDESC ddsd_bad2; DDSURFACEDESC ddsd_bad3; DDSURFACEDESC ddsd_bad4; DDSURFACEDESC2 ddsd2_ok; DDSURFACEDESC2 ddsd2_bad1; DDSURFACEDESC2 ddsd2_bad2; DDSURFACEDESC2 ddsd2_bad3; DDSURFACEDESC2 ddsd2_bad4; IDirectDrawSurface *surf; IDirectDrawSurface4 *surf4; IDirectDrawSurface7 *surf7; HRESULT hr; IDirectDraw2 *dd2; IDirectDraw4 *dd4; IDirectDraw7 *dd7; const DWORD caps = DDSCAPS_OFFSCREENPLAIN; memset(&ddsd_ok, 0, sizeof(ddsd_ok)); ddsd_ok.dwSize = sizeof(ddsd_ok); ddsd_ok.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd_ok.dwWidth = 64; ddsd_ok.dwHeight = 64; ddsd_ok.ddsCaps.dwCaps = caps; memcpy(&ddsd_bad1, &ddsd_ok, sizeof(ddsd_bad1)); ddsd_bad1.dwSize--; memcpy(&ddsd_bad2, &ddsd_ok, sizeof(ddsd_bad2)); ddsd_bad2.dwSize++; memcpy(&ddsd_bad3, &ddsd_ok, sizeof(ddsd_bad3)); ddsd_bad3.dwSize = 0; memcpy(&ddsd_bad4, &ddsd_ok, sizeof(ddsd_bad4)); ddsd_bad4.dwSize = sizeof(DDSURFACEDESC2); memset(&ddsd2_ok, 0, sizeof(ddsd2_ok)); ddsd2_ok.dwSize = sizeof(ddsd2_ok); ddsd2_ok.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd2_ok.dwWidth = 64; ddsd2_ok.dwHeight = 64; ddsd2_ok.ddsCaps.dwCaps = caps; memcpy(&ddsd2_bad1, &ddsd2_ok, sizeof(ddsd2_bad1)); ddsd2_bad1.dwSize--; memcpy(&ddsd2_bad2, &ddsd2_ok, sizeof(ddsd2_bad2)); ddsd2_bad2.dwSize++; memcpy(&ddsd2_bad3, &ddsd2_ok, sizeof(ddsd2_bad3)); ddsd2_bad3.dwSize = 0; memcpy(&ddsd2_bad4, &ddsd2_ok, sizeof(ddsd2_bad4)); ddsd2_bad4.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDraw_CreateSurface(lpDD, &ddsd_ok, &surf, NULL); ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed: 0x%08x\n", hr); IDirectDrawSurface_Release(surf); hr = IDirectDraw_CreateSurface(lpDD, &ddsd_bad1, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw_CreateSurface(lpDD, &ddsd_bad2, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw_CreateSurface(lpDD, &ddsd_bad3, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw_CreateSurface(lpDD, &ddsd_bad4, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw_CreateSurface(lpDD, NULL, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &dd2); ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw2_CreateSurface(dd2, &ddsd_ok, &surf, NULL); ok(SUCCEEDED(hr), "IDirectDraw2_CreateSurface failed: 0x%08x\n", hr); IDirectDrawSurface_Release(surf); hr = IDirectDraw2_CreateSurface(dd2, &ddsd_bad1, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw2_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw2_CreateSurface(dd2, &ddsd_bad2, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw2_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw2_CreateSurface(dd2, &ddsd_bad3, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw2_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw2_CreateSurface(dd2, &ddsd_bad4, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw2_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw2_CreateSurface(dd2, NULL, &surf, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw2_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); IDirectDraw2_Release(dd2); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw4_CreateSurface(dd4, &ddsd2_ok, &surf4, NULL); ok(SUCCEEDED(hr), "IDirectDraw4_CreateSurface failed: 0x%08x\n", hr); IDirectDrawSurface4_Release(surf4); hr = IDirectDraw4_CreateSurface(dd4, &ddsd2_bad1, &surf4, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw4_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw4_CreateSurface(dd4, &ddsd2_bad2, &surf4, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw4_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw4_CreateSurface(dd4, &ddsd2_bad3, &surf4, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw4_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw4_CreateSurface(dd4, &ddsd2_bad4, &surf4, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw4_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw4_CreateSurface(dd4, NULL, &surf4, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw4_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); IDirectDraw4_Release(dd4); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw7_CreateSurface(dd7, &ddsd2_ok, &surf7, NULL); ok(SUCCEEDED(hr), "IDirectDraw7_CreateSurface failed: 0x%08x\n", hr); IDirectDrawSurface7_Release(surf7); hr = IDirectDraw7_CreateSurface(dd7, &ddsd2_bad1, &surf7, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw7_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw7_CreateSurface(dd7, &ddsd2_bad2, &surf7, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw7_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw7_CreateSurface(dd7, &ddsd2_bad3, &surf7, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw7_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw7_CreateSurface(dd7, &ddsd2_bad4, &surf7, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw7_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); hr = IDirectDraw7_CreateSurface(dd7, NULL, &surf7, NULL); ok(hr == DDERR_INVALIDPARAMS, "IDirectDraw7_CreateSurface didn't return 0x%08x, but 0x%08x\n", DDERR_INVALIDPARAMS, hr); IDirectDraw7_Release(dd7); } static void reset_ddsd(DDSURFACEDESC *ddsd) { memset(ddsd, 0, sizeof(*ddsd)); ddsd->dwSize = sizeof(*ddsd); } static void no_ddsd_caps_test(void) { DDSURFACEDESC ddsd; HRESULT hr; IDirectDrawSurface *surface; reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed, hr %#x.\n", hr); reset_ddsd(&ddsd); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &ddsd); IDirectDrawSurface_Release(surface); ok(ddsd.dwFlags & DDSD_CAPS, "DDSD_CAPS is not set\n"); ok(ddsd.ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN, "DDSCAPS_OFFSCREENPLAIN is not set\n"); reset_ddsd(&ddsd); ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed, hr %#x.\n", hr); reset_ddsd(&ddsd); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &ddsd); IDirectDrawSurface_Release(surface); ok(ddsd.dwFlags & DDSD_CAPS, "DDSD_CAPS is not set\n"); ok(ddsd.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE, "DDSCAPS_OFFSCREENPLAIN is not set\n"); reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(hr == DDERR_INVALIDCAPS, "IDirectDraw_CreateSurface returned %#x, expected DDERR_INVALIDCAPS.\n", hr); } static void dump_format(const DDPIXELFORMAT *fmt) { trace("dwFlags %08x, FourCC %08x, dwZBufferBitDepth %u, stencil %u\n", fmt->dwFlags, fmt->dwFourCC, U1(*fmt).dwZBufferBitDepth, U2(*fmt).dwStencilBitDepth); trace("dwZBitMask %08x, dwStencilBitMask %08x, dwRGBZBitMask %08x\n", U3(*fmt).dwZBitMask, U4(*fmt).dwStencilBitMask, U5(*fmt).dwRGBZBitMask); } static void zbufferbitdepth_test(void) { enum zfmt_succeed { ZFMT_SUPPORTED_ALWAYS, ZFMT_SUPPORTED_NEVER, ZFMT_SUPPORTED_HWDEPENDENT }; struct { DWORD depth; enum zfmt_succeed supported; DDPIXELFORMAT pf; } test_data[] = { { 16, ZFMT_SUPPORTED_ALWAYS, { sizeof(DDPIXELFORMAT), DDPF_ZBUFFER, 0, {16}, {0}, {0x0000ffff}, {0x00000000}, {0x00000000} } }, { 24, ZFMT_SUPPORTED_HWDEPENDENT, { sizeof(DDPIXELFORMAT), DDPF_ZBUFFER, 0, {24}, {0}, {0x00ffffff}, {0x00000000}, {0x00000000} } }, { 32, ZFMT_SUPPORTED_HWDEPENDENT, { sizeof(DDPIXELFORMAT), DDPF_ZBUFFER, 0, {32}, {0}, {0xffffffff}, {0x00000000}, {0x00000000} } }, /* Returns DDERR_INVALIDPARAMS instead of DDERR_INVALIDPIXELFORMAT. * Disabled for now { 0, ZFMT_SUPPORTED_NEVER }, */ { 15, ZFMT_SUPPORTED_NEVER }, { 28, ZFMT_SUPPORTED_NEVER }, { 40, ZFMT_SUPPORTED_NEVER }, }; DDSURFACEDESC ddsd; IDirectDrawSurface *surface; HRESULT hr; unsigned int i; DDCAPS caps; memset(&caps, 0, sizeof(caps)); caps.dwSize = sizeof(caps); hr = IDirectDraw_GetCaps(lpDD, &caps, NULL); ok(SUCCEEDED(hr), "IDirectDraw_GetCaps failed, hr %#x.\n", hr); if (!(caps.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)) { skip("Z buffers not supported, skipping DDSD_ZBUFFERBITDEPTH test\n"); return; } for (i = 0; i < (sizeof(test_data) / sizeof(*test_data)); i++) { reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_ZBUFFERBITDEPTH; ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; ddsd.dwWidth = 256; ddsd.dwHeight = 256; U2(ddsd).dwZBufferBitDepth = test_data[i].depth; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); if (test_data[i].supported == ZFMT_SUPPORTED_ALWAYS) { ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed, hr %#x.\n", hr); } else if (test_data[i].supported == ZFMT_SUPPORTED_NEVER) { ok(hr == DDERR_INVALIDPIXELFORMAT, "IDirectDraw_CreateSurface returned %#x, expected %x.\n", hr, DDERR_INVALIDPIXELFORMAT); } if (!surface) continue; reset_ddsd(&ddsd); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &ddsd); ok(SUCCEEDED(hr), "IDirectDrawSurface_GetSurfaceDesc failed, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); ok(ddsd.dwFlags & DDSD_ZBUFFERBITDEPTH, "DDSD_ZBUFFERBITDEPTH is not set\n"); ok(!(ddsd.dwFlags & DDSD_PIXELFORMAT), "DDSD_PIXELFORMAT is set\n"); /* Yet the ddpfPixelFormat member contains valid data */ if (memcmp(&ddsd.ddpfPixelFormat, &test_data[i].pf, ddsd.ddpfPixelFormat.dwSize)) { ok(0, "Unexpected format for depth %u\n", test_data[i].depth); dump_format(&ddsd.ddpfPixelFormat); } } /* DDSD_ZBUFFERBITDEPTH vs DDSD_PIXELFORMAT? */ reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_ZBUFFERBITDEPTH; ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; ddsd.dwWidth = 256; ddsd.dwHeight = 256; U2(ddsd).dwZBufferBitDepth = 24; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; U1(ddsd.ddpfPixelFormat).dwZBufferBitDepth = 16; U3(ddsd.ddpfPixelFormat).dwZBitMask = 0x0000ffff; surface = NULL; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed, hr %#x.\n", hr); if (!surface) return; reset_ddsd(&ddsd); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &ddsd); ok(SUCCEEDED(hr), "IDirectDrawSurface_GetSurfaceDesc failed, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); ok(U1(ddsd.ddpfPixelFormat).dwZBufferBitDepth == 16, "Expected a 16bpp depth buffer, got %ubpp\n", U1(ddsd.ddpfPixelFormat).dwZBufferBitDepth); ok(ddsd.dwFlags & DDSD_ZBUFFERBITDEPTH, "DDSD_ZBUFFERBITDEPTH is not set\n"); ok(!(ddsd.dwFlags & DDSD_PIXELFORMAT), "DDSD_PIXELFORMAT is set\n"); ok(U2(ddsd).dwZBufferBitDepth == 16, "Expected dwZBufferBitDepth=16, got %u\n", U2(ddsd).dwZBufferBitDepth); /* DDSD_PIXELFORMAT vs invalid ZBUFFERBITDEPTH */ reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; ddsd.dwWidth = 256; ddsd.dwHeight = 256; U2(ddsd).dwZBufferBitDepth = 40; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; U1(ddsd.ddpfPixelFormat).dwZBufferBitDepth = 16; U3(ddsd.ddpfPixelFormat).dwZBitMask = 0x0000ffff; surface = NULL; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed, hr %#x.\n", hr); if (surface) IDirectDrawSurface_Release(surface); /* Create a PIXELFORMAT-only surface, see if ZBUFFERBITDEPTH is set */ reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; ddsd.dwWidth = 256; ddsd.dwHeight = 256; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; U1(ddsd.ddpfPixelFormat).dwZBufferBitDepth = 16; U3(ddsd.ddpfPixelFormat).dwZBitMask = 0x0000ffff; surface = NULL; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "IDirectDrawSurface_GetSurfaceDesc failed, hr %#x.\n", hr); reset_ddsd(&ddsd); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &ddsd); ok(SUCCEEDED(hr), "IDirectDrawSurface_GetSurfaceDesc failed, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); ok(U1(ddsd.ddpfPixelFormat).dwZBufferBitDepth == 16, "Expected a 16bpp depth buffer, got %ubpp\n", U1(ddsd.ddpfPixelFormat).dwZBufferBitDepth); ok(ddsd.dwFlags & DDSD_ZBUFFERBITDEPTH, "DDSD_ZBUFFERBITDEPTH is not set\n"); ok(!(ddsd.dwFlags & DDSD_PIXELFORMAT), "DDSD_PIXELFORMAT is set\n"); ok(U2(ddsd).dwZBufferBitDepth == 16, "Expected dwZBufferBitDepth=16, got %u\n", U2(ddsd).dwZBufferBitDepth); } static void test_ddsd(DDSURFACEDESC *ddsd, BOOL expect_pf, BOOL expect_zd, const char *name, DWORD z_bit_depth) { IDirectDrawSurface *surface; IDirectDrawSurface7 *surface7; HRESULT hr; DDSURFACEDESC out; DDSURFACEDESC2 out2; hr = IDirectDraw_CreateSurface(lpDD, ddsd, &surface, NULL); if (hr == DDERR_NOZBUFFERHW) { skip("Z buffers not supported, skipping Z flag test\n"); return; } ok(SUCCEEDED(hr), "IDirectDraw_CreateSurface failed, hr %#x.\n", hr); hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface7, (void **) &surface7); ok(SUCCEEDED(hr), "IDirectDrawSurface_QueryInterface failed, hr %#x.\n", hr); reset_ddsd(&out); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &out); ok(SUCCEEDED(hr), "IDirectDrawSurface_GetSurfaceDesc failed, hr %#x.\n", hr); memset(&out2, 0, sizeof(out2)); out2.dwSize = sizeof(out2); hr = IDirectDrawSurface7_GetSurfaceDesc(surface7, &out2); ok(SUCCEEDED(hr), "IDirectDrawSurface_GetSurfaceDesc failed, hr %#x.\n", hr); if (expect_pf) { ok(out.dwFlags & DDSD_PIXELFORMAT, "%s surface: Expected DDSD_PIXELFORMAT to be set\n", name); ok(out2.dwFlags & DDSD_PIXELFORMAT, "%s surface: Expected DDSD_PIXELFORMAT to be set in DDSURFACEDESC2\n", name); } else { ok(!(out.dwFlags & DDSD_PIXELFORMAT), "%s surface: Expected DDSD_PIXELFORMAT not to be set\n", name); ok(out2.dwFlags & DDSD_PIXELFORMAT, "%s surface: Expected DDSD_PIXELFORMAT to be set in DDSURFACEDESC2\n", name); } if (expect_zd) { ok(out.dwFlags & DDSD_ZBUFFERBITDEPTH, "%s surface: Expected DDSD_ZBUFFERBITDEPTH to be set\n", name); ok(U2(out).dwZBufferBitDepth == z_bit_depth, "ZBufferBitDepth is %u, expected %u\n", U2(out).dwZBufferBitDepth, z_bit_depth); ok(!(out2.dwFlags & DDSD_ZBUFFERBITDEPTH), "%s surface: Did not expect DDSD_ZBUFFERBITDEPTH to be set in DDSURFACEDESC2\n", name); /* dwMipMapCount and dwZBufferBitDepth share the same union */ ok(U2(out2).dwMipMapCount == 0, "dwMipMapCount is %u, expected 0\n", U2(out2).dwMipMapCount); } else { ok(!(out.dwFlags & DDSD_ZBUFFERBITDEPTH), "%s surface: Expected DDSD_ZBUFFERBITDEPTH not to be set\n", name); ok(U2(out).dwZBufferBitDepth == 0, "ZBufferBitDepth is %u, expected 0\n", U2(out).dwZBufferBitDepth); ok(!(out2.dwFlags & DDSD_ZBUFFERBITDEPTH), "%s surface: Did not expect DDSD_ZBUFFERBITDEPTH to be set in DDSURFACEDESC2\n", name); ok(U2(out2).dwMipMapCount == 0, "dwMipMapCount is %u, expected 0\n", U2(out2).dwMipMapCount); } reset_ddsd(&out); hr = IDirectDrawSurface_Lock(surface, NULL, &out, 0, NULL); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface_Unlock(surface, NULL); ok(SUCCEEDED(hr), "IDirectDrawSurface_GetSurfaceDesc failed, hr %#x.\n", hr); /* DDSD_ZBUFFERBITDEPTH is never set on Nvidia, but follows GetSurfaceDesc rules on AMD */ if (!expect_zd) { ok(!(out.dwFlags & DDSD_ZBUFFERBITDEPTH), "Lock %s surface: Expected DDSD_ZBUFFERBITDEPTH not to be set\n", name); } /* DDSD_PIXELFORMAT follows GetSurfaceDesc rules */ if (expect_pf) { ok(out.dwFlags & DDSD_PIXELFORMAT, "%s surface: Expected DDSD_PIXELFORMAT to be set\n", name); } else { ok(!(out.dwFlags & DDSD_PIXELFORMAT), "Lock %s surface: Expected DDSD_PIXELFORMAT not to be set\n", name); } if (out.dwFlags & DDSD_ZBUFFERBITDEPTH) ok(U2(out).dwZBufferBitDepth == z_bit_depth, "ZBufferBitDepth is %u, expected %u\n", U2(out).dwZBufferBitDepth, z_bit_depth); else ok(U2(out).dwZBufferBitDepth == 0, "ZBufferBitDepth is %u, expected 0\n", U2(out).dwZBufferBitDepth); } hr = IDirectDrawSurface7_Lock(surface7, NULL, &out2, 0, NULL); ok(SUCCEEDED(hr), "IDirectDrawSurface7_Lock failed, hr %#x.\n", hr); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_Unlock(surface7, NULL); ok(SUCCEEDED(hr), "IDirectDrawSurface7_Unlock failed, hr %#x.\n", hr); /* DDSD_PIXELFORMAT is always set, DDSD_ZBUFFERBITDEPTH never */ ok(out2.dwFlags & DDSD_PIXELFORMAT, "Lock %s surface: Expected DDSD_PIXELFORMAT to be set in DDSURFACEDESC2\n", name); ok(!(out2.dwFlags & DDSD_ZBUFFERBITDEPTH), "Lock %s surface: Did not expect DDSD_ZBUFFERBITDEPTH to be set in DDSURFACEDESC2\n", name); ok(U2(out2).dwMipMapCount == 0, "dwMipMapCount is %u, expected 0\n", U2(out2).dwMipMapCount); } IDirectDrawSurface7_Release(surface7); IDirectDrawSurface_Release(surface); } static void pixelformat_flag_test(void) { DDSURFACEDESC ddsd; DDCAPS caps; HRESULT hr; memset(&caps, 0, sizeof(caps)); caps.dwSize = sizeof(caps); hr = IDirectDraw_GetCaps(lpDD, &caps, NULL); ok(SUCCEEDED(hr), "IDirectDraw_GetCaps failed, hr %#x.\n", hr); if (!(caps.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)) { skip("Z buffers not supported, skipping DDSD_PIXELFORMAT test\n"); return; } reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = 64; ddsd.dwHeight = 64; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; test_ddsd(&ddsd, TRUE, FALSE, "offscreen plain", ~0U); reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; test_ddsd(&ddsd, TRUE, FALSE, "primary", ~0U); reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_ZBUFFERBITDEPTH; ddsd.dwWidth = 64; ddsd.dwHeight = 64; U2(ddsd).dwZBufferBitDepth = 16; ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; test_ddsd(&ddsd, FALSE, TRUE, "Z buffer", 16); } static void set_surface_desc_test(void) { HRESULT hr; DDSURFACEDESC ddsd; IDirectDrawSurface *surface; IDirectDrawSurface3 *surface3; BYTE data[16*16*4]; reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT; ddsd.dwWidth = 8; ddsd.dwHeight = 8; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff; ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x.\n", hr); hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface3, (void **) &surface3); ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_LPSURFACE; ddsd.lpSurface = data; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(SUCCEEDED(hr), "SetSurfaceDesc failed, hr %#x.\n", hr); /* Redundantly setting the same lpSurface is not an error */ hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(SUCCEEDED(hr), "SetSurfaceDesc failed, hr %#x.\n", hr); hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 1); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, NULL, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); IDirectDrawSurface_Release(surface3); reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT; ddsd.dwWidth = 8; ddsd.dwHeight = 8; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff; ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x.\n", hr); hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface3, (void **) &surface3); ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); hr = IDirectDrawSurface3_GetSurfaceDesc(surface3, &ddsd); ok(SUCCEEDED(hr), "GetSurfaceDesc failed, hr %#x.\n", hr); /* Setting the caps is an error. This also means the original description cannot be reapplied */ hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_CAPS; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); /* TODO: The INVALIDCAPS return value suggests that some caps can be set. */ ddsd.dwFlags = DDSD_CAPS | DDSD_LPSURFACE; ddsd.lpSurface = data; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDCAPS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDCAPS); ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDCAPS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDCAPS); /* Setting the height is allowed, but it cannot be set to 0, and only if LPSURFACE is set too */ reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_HEIGHT; ddsd.dwHeight = 16; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.lpSurface = data; ddsd.dwFlags = DDSD_HEIGHT | DDSD_LPSURFACE; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(SUCCEEDED(hr), "SetSurfaceDesc failed, hr %#x.\n", hr); ddsd.dwHeight = 0; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); reset_ddsd(&ddsd); hr = IDirectDrawSurface3_GetSurfaceDesc(surface3, &ddsd); ok(SUCCEEDED(hr), "GetSurfaceDesc failed, hr %#x.\n", hr); ok(ddsd.dwWidth == 8, "SetSurfaceDesc: Expected width 8, got %u.\n", ddsd.dwWidth); ok(ddsd.dwHeight == 16, "SetSurfaceDesc: Expected height 16, got %u.\n", ddsd.dwHeight); /* Pitch and width can be set, but only together, and only with LPSURFACE. They must not be 0 */ reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_PITCH; U1(ddsd).lPitch = 8 * 4; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_WIDTH; ddsd.dwWidth = 16; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_PITCH | DDSD_LPSURFACE; ddsd.lpSurface = data; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_WIDTH | DDSD_LPSURFACE; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_WIDTH | DDSD_PITCH | DDSD_LPSURFACE; U1(ddsd).lPitch = 16 * 4; ddsd.dwWidth = 16; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(SUCCEEDED(hr), "SetSurfaceDesc failed, hr %#x.\n", hr); reset_ddsd(&ddsd); hr = IDirectDrawSurface3_GetSurfaceDesc(surface3, &ddsd); ok(SUCCEEDED(hr), "GetSurfaceDesc failed, hr %#x.\n", hr); ok(ddsd.dwWidth == 16, "SetSurfaceDesc: Expected width 8, got %u.\n", ddsd.dwWidth); ok(ddsd.dwHeight == 16, "SetSurfaceDesc: Expected height 16, got %u.\n", ddsd.dwHeight); ok(U1(ddsd).lPitch == 16 * 4, "SetSurfaceDesc: Expected pitch 64, got %u.\n", U1(ddsd).lPitch); /* The pitch must be 32 bit aligned and > 0, but is not verified for sanity otherwise * * VMware rejects those calls, but all real drivers accept it. Mark the VMware behavior broken. */ ddsd.dwFlags = DDSD_WIDTH | DDSD_PITCH | DDSD_LPSURFACE; U1(ddsd).lPitch = 4 * 4; ddsd.lpSurface = data; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(SUCCEEDED(hr) || broken(hr == DDERR_INVALIDPARAMS), "SetSurfaceDesc failed, hr %#x.\n", hr); U1(ddsd).lPitch = 4; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(SUCCEEDED(hr) || broken(hr == DDERR_INVALIDPARAMS), "SetSurfaceDesc failed, hr %#x.\n", hr); U1(ddsd).lPitch = 16 * 4 + 1; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); U1(ddsd).lPitch = 16 * 4 + 3; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); U1(ddsd).lPitch = -4; /* lPitch is signed */ hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); U1(ddsd).lPitch = 16 * 4; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(SUCCEEDED(hr), "SetSurfaceDesc failed, hr %#x.\n", hr); reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_PITCH | DDSD_LPSURFACE; U1(ddsd).lPitch = 0; ddsd.dwWidth = 16; ddsd.lpSurface = data; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_WIDTH | DDSD_PITCH | DDSD_LPSURFACE; U1(ddsd).lPitch = 16 * 4; ddsd.dwWidth = 0; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); /* Setting the pixelformat without lpsurface is an error, but with LPSURFACE it works */ ddsd.dwFlags = DDSD_PIXELFORMAT; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_PIXELFORMAT | DDSD_LPSURFACE; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DD_OK, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DD_OK); /* Can't set color keys */ reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_CKSRCBLT; ddsd.ddckCKSrcBlt.dwColorSpaceLowValue = 0x00ff0000; ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = 0x00ff0000; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); ddsd.dwFlags = DDSD_CKSRCBLT | DDSD_LPSURFACE; ddsd.lpSurface = data; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDPARAMS, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDPARAMS); IDirectDrawSurface_Release(surface3); /* Need systemmemory surfaces * * As a sidenote, fourcc surfaces aren't allowed in sysmem, thus testing DDSD_LINEARSIZE is moot */ reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT; ddsd.dwWidth = 8; ddsd.dwHeight = 8; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32; U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000; U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00; U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff; ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); ok(SUCCEEDED(hr) || hr == DDERR_NODIRECTDRAWHW, "CreateSurface failed, hr %#x.\n", hr); if (FAILED(hr)) { skip("Cannot create a video memory surface, skipping vidmem SetSurfaceDesc test.\n"); return; } hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface3, (void **) &surface3); ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); reset_ddsd(&ddsd); ddsd.dwFlags = DDSD_LPSURFACE; ddsd.lpSurface = data; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDSURFACETYPE, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDSURFACETYPE); ddsd.dwFlags = DDSD_WIDTH; hr = IDirectDrawSurface3_SetSurfaceDesc(surface3, &ddsd, 0); ok(hr == DDERR_INVALIDSURFACETYPE, "SetSurfaceDesc returned %#x, expected %#x.\n", hr, DDERR_INVALIDSURFACETYPE); IDirectDrawSurface3_Release(surface3); } static BOOL fourcc_supported(DWORD fourcc, DWORD caps) { DDSURFACEDESC ddsd; HRESULT hr; IDirectDrawSurface *surface; reset_ddsd(&ddsd); ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 4; ddsd.dwHeight = 4; ddsd.ddsCaps.dwCaps = caps; ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC; ddsd.ddpfPixelFormat.dwFourCC = fourcc; hr = IDirectDraw_CreateSurface(lpDD, &ddsd, &surface, NULL); if (FAILED(hr)) { return FALSE; } IDirectDrawSurface_Release(surface); return TRUE; } static void partial_block_lock_test(void) { IDirectDrawSurface7 *surface; HRESULT hr; DDSURFACEDESC2 ddsd; IDirectDraw7 *dd7; const struct { DWORD caps, caps2; const char *name; BOOL success; } pools[] = { { DDSCAPS_VIDEOMEMORY, 0, "D3DPOOL_DEFAULT", FALSE }, { DDSCAPS_SYSTEMMEMORY, 0, "D3DPOOL_SYSTEMMEM", TRUE }, { 0, DDSCAPS2_TEXTUREMANAGE, "D3DPOOL_MANAGED", TRUE } }; const struct { DWORD fourcc; DWORD caps; const char *name; unsigned int block_width; unsigned int block_height; } formats[] = { {MAKEFOURCC('D','X','T','1'), DDSCAPS_TEXTURE, "D3DFMT_DXT1", 4, 4}, {MAKEFOURCC('D','X','T','2'), DDSCAPS_TEXTURE, "D3DFMT_DXT2", 4, 4}, {MAKEFOURCC('D','X','T','3'), DDSCAPS_TEXTURE, "D3DFMT_DXT3", 4, 4}, {MAKEFOURCC('D','X','T','4'), DDSCAPS_TEXTURE, "D3DFMT_DXT4", 4, 4}, {MAKEFOURCC('D','X','T','5'), DDSCAPS_TEXTURE, "D3DFMT_DXT5", 4, 4}, /* ATI2N surfaces aren't available in ddraw */ {MAKEFOURCC('U','Y','V','Y'), DDSCAPS_OVERLAY, "D3DFMT_UYVY", 2, 1}, {MAKEFOURCC('Y','U','Y','2'), DDSCAPS_OVERLAY, "D3DFMT_YUY2", 2, 1}, }; unsigned int i, j; RECT rect; hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7); ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr); for (i = 0; i < sizeof(formats) / sizeof(formats[0]); i++) { if (!fourcc_supported(formats[i].fourcc, formats[i].caps | DDSCAPS_VIDEOMEMORY)) { skip("%s surfaces not supported, skipping partial block lock test\n", formats[i].name); continue; } for (j = 0; j < (sizeof(pools) / sizeof(*pools)); j++) { if (formats[i].caps & DDSCAPS_OVERLAY && !(pools[j].caps & DDSCAPS_VIDEOMEMORY)) continue; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; ddsd.dwWidth = 128; ddsd.dwHeight = 128; ddsd.ddsCaps.dwCaps = pools[j].caps | formats[i].caps; ddsd.ddsCaps.dwCaps2 = pools[j].caps2; U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_FOURCC; U4(ddsd).ddpfPixelFormat.dwFourCC = formats[i].fourcc; hr = IDirectDraw7_CreateSurface(dd7, &ddsd, &surface, NULL); ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x, format %s, pool %s\n", hr, formats[i].name, pools[j].name); /* All Windows versions allow partial block locks with DDSCAPS_SYSTEMMEMORY and * DDSCAPS2_TEXTUREMANAGE, just like in d3d8 and d3d9. Windows XP also allows those locks * with DDSCAPS_VIDEOMEMORY. Windows Vista and Windows 7 disallow partial locks of vidmem * surfaces, making the ddraw behavior consistent with d3d8 and 9. * * Mark the Windows XP behavior as broken until we find an application that needs it */ if (formats[i].block_width > 1) { SetRect(&rect, formats[i].block_width >> 1, 0, formats[i].block_width, formats[i].block_height); hr = IDirectDrawSurface7_Lock(surface, &rect, &ddsd, 0, NULL); ok(!SUCCEEDED(hr) == !pools[j].success || broken(SUCCEEDED(hr)), "Partial block lock %s, expected %s, format %s, pool %s\n", SUCCEEDED(hr) ? "succeeded" : "failed", pools[j].success ? "success" : "failure", formats[i].name, pools[j].name); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed, hr %#x.\n", hr); } SetRect(&rect, 0, 0, formats[i].block_width >> 1, formats[i].block_height); hr = IDirectDrawSurface7_Lock(surface, &rect, &ddsd, 0, NULL); ok(!SUCCEEDED(hr) == !pools[j].success || broken(SUCCEEDED(hr)), "Partial block lock %s, expected %s, format %s, pool %s\n", SUCCEEDED(hr) ? "succeeded" : "failed", pools[j].success ? "success" : "failure", formats[i].name, pools[j].name); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed, hr %#x.\n", hr); } } if (formats[i].block_height > 1) { SetRect(&rect, 0, formats[i].block_height >> 1, formats[i].block_width, formats[i].block_height); hr = IDirectDrawSurface7_Lock(surface, &rect, &ddsd, 0, NULL); ok(!SUCCEEDED(hr) == !pools[j].success || broken(SUCCEEDED(hr)), "Partial block lock %s, expected %s, format %s, pool %s\n", SUCCEEDED(hr) ? "succeeded" : "failed", pools[j].success ? "success" : "failure", formats[i].name, pools[j].name); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed, hr %#x.\n", hr); } SetRect(&rect, 0, 0, formats[i].block_width, formats[i].block_height >> 1); hr = IDirectDrawSurface7_Lock(surface, &rect, &ddsd, 0, NULL); ok(!SUCCEEDED(hr) == !pools[j].success || broken(SUCCEEDED(hr)), "Partial block lock %s, expected %s, format %s, pool %s\n", SUCCEEDED(hr) ? "succeeded" : "failed", pools[j].success ? "success" : "failure", formats[i].name, pools[j].name); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed, hr %#x.\n", hr); } } SetRect(&rect, 0, 0, formats[i].block_width, formats[i].block_height); hr = IDirectDrawSurface7_Lock(surface, &rect, &ddsd, 0, NULL); ok(SUCCEEDED(hr), "Full block lock returned %08x, expected %08x, format %s, pool %s\n", hr, DD_OK, formats[i].name, pools[j].name); if (SUCCEEDED(hr)) { hr = IDirectDrawSurface7_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Unlock failed, hr %#x.\n", hr); } IDirectDrawSurface7_Release(surface); } } IDirectDraw7_Release(dd7); } static void create_surface_test(void) { HRESULT hr; IDirectDraw2 *ddraw2; IDirectDraw4 *ddraw4; IDirectDraw7 *ddraw7; IDirectDrawSurface *surface; IDirectDrawSurface4 *surface4; IDirectDrawSurface7 *surface7; hr = IDirectDraw_CreateSurface(lpDD, NULL, &surface, NULL); ok(hr == DDERR_INVALIDPARAMS, "CreateSurface(ddsd=NULL) returned %#x," " expected %#x.\n", hr, DDERR_INVALIDPARAMS); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2, (void **) &ddraw2); ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr); hr = IDirectDraw2_CreateSurface(ddraw2, NULL, &surface, NULL); ok(hr == DDERR_INVALIDPARAMS, "CreateSurface(ddsd=NULL) returned %#x," " expected %#x.\n", hr, DDERR_INVALIDPARAMS); IDirectDraw2_Release(ddraw2); hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &ddraw4); ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr); hr = IDirectDraw4_CreateSurface(ddraw4, NULL, &surface4, NULL); ok(hr == DDERR_INVALIDPARAMS, "CreateSurface(ddsd=NULL) returned %#x," " expected %#x.\n", hr, DDERR_INVALIDPARAMS); IDirectDraw4_Release(ddraw4); if (!pDirectDrawCreateEx) { skip("DirectDrawCreateEx not available, skipping IDirectDraw7 tests.\n"); return; } hr = pDirectDrawCreateEx(NULL, (void **) &ddraw7, &IID_IDirectDraw7, NULL); ok(SUCCEEDED(hr), "DirectDrawCreateEx failed, hr %#x.\n", hr); hr = IDirectDraw7_CreateSurface(ddraw7, NULL, &surface7, NULL); ok(hr == DDERR_NOCOOPERATIVELEVELSET, "CreateSurface(ddsd=NULL, pre-SCL) returned %#x," " expected %#x.\n", hr, DDERR_NOCOOPERATIVELEVELSET); hr = IDirectDraw7_SetCooperativeLevel(ddraw7, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "SetCooperativeLevel failed, hr %#x.\n", hr); hr = IDirectDraw7_CreateSurface(ddraw7, NULL, &surface7, NULL); ok(hr == DDERR_INVALIDPARAMS, "CreateSurface(ddsd=NULL) returned %#x," " expected %#x.\n", hr, DDERR_INVALIDPARAMS); IDirectDraw7_Release(ddraw7); } START_TEST(dsurface) { HRESULT ret; IDirectDraw4 *dd4; HMODULE ddraw_mod = GetModuleHandleA("ddraw.dll"); pDirectDrawCreateEx = (void *) GetProcAddress(ddraw_mod, "DirectDrawCreateEx"); if (!CreateDirectDraw()) return; ret = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void **) &dd4); if (ret == E_NOINTERFACE) { win_skip("DirectDraw4 and higher are not supported\n"); ReleaseDirectDraw(); return; } IDirectDraw_Release(dd4); if(!can_create_primary_surface()) { skip("Unable to create primary surface\n"); return; } ddcaps.dwSize = sizeof(DDCAPS); ret = IDirectDraw_GetCaps(lpDD, &ddcaps, NULL); if (ret != DD_OK) { skip("IDirectDraw_GetCaps failed with %08x\n", ret); return; } MipMapCreationTest(); SrcColorKey32BlitTest(); QueryInterface(); GetDDInterface_1(); GetDDInterface_2(); GetDDInterface_4(); GetDDInterface_7(); EnumTest(); AttachmentTest(); AttachmentTest7(); CubeMapTest(); test_lockrect_invalid(); CompressedTest(); SizeTest(); PrivateDataTest(); BltParamTest(); StructSizeTest(); PaletteTest(); SurfaceCapsTest(); GetDCTest(); GetDCFormatTest(); BackBufferCreateSurfaceTest(); BackBufferAttachmentFlipTest(); CreateSurfaceBadCapsSizeTest(); no_ddsd_caps_test(); zbufferbitdepth_test(); pixelformat_flag_test(); set_surface_desc_test(); partial_block_lock_test(); create_surface_test(); ReleaseDirectDraw(); }