gmane.comp.emulators.wine.patches

[PATCH 2/3] dmusic: Cleanup IDirectMusic8Impl_QueryInterface.

Christian Costa — 2012-05-24T06:50:32

---
 dlls/dmusic/dmusic.c |   33 +++++++++++++++++++--------------
 1 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/dlls/dmusic/dmusic.c b/dlls/dmusic/dmusic.c
index 8afe2cc..9c93ba8 100644
--- a/dlls/dmusic/dmusic.c
+++ b/dlls/dmusic/dmusic.c
< at >< at > -31,22 +31,27 < at >< at > static inline IDirectMusic8Impl *impl_from_IDirectMusic8(IDirectMusic8 *iface)
 }
 
 /* IDirectMusic8Impl IUnknown part: */
-static HRESULT WINAPI IDirectMusic8Impl_QueryInterface(LPDIRECTMUSIC8 iface, REFIID riid, LPVOID *ppobj)
+static HRESULT WINAPI IDirectMusic8Impl_QueryInterface(LPDIRECTMUSIC8 iface, REFIID riid, LPVOID *ret_iface)
 {
-IDirectMusic8Impl *This = impl_from_IDirectMusic8(iface);
-TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
-
-if (IsEqualIID (riid, &IID_IUnknown) || 
-    IsEqualIID (riid, &IID_IDirectMusic) ||
-    IsEqualIID (riid, &IID_IDirectMusic2) ||
-    IsEqualIID (riid, &IID_IDirectMusic8)) {
-IUnknown_AddRef(iface);
-*ppobj = This;
-return S_OK;
-}
+    IDirectMusic8Impl *This = impl_from_IDirectMusic8(iface);
 
-WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
-return E_NOINTERFACE;
+    TRACE("(%p)->(%s, %p)\n", iface, debugstr_dmguid(riid), ret_iface);
+
+    if (IsEqualIID (riid, &IID_IUnknown) ||
+        IsEqualIID (riid, &IID_IDirectMusic) ||
+        IsEqualIID (riid, &IID_IDirectMusic2) ||
+        IsEqualIID (riid, &IID_IDirectMusic8))
+    {
+        IDirectMusic8_AddRef(iface);
+        *ret_iface = iface;
+        return S_OK;
+    }
+
+    *ret_iface = NULL;
+
+    WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ret_iface);
+
+    return E_NOINTERFACE;
 }
 
 static ULONG WINAPI IDirectMusic8Impl_AddRef(LPDIRECTMUSIC8 iface)

[PATCH 1/3] dmusic: Display new ref in trace for AddRef and Releasefor direct music object.

Christian Costa — 2012-05-24T06:50:24

---
 dlls/dmusic/dmusic.c |   34 ++++++++++++++++++----------------
 1 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/dlls/dmusic/dmusic.c b/dlls/dmusic/dmusic.c
index 1a00236..8afe2cc 100644
--- a/dlls/dmusic/dmusic.c
+++ b/dlls/dmusic/dmusic.c
< at >< at > -1,6 +1,8 < at >< at >
-/* IDirectMusic8 Implementation
+/*
+ * IDirectMusic8 Implementation
  *
  * Copyright (C) 2003-2004 Rok Mandeljc
+ * Copyright (C) 2012 Christian Costa
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
< at >< at > -49,31 +51,31 < at >< at > static HRESULT WINAPI IDirectMusic8Impl_QueryInterface(LPDIRECTMUSIC8 iface, REF
 
 static ULONG WINAPI IDirectMusic8Impl_AddRef(LPDIRECTMUSIC8 iface)
 {
-IDirectMusic8Impl *This = impl_from_IDirectMusic8(iface);
-ULONG refCount = InterlockedIncrement(&This->ref);
+    IDirectMusic8Impl *This = impl_from_IDirectMusic8(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
 
-TRACE("(%p)->(ref before=%u)\n", This, refCount - 1);
+    TRACE("(%p)->(): new ref = %u\n", This, ref);
 
-DMUSIC_LockModule();
+    DMUSIC_LockModule();
 
-return refCount;
+    return ref;
 }
 
 static ULONG WINAPI IDirectMusic8Impl_Release(LPDIRECTMUSIC8 iface)
 {
-IDirectMusic8Impl *This = impl_from_IDirectMusic8(iface);
-ULONG refCount = InterlockedDecrement(&This->ref);
+    IDirectMusic8Impl *This = impl_from_IDirectMusic8(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
 
-TRACE("(%p)->(ref before=%u)\n", This, refCount + 1);
+    TRACE("(%p)->(): new ref = %u\n", This, ref);
 
-if (!refCount) {
-HeapFree(GetProcessHeap(), 0, This->ppPorts);
-HeapFree(GetProcessHeap(), 0, This);
-}
+    if (!ref) {
+        HeapFree(GetProcessHeap(), 0, This->ppPorts);
+        HeapFree(GetProcessHeap(), 0, This);
+    }
 
-DMUSIC_UnlockModule();
-
-return refCount;
+    DMUSIC_UnlockModule();
+
+    return ref;
 }
 
 /* IDirectMusic8Impl IDirectMusic part: */

[PATCH 3/3] dmusic: Cleanup DMUSIC_CreateDirectMusicImpl.

Christian Costa — 2012-05-24T06:50:39

---
 dlls/dmusic/dmusic.c |   42 +++++++++++++++++++++++++-----------------
 1 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/dlls/dmusic/dmusic.c b/dlls/dmusic/dmusic.c
index 9c93ba8..900f514 100644
--- a/dlls/dmusic/dmusic.c
+++ b/dlls/dmusic/dmusic.c
< at >< at > -369,23 +369,31 < at >< at > static const IDirectMusic8Vtbl DirectMusic8_Vtbl = {
 IDirectMusic8Impl_SetExternalMasterClock
 };
 
-/* for ClassFactory */
-HRESULT WINAPI DMUSIC_CreateDirectMusicImpl (LPCGUID lpcGUID, LPVOID* ppobj, LPUNKNOWN pUnkOuter) {
-IDirectMusic8Impl *dmusic;
+/* For ClassFactory */
+HRESULT WINAPI DMUSIC_CreateDirectMusicImpl(LPCGUID riid, LPVOID* ret_iface, LPUNKNOWN unkouter)
+{
+    IDirectMusic8Impl *dmusic;
+    HRESULT ret;
 
-TRACE("(%p,%p,%p)\n",lpcGUID, ppobj, pUnkOuter);
+    TRACE("(%p,%p,%p)\n", riid, ret_iface, unkouter);
 
-dmusic = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusic8Impl));
-if (NULL == dmusic) {
-*ppobj = NULL;
-return E_OUTOFMEMORY;
-}
-dmusic->IDirectMusic8_iface.lpVtbl = &DirectMusic8_Vtbl;
-dmusic->ref = 0; /* will be inited with QueryInterface */
-dmusic->pMasterClock = NULL;
-dmusic->ppPorts = NULL;
-dmusic->nrofports = 0;
-DMUSIC_CreateReferenceClockImpl (&IID_IReferenceClock, (LPVOID*)&dmusic->pMasterClock, NULL);
-
-return IDirectMusic8Impl_QueryInterface ((LPDIRECTMUSIC8)dmusic, lpcGUID, ppobj);
+    dmusic = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusic8Impl));
+    if (!dmusic) {
+        *ret_iface = NULL;
+        return E_OUTOFMEMORY;
+    }
+    dmusic->IDirectMusic8_iface.lpVtbl = &DirectMusic8_Vtbl;
+    dmusic->ref = 0; /* Will be inited by QueryInterface */
+    dmusic->pMasterClock = NULL;
+    dmusic->ppPorts = NULL;
+    dmusic->nrofports = 0;
+    DMUSIC_CreateReferenceClockImpl(&IID_IReferenceClock, (LPVOID*)&dmusic->pMasterClock, NULL);
+
+    ret = IDirectMusic8Impl_QueryInterface(&dmusic->IDirectMusic8_iface, riid, ret_iface);
+    if (FAILED(ret)) {
+        HeapFree(GetProcessHeap(), 0, dmusic);
+        return ret;
+    }
+
+    return S_OK;
 }

[PATCH 2/2] d3drm: Add stub interface for IDirectTextureX.

Christian Costa — 2012-05-24T06:50:02

---
 dlls/d3drm/Makefile.in     |    1 
 dlls/d3drm/d3drm_private.h |    1 
 dlls/d3drm/texture.c       |  843 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 845 insertions(+), 0 deletions(-)
 create mode 100644 dlls/d3drm/texture.c

diff --git a/dlls/d3drm/Makefile.in b/dlls/d3drm/Makefile.in
index 9c1d1a5..0802430 100644
--- a/dlls/d3drm/Makefile.in
+++ b/dlls/d3drm/Makefile.in
< at >< at > -11,6 +11,7 < at >< at > C_SRCS = \
 material.c \
 math.c \
 meshbuilder.c \
+texture.c \
 viewport.c
 
 RC_SRCS = version.rc
diff --git a/dlls/d3drm/d3drm_private.h b/dlls/d3drm/d3drm_private.h
index ae56124..3a8982d 100644
--- a/dlls/d3drm/d3drm_private.h
+++ b/dlls/d3drm/d3drm_private.h
< at >< at > -31,6 +31,7 < at >< at > HRESULT Direct3DRMLight_create(IUnknown** ppObj) DECLSPEC_HIDDEN;
 HRESULT Direct3DRMMeshBuilder_create(REFIID riid, IUnknown** ppObj) DECLSPEC_HIDDEN;
 HRESULT Direct3DRMViewport_create(REFIID riid, IUnknown** ppObj) DECLSPEC_HIDDEN;
 HRESULT Direct3DRMMaterial_create(IDirect3DRMMaterial2** ret_iface) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMTexture_create(REFIID riid, IUnknown** ret_iface) DECLSPEC_HIDDEN;
 
 HRESULT load_mesh_data(IDirect3DRMMeshBuilder3* iface, LPDIRECTXFILEDATA pData) DECLSPEC_HIDDEN;
 
diff --git a/dlls/d3drm/texture.c b/dlls/d3drm/texture.c
new file mode 100644
index 0000000..44a9061
--- /dev/null
+++ b/dlls/d3drm/texture.c
< at >< at > -0,0 +1,843 < at >< at >
+/*
+ * Implementation of IDirect3DRMTextureX interfaces
+ *
+ * Copyright 2012 Christian Costa
+ *
+ * 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
+ */
+
+#include "wine/debug.h"
+
+#define COBJMACROS
+
+#include "winbase.h"
+#include "wingdi.h"
+
+#include "d3drm_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
+
+typedef struct {
+    IDirect3DRMTexture2 IDirect3DRMTexture2_iface;
+    IDirect3DRMTexture3 IDirect3DRMTexture3_iface;
+    LONG ref;
+} IDirect3DRMTextureImpl;
+
+static inline IDirect3DRMTextureImpl *impl_from_IDirect3DRMTexture2(IDirect3DRMTexture2 *iface)
+{
+    return CONTAINING_RECORD(iface, IDirect3DRMTextureImpl, IDirect3DRMTexture2_iface);
+}
+
+static inline IDirect3DRMTextureImpl *impl_from_IDirect3DRMTexture3(IDirect3DRMTexture3 *iface)
+{
+    return CONTAINING_RECORD(iface, IDirect3DRMTextureImpl, IDirect3DRMTexture3_iface);
+}
+
+/*** IUnknown methods ***/
+static HRESULT WINAPI IDirect3DRMTexture2Impl_QueryInterface(IDirect3DRMTexture2* iface,
+                                                             REFIID riid, void** object)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), object);
+
+    *object = NULL;
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+        IsEqualGUID(riid, &IID_IDirect3DRMTexture) ||
+        IsEqualGUID(riid, &IID_IDirect3DRMTexture2))
+    {
+        *object = &This->IDirect3DRMTexture2_iface;
+    }
+    else if IsEqualGUID(riid, &IID_IDirect3DRMTexture3)
+    {
+        *object = &This->IDirect3DRMTexture3_iface;
+    }
+    else
+    {
+        FIXME("Interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IDirect3DRMTexture3_AddRef(iface);
+
+    return S_OK;
+}
+
+static ULONG WINAPI IDirect3DRMTexture2Impl_AddRef(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p)->(): new ref = %d\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI IDirect3DRMTexture2Impl_Release(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p)->(): new ref = %d\n", iface, ref);
+
+    if (!ref)
+        HeapFree(GetProcessHeap(), 0, This);
+
+    return ref;
+}
+
+/*** IDirect3DRMObject methods ***/
+static HRESULT WINAPI IDirect3DRMTexture2Impl_Clone(IDirect3DRMTexture2* iface,
+                                                    LPUNKNOWN unknown, REFIID riid,
+                                                    LPVOID* object)
+{
+    FIXME("(%p)->(%p, %s, %p): stub\n", iface, unknown, debugstr_guid(riid), object);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_AddDestroyCallback(IDirect3DRMTexture2* iface,
+                                                                 D3DRMOBJECTCALLBACK cb,
+                                                                 LPVOID argument)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, cb, argument);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_DeleteDestroyCallback(IDirect3DRMTexture2* iface,
+                                                                    D3DRMOBJECTCALLBACK cb,
+                                                                    LPVOID argument)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, cb, argument);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetAppData(IDirect3DRMTexture2* iface,
+                                                          DWORD data)
+{
+    FIXME("(%p)->(%u): stub\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI IDirect3DRMTexture2Impl_GetAppData(IDirect3DRMTexture2* iface)
+{
+    FIXME("(%p)->(): stub\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetName(IDirect3DRMTexture2* iface, LPCSTR name)
+{
+    FIXME("(%p)->(%s): stub\n", iface, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_GetName(IDirect3DRMTexture2* iface,
+                                                      LPDWORD size, LPSTR name)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_GetClassName(IDirect3DRMTexture2* iface,
+                                                           LPDWORD size, LPSTR name)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+/*** IDirect3DRMTexture3 methods ***/
+static HRESULT WINAPI IDirect3DRMTexture2Impl_InitFromFile(IDirect3DRMTexture2* iface, const char *filename)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%s): stub\n", iface, This, debugstr_a(filename));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_InitFromSurface(IDirect3DRMTexture2* iface, LPDIRECTDRAWSURFACE surface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_InitFromResource(IDirect3DRMTexture2* iface, HRSRC resource)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%p): stub\n", iface, This, resource);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_Changed(IDirect3DRMTexture2* iface, BOOL pixels, BOOL palette)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%u, %u): stub\n", iface, This, pixels, palette);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetColors(IDirect3DRMTexture2* iface, DWORD max_colors)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, max_colors);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetShades(IDirect3DRMTexture2* iface, DWORD max_shades)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, max_shades);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetDecalSize(IDirect3DRMTexture2* iface, D3DVALUE width, D3DVALUE height)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%f, %f): stub\n", iface, This, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetDecalOrigin(IDirect3DRMTexture2* iface, LONG x, LONG y)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%d, %d): stub\n", iface, This, x, y);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetDecalScale(IDirect3DRMTexture2* iface, DWORD scale)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, scale);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetDecalTransparency(IDirect3DRMTexture2* iface, BOOL transparency)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, transparency);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_SetDecalTransparentColor(IDirect3DRMTexture2* iface, D3DCOLOR color)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%x): stub\n", iface, This, color);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_GetDecalSize(IDirect3DRMTexture2* iface, D3DVALUE* width, D3DVALUE* height)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, height, width);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_GetDecalOrigin(IDirect3DRMTexture2* iface, LONG* x, LONG* y)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, x, y);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMIMAGE* WINAPI IDirect3DRMTexture2Impl_GetImage(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return NULL;
+}
+
+static DWORD WINAPI IDirect3DRMTexture2Impl_GetShades(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+static DWORD WINAPI IDirect3DRMTexture2Impl_GetColors(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+static DWORD WINAPI IDirect3DRMTexture2Impl_GetDecalScale(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+static BOOL WINAPI IDirect3DRMTexture2Impl_GetDecalTransparency(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return FALSE;
+}
+
+static D3DCOLOR WINAPI IDirect3DRMTexture2Impl_GetDecalTransparentColor(IDirect3DRMTexture2* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+/*** IDirect3DRMTexture2 methods ***/
+static HRESULT WINAPI IDirect3DRMTexture2Impl_InitFromImage(IDirect3DRMTexture2* iface, LPD3DRMIMAGE image)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%p): stub\n", iface, This, image);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_InitFromResource2(IDirect3DRMTexture2* iface, HMODULE module,
+                                                               LPCSTR /* LPCTSTR */ name, LPCSTR /* LPCTSTR */ type)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%p, %s, %s): stub\n", iface, This, module, debugstr_a(name), debugstr_a(type));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture2Impl_GenerateMIPMap(IDirect3DRMTexture2* iface, DWORD flags)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture2(iface);
+
+    FIXME("(%p/%p)->(%x): stub\n", iface, This, flags);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMTexture2Vtbl Direct3DRMTexture2_Vtbl =
+{
+    /*** IUnknown methods ***/
+    IDirect3DRMTexture2Impl_QueryInterface,
+    IDirect3DRMTexture2Impl_AddRef,
+    IDirect3DRMTexture2Impl_Release,
+    /*** IDirect3DRMObject methods ***/
+    IDirect3DRMTexture2Impl_Clone,
+    IDirect3DRMTexture2Impl_AddDestroyCallback,
+    IDirect3DRMTexture2Impl_DeleteDestroyCallback,
+    IDirect3DRMTexture2Impl_SetAppData,
+    IDirect3DRMTexture2Impl_GetAppData,
+    IDirect3DRMTexture2Impl_SetName,
+    IDirect3DRMTexture2Impl_GetName,
+    IDirect3DRMTexture2Impl_GetClassName,
+    /*** IDirect3DRMTexture methods ***/
+    IDirect3DRMTexture2Impl_InitFromFile,
+    IDirect3DRMTexture2Impl_InitFromSurface,
+    IDirect3DRMTexture2Impl_InitFromResource,
+    IDirect3DRMTexture2Impl_Changed,
+    IDirect3DRMTexture2Impl_SetColors,
+    IDirect3DRMTexture2Impl_SetShades,
+    IDirect3DRMTexture2Impl_SetDecalSize,
+    IDirect3DRMTexture2Impl_SetDecalOrigin,
+    IDirect3DRMTexture2Impl_SetDecalScale,
+    IDirect3DRMTexture2Impl_SetDecalTransparency,
+    IDirect3DRMTexture2Impl_SetDecalTransparentColor,
+    IDirect3DRMTexture2Impl_GetDecalSize,
+    IDirect3DRMTexture2Impl_GetDecalOrigin,
+    IDirect3DRMTexture2Impl_GetImage,
+    IDirect3DRMTexture2Impl_GetShades,
+    IDirect3DRMTexture2Impl_GetColors,
+    IDirect3DRMTexture2Impl_GetDecalScale,
+    IDirect3DRMTexture2Impl_GetDecalTransparency,
+    IDirect3DRMTexture2Impl_GetDecalTransparentColor,
+    /*** IDirect3DRMTexture2 methods ***/
+    IDirect3DRMTexture2Impl_InitFromImage,
+    IDirect3DRMTexture2Impl_InitFromResource2,
+    IDirect3DRMTexture2Impl_GenerateMIPMap
+};
+
+/*** IUnknown methods ***/
+static HRESULT WINAPI IDirect3DRMTexture3Impl_QueryInterface(IDirect3DRMTexture3* iface,
+                                                           REFIID riid, void** object)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), object);
+
+    *object = NULL;
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+        IsEqualGUID(riid, &IID_IDirect3DRMTexture) ||
+        IsEqualGUID(riid, &IID_IDirect3DRMTexture2))
+    {
+        *object = &This->IDirect3DRMTexture2_iface;
+    }
+    else if IsEqualGUID(riid, &IID_IDirect3DRMTexture3)
+    {
+        *object = &This->IDirect3DRMTexture3_iface;
+    }
+    else
+    {
+        FIXME("Interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IDirect3DRMTexture3_AddRef(iface);
+
+    return S_OK;
+}
+
+static ULONG WINAPI IDirect3DRMTexture3Impl_AddRef(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p)->(): new ref = %d\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI IDirect3DRMTexture3Impl_Release(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p)->(): new ref = %d\n", iface, ref);
+
+    if (!ref)
+        HeapFree(GetProcessHeap(), 0, This);
+
+    return ref;
+}
+
+/*** IDirect3DRMObject methods ***/
+static HRESULT WINAPI IDirect3DRMTexture3Impl_Clone(IDirect3DRMTexture3* iface,
+                                                     LPUNKNOWN unknown, REFIID riid,
+                                                     LPVOID* object)
+{
+    FIXME("(%p)->(%p, %s, %p): stub\n", iface, unknown, debugstr_guid(riid), object);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_AddDestroyCallback(IDirect3DRMTexture3* iface,
+                                                                  D3DRMOBJECTCALLBACK cb,
+                                                                  LPVOID argument)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, cb, argument);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_DeleteDestroyCallback(IDirect3DRMTexture3* iface,
+                                                                     D3DRMOBJECTCALLBACK cb,
+                                                                     LPVOID argument)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, cb, argument);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetAppData(IDirect3DRMTexture3* iface,
+                                                          DWORD data)
+{
+    FIXME("(%p)->(%u): stub\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI IDirect3DRMTexture3Impl_GetAppData(IDirect3DRMTexture3* iface)
+{
+    FIXME("(%p)->(): stub\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetName(IDirect3DRMTexture3* iface, LPCSTR name)
+{
+    FIXME("(%p)->(%s): stub\n", iface, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_GetName(IDirect3DRMTexture3* iface,
+                                                       LPDWORD size, LPSTR name)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_GetClassName(IDirect3DRMTexture3* iface,
+                                                           LPDWORD size, LPSTR name)
+{
+    FIXME("(%p)->(%p, %p): stub\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+/*** IDirect3DRMTexture3 methods ***/
+static HRESULT WINAPI IDirect3DRMTexture3Impl_InitFromFile(IDirect3DRMTexture3* iface, const char *filename)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%s): stub\n", iface, This, debugstr_a(filename));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_InitFromSurface(IDirect3DRMTexture3* iface, LPDIRECTDRAWSURFACE surface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_InitFromResource(IDirect3DRMTexture3* iface, HRSRC resource)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p): stub\n", iface, This, resource);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_Changed(IDirect3DRMTexture3* iface, DWORD flags, DWORD nb_rects, LPRECT rects)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%x, %u, %p): stub\n", iface, This, flags, nb_rects, rects);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetColors(IDirect3DRMTexture3* iface, DWORD max_colors)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, max_colors);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetShades(IDirect3DRMTexture3* iface, DWORD max_shades)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, max_shades);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetDecalSize(IDirect3DRMTexture3* iface, D3DVALUE width, D3DVALUE height)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%f, %f): stub\n", iface, This, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetDecalOrigin(IDirect3DRMTexture3* iface, LONG x, LONG y)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%d, %d): stub\n", iface, This, x, y);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetDecalScale(IDirect3DRMTexture3* iface, DWORD scale)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, scale);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetDecalTransparency(IDirect3DRMTexture3* iface, BOOL transparency)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%u): stub\n", iface, This, transparency);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetDecalTransparentColor(IDirect3DRMTexture3* iface, D3DCOLOR color)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%x): stub\n", iface, This, color);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_GetDecalSize(IDirect3DRMTexture3* iface, D3DVALUE* width, D3DVALUE* height)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, height, width);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_GetDecalOrigin(IDirect3DRMTexture3* iface, LONG* x, LONG* y)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, x, y);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMIMAGE* WINAPI IDirect3DRMTexture3Impl_GetImage(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return NULL;
+}
+
+static DWORD WINAPI IDirect3DRMTexture3Impl_GetShades(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+static DWORD WINAPI IDirect3DRMTexture3Impl_GetColors(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+static DWORD WINAPI IDirect3DRMTexture3Impl_GetDecalScale(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+static BOOL WINAPI IDirect3DRMTexture3Impl_GetDecalTransparency(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return FALSE;
+}
+
+static D3DCOLOR WINAPI IDirect3DRMTexture3Impl_GetDecalTransparentColor(IDirect3DRMTexture3* iface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(): stub\n", iface, This);
+
+    return 0;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_InitFromImage(IDirect3DRMTexture3* iface, LPD3DRMIMAGE image)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p): stub\n", iface, This, image);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_InitFromResource2(IDirect3DRMTexture3* iface, HMODULE module,
+                                                               LPCSTR /* LPCTSTR */ name, LPCSTR /* LPCTSTR */ type)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p, %s, %s): stub\n", iface, This, module, debugstr_a(name), debugstr_a(type));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_GenerateMIPMap(IDirect3DRMTexture3* iface, DWORD flags)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%x): stub\n", iface, This, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_GetSurface(IDirect3DRMTexture3* iface, DWORD flags, LPDIRECTDRAWSURFACE* surface)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%x, %p): stub\n", iface, This, flags, surface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetCacheOptions(IDirect3DRMTexture3* iface, LONG importance, DWORD flags)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%d, %x): stub\n", iface, This, importance, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_GetCacheOptions(IDirect3DRMTexture3* iface, LPLONG importance, LPDWORD flags)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, importance, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetDownsampleCallback(IDirect3DRMTexture3* iface, D3DRMDOWNSAMPLECALLBACK callback, LPVOID arg)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, callback, arg);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDirect3DRMTexture3Impl_SetValidationCallback(IDirect3DRMTexture3* iface, D3DRMVALIDATIONCALLBACK callback, LPVOID arg)
+{
+    IDirect3DRMTextureImpl *This = impl_from_IDirect3DRMTexture3(iface);
+
+    FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, callback, arg);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMTexture3Vtbl Direct3DRMTexture3_Vtbl =
+{
+    /*** IUnknown methods ***/
+    IDirect3DRMTexture3Impl_QueryInterface,
+    IDirect3DRMTexture3Impl_AddRef,
+    IDirect3DRMTexture3Impl_Release,
+    /*** IDirect3DRMObject methods ***/
+    IDirect3DRMTexture3Impl_Clone,
+    IDirect3DRMTexture3Impl_AddDestroyCallback,
+    IDirect3DRMTexture3Impl_DeleteDestroyCallback,
+    IDirect3DRMTexture3Impl_SetAppData,
+    IDirect3DRMTexture3Impl_GetAppData,
+    IDirect3DRMTexture3Impl_SetName,
+    IDirect3DRMTexture3Impl_GetName,
+    IDirect3DRMTexture3Impl_GetClassName,
+    /*** IDirect3DRMTexture3 methods ***/
+    IDirect3DRMTexture3Impl_InitFromFile,
+    IDirect3DRMTexture3Impl_InitFromSurface,
+    IDirect3DRMTexture3Impl_InitFromResource,
+    IDirect3DRMTexture3Impl_Changed,
+    IDirect3DRMTexture3Impl_SetColors,
+    IDirect3DRMTexture3Impl_SetShades,
+    IDirect3DRMTexture3Impl_SetDecalSize,
+    IDirect3DRMTexture3Impl_SetDecalOrigin,
+    IDirect3DRMTexture3Impl_SetDecalScale,
+    IDirect3DRMTexture3Impl_SetDecalTransparency,
+    IDirect3DRMTexture3Impl_SetDecalTransparentColor,
+    IDirect3DRMTexture3Impl_GetDecalSize,
+    IDirect3DRMTexture3Impl_GetDecalOrigin,
+    IDirect3DRMTexture3Impl_GetImage,
+    IDirect3DRMTexture3Impl_GetShades,
+    IDirect3DRMTexture3Impl_GetColors,
+    IDirect3DRMTexture3Impl_GetDecalScale,
+    IDirect3DRMTexture3Impl_GetDecalTransparency,
+    IDirect3DRMTexture3Impl_GetDecalTransparentColor,
+    IDirect3DRMTexture3Impl_InitFromImage,
+    IDirect3DRMTexture3Impl_InitFromResource2,
+    IDirect3DRMTexture3Impl_GenerateMIPMap,
+    IDirect3DRMTexture3Impl_GetSurface,
+    IDirect3DRMTexture3Impl_SetCacheOptions,
+    IDirect3DRMTexture3Impl_GetCacheOptions,
+    IDirect3DRMTexture3Impl_SetDownsampleCallback,
+    IDirect3DRMTexture3Impl_SetValidationCallback
+};
+
+HRESULT Direct3DRMTexture_create(REFIID riid, IUnknown** ret_iface)
+{
+    IDirect3DRMTextureImpl* object;
+
+    TRACE("(%p)\n", ret_iface);
+
+    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMTextureImpl));
+    if (!object)
+    {
+        ERR("Out of memory\n");
+        return E_OUTOFMEMORY;
+    }
+
+    object->IDirect3DRMTexture2_iface.lpVtbl = &Direct3DRMTexture2_Vtbl;
+    object->IDirect3DRMTexture3_iface.lpVtbl = &Direct3DRMTexture3_Vtbl;
+    object->ref = 1;
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMTexture3))
+        *ret_iface = (IUnknown*)&object->IDirect3DRMTexture3_iface;
+    else
+        *ret_iface = (IUnknown*)&object->IDirect3DRMTexture2_iface;
+
+    return S_OK;
+}

[PATCH 1/2] d3drm: Add some tests for mesh default material andtexture.

Christian Costa — 2012-05-24T06:49:53

---
 dlls/d3drm/tests/d3drm.c |   24 ++++++++++++++++++++++++
 1 files changed, 24 insertions(+), 0 deletions(-)

diff --git a/dlls/d3drm/tests/d3drm.c b/dlls/d3drm/tests/d3drm.c
index c0869be..5bbd363 100644
--- a/dlls/d3drm/tests/d3drm.c
+++ b/dlls/d3drm/tests/d3drm.c
< at >< at > -353,6 +353,9 < at >< at > static void test_MeshBuilder(void)
         DWORD nb_groups;
         unsigned nb_vertices, nb_faces, nb_face_vertices;
         DWORD data_size;
+        LPDIRECT3DRMMATERIAL material;
+        LPDIRECT3DRMTEXTURE texture;
+        D3DVALUE values[3];
 
         nb_groups = IDirect3DRMMesh_GetGroupCount(mesh);
         ok(nb_groups == 1, "GetCroupCount returned %u\n", nb_groups);
< at >< at > -364,6 +367,27 < at >< at > static void test_MeshBuilder(void)
         ok(nb_faces == 1, "Wrong number of faces %u (must be 1)\n", nb_faces);
         todo_wine ok(nb_face_vertices == 3, "Wrong number of vertices per face %u (must be 3)\n", nb_face_vertices);
         todo_wine ok(data_size == 3, "Wrong number of face data bytes %u (must be 3)\n", data_size);
+        hr = IDirect3DRMMesh_GetGroupTexture(mesh, 0, &texture);
+        todo_wine ok(hr == D3DRM_OK, "GetCroupTexture failed returning hr = %x\n", hr);
+        todo_wine ok(texture == NULL, "No texture should be present\n");
+        hr = IDirect3DRMMesh_GetGroupMaterial(mesh, 0, &material);
+        todo_wine ok(hr == D3DRM_OK, "GetCroupMaterial failed returning hr = %x\n", hr);
+        todo_wine ok(material != NULL, "No material should be present\n");
+        if ((hr == D3DRM_OK) && material)
+        {
+            hr = IDirect3DRMMaterial_GetEmissive(material, &values[0], &values[1], &values[2]);
+            ok(hr == D3DRM_OK, "GetMaterialEmissive failed returning hr = %x\n", hr);
+            ok(values[0] == 0.5f, "Emissive red component should be %f instead of %f\n", 0.5f, values[0]);
+            ok(values[1] == 0.5f, "Emissive green component should be %f instead of %f\n", 0.5f, values[1]);
+            ok(values[2] == 0.5f, "Emissive blue component should be %f instead of %f\n", 0.5f, values[2]);
+            hr = IDirect3DRMMaterial_GetSpecular(material, &values[0], &values[1], &values[2]);
+            ok(hr == D3DRM_OK, "GetMaterialEmissive failed returning hr = %x\n", hr);
+            ok(values[0] == 1.0f, "Specular red component should be %f instead of %f\n", 1.0f, values[0]);
+            ok(values[1] == 0.0f, "Specular green component should be %f instead of %f\n", 0.0f, values[1]);
+            ok(values[2] == 0.0f, "Specular blue component should be %f instead of %f\n", 0.0f, values[2]);
+            values[0] = IDirect3DRMMaterial_GetPower(material);
+            ok(values[0] == 30.0f, "Power value should be %f instead of %f\n", 30.0f, values[0]);
+        }
 
         IDirect3DRMMesh_Release(mesh);
     }

po: Update Korean translation

Hwang YunSong(황윤성 — 2012-05-23T12:45:51

comctl32: Use WARN instead of ERR if a toolbar index is out of range.

Dmitry Timoshkov — 2012-05-24T05:43:36

This is a usual code path if there is no imagelist assigned, or an app
draws the toolbar button on its own in NM_CUSTOMDRAW handler.
---
 dlls/comctl32/toolbar.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dlls/comctl32/toolbar.c b/dlls/comctl32/toolbar.c
index da13aa2..cd19a58 100644
--- a/dlls/comctl32/toolbar.c
+++ b/dlls/comctl32/toolbar.c
< at >< at > -428,7 +428,7 < at >< at > TOOLBAR_GetImageListForDrawing (const TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPt
 
     if (!TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap)) {
 if (btnPtr->iBitmap == I_IMAGENONE) return NULL;
-ERR("bitmap for ID %d, index %d is not valid, number of bitmaps in imagelist: %d\n",
+WARN("bitmap for ID %d, index %d is not valid, number of bitmaps in imagelist: %d\n",
     HIWORD(btnPtr->iBitmap), LOWORD(btnPtr->iBitmap), infoPtr->nNumBitmaps);
 return NULL;
     }

gdiplus: Avoid needless gotos.

Dmitry Timoshkov — 2012-05-24T04:49:02

---
 dlls/gdiplus/region.c |   19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/dlls/gdiplus/region.c b/dlls/gdiplus/region.c
index ad8ab79..d4f590a 100644
--- a/dlls/gdiplus/region.c
+++ b/dlls/gdiplus/region.c
< at >< at > -151,15 +151,15 < at >< at > static inline GpStatus clone_element(const region_element* element,
     {
         case RegionDataRect:
             (*element2)->elementdata.rect = element->elementdata.rect;
-            break;
+            return Ok;
         case RegionDataEmptyRect:
         case RegionDataInfiniteRect:
-            break;
+            return Ok;
         case RegionDataPath:
             (*element2)->elementdata.pathdata.pathheader = element->elementdata.pathdata.pathheader;
             stat = GdipClonePath(element->elementdata.pathdata.path,
                     &(*element2)->elementdata.pathdata.path);
-            if (stat != Ok) goto clone_out;
+            if (stat == Ok) return Ok;
             break;
         default:
             (*element2)->elementdata.combine.left  = NULL;
< at >< at > -167,16 +167,15 < at >< at > static inline GpStatus clone_element(const region_element* element,
 
             stat = clone_element(element->elementdata.combine.left,
                     &(*element2)->elementdata.combine.left);
-            if (stat != Ok) goto clone_out;
-            stat = clone_element(element->elementdata.combine.right,
-                    &(*element2)->elementdata.combine.right);
-            if (stat != Ok) goto clone_out;
+            if (stat == Ok)
+            {
+                stat = clone_element(element->elementdata.combine.right,
+                        &(*element2)->elementdata.combine.right);
+                if (stat == Ok) return Ok;
+            }
             break;
     }
 
-    return Ok;
-
-clone_out:
     delete_element(*element2);
     *element2 = NULL;
     return stat;

gdiplus: Return correct status code if GdipAlloc fails.

Dmitry Timoshkov — 2012-05-24T04:48:30

---
 dlls/gdiplus/region.c |   52 ++++++++++++++++++++++++-------------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/dlls/gdiplus/region.c b/dlls/gdiplus/region.c
index 485c3a3..ad8ab79 100644
--- a/dlls/gdiplus/region.c
+++ b/dlls/gdiplus/region.c
< at >< at > -254,20 +254,20 < at >< at > GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion *region, GpPath *path, Combin
     }
 
     left = GdipAlloc(sizeof(region_element));
-    if (!left)
-        goto out;
-    *left = region->node;
-
-    stat = clone_element(&path_region->node, &right);
-    if (stat != Ok)
-        goto out;
-
-    fuse_region(region, left, right, mode);
-
-    GdipDeleteRegion(path_region);
-    return Ok;
+    if (left)
+    {
+        *left = region->node;
+        stat = clone_element(&path_region->node, &right);
+        if (stat == Ok)
+        {
+            fuse_region(region, left, right, mode);
+            GdipDeleteRegion(path_region);
+            return Ok;
+        }
+    }
+    else
+        stat = OutOfMemory;
 
-out:
     GdipFree(left);
     GdipDeleteRegion(path_region);
     return stat;
< at >< at > -301,20 +301,20 < at >< at > GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion *region,
     }
 
     left = GdipAlloc(sizeof(region_element));
-    if (!left)
-        goto out;
-    memcpy(left, &region->node, sizeof(region_element));
-
-    stat = clone_element(&rect_region->node, &right);
-    if (stat != Ok)
-        goto out;
-
-    fuse_region(region, left, right, mode);
-
-    GdipDeleteRegion(rect_region);
-    return Ok;
+    if (left)
+    {
+        memcpy(left, &region->node, sizeof(region_element));
+        stat = clone_element(&rect_region->node, &right);
+        if (stat == Ok)
+        {
+            fuse_region(region, left, right, mode);
+            GdipDeleteRegion(rect_region);
+            return Ok;
+        }
+    }
+    else
+        stat = OutOfMemory;
 
-out:
     GdipFree(left);
     GdipDeleteRegion(rect_region);
     return stat;

wininet: Add "Content-Disposition" field.

Alexander Morozov — 2012-05-23T17:29:44

HttpQueryInfo with HTTP_QUERY_CONTENT_DISPOSITION retrieves 
"Content-Disposition" HTTP header field content.

[PATCH 1/2] po: Update Finnish translation.

Lauri Kenttä — 2012-05-23T16:41:21

---
 po/fi.po |   21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

diff --git a/po/fi.po b/po/fi.po
index 2581565..f54e878 100644
--- a/po/fi.po
+++ b/po/fi.po
< at >< at > -155,21 +155,10 < at >< at > msgid "Cancel"
 msgstr "Peruuta"
 
 #: appwiz.rc:112
-#, fuzzy
-#| msgid "Wine Gecko Installer"
 msgid "Wine Mono Installer"
-msgstr "Wine Gecko -asennusohjelma"
+msgstr "Wine Mono -asennusohjelma"
 
 #: appwiz.rc:115
-#, fuzzy
-#| msgid ""
-#| "Wine could not find a Gecko package which is needed for applications "
-#| "embedding HTML to work correctly. Wine can automatically download and "
-#| "install it for you.\n"
-#| "\n"
-#| "Note: it is recommended to use your distribution's packages instead. See "
-#| "<a href=\"http://wiki.winehq.org/Gecko\">http://wiki.winehq.org/Gecko</a> "
-#| "for details."
 msgid ""
 "Wine could not find a Mono package which is needed for .NET applications to "
 "work correctly. Wine can automatically download and install it for you.\n"
< at >< at > -178,12 +167,12 < at >< at > msgid ""
 "href=\"http://wiki.winehq.org/Mono\">http://wiki.winehq.org/Mono</a> for "
 "details."
 msgstr ""
-"Wine ei löytänyt Gecko-pakettia, jota tarvitaan HTML:ää sisältävien "
-"ohjelmien toimintaan. Wine voi ladata ja asentaa sen puolestasi.\n"
+"Wine ei löytänyt Mono-pakettia, jota tarvitaan, jotta .NET-sovellukset "
+"toimisivat oikein. Wine voi ladata ja asentaa sen puolestasi.\n"
 "\n"
 "Huomaa, että on suositeltavampaa käyttää oman jakelusi paketteja. "
-"Lisätietoja: <a href=\"http://wiki.winehq.org/Gecko\">http://wiki.winehq.org/"
-"Gecko</a>."
+"Lisätietoja: <a href=\"http://wiki.winehq.org/Mono\">http://wiki.winehq.org/"
+"Mono</a>."
 
 #: appwiz.rc:28
 msgid "Add/Remove Programs"

[PATCH 2/2] po: Update Swedish translation.

Lauri Kenttä — 2012-05-23T16:41:22

---
 po/sv.po |   35 +++++++++++++++++------------------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/po/sv.po b/po/sv.po
index d7d9062..590cb14 100644
--- a/po/sv.po
+++ b/po/sv.po
< at >< at > -157,21 +157,10 < at >< at > msgid "Cancel"
 msgstr "Avbryt"
 
 #: appwiz.rc:112
-#, fuzzy
-#| msgid "Wine Gecko Installer"
 msgid "Wine Mono Installer"
-msgstr "Wine Gecko Installationsprogram"
+msgstr "Wine Mono Installationsprogram"
 
 #: appwiz.rc:115
-#, fuzzy
-#| msgid ""
-#| "Wine could not find a Gecko package which is needed for applications "
-#| "embedding HTML to work correctly. Wine can automatically download and "
-#| "install it for you.\n"
-#| "\n"
-#| "Note: it is recommended to use your distribution's packages instead. See "
-#| "<a href=\"http://wiki.winehq.org/Gecko\">http://wiki.winehq.org/Gecko</a> "
-#| "for details."
 msgid ""
 "Wine could not find a Mono package which is needed for .NET applications to "
 "work correctly. Wine can automatically download and install it for you.\n"
< at >< at > -180,12 +169,11 < at >< at > msgid ""
 "href=\"http://wiki.winehq.org/Mono\">http://wiki.winehq.org/Mono</a> for "
 "details."
 msgstr ""
-"Wine kunde inte hitta paketet Gecko vilket krävs för att program med "
-"inbäddad HTML ska fungera korrekt. Wine kan hämta och installera det "
-"automatiskt åt dig.\n"
+"Wine kunde inte hitta paketet Mono vilket krävs för att .NET-program ska "
+"fungera korrekt. Wine kan hämta och installera det automatiskt åt dig.\n"
 "\n"
 "Obs: Du rekommenderas att använda din distributions paket i stället. Se <a "
-"href=\"http://wiki.winehq.org/Gecko\">http://wiki.winehq.org/Gecko</a> för "
+"href=\"http://wiki.winehq.org/Mono\">http://wiki.winehq.org/Mono</a> för "
 "mer information."
 
 #: appwiz.rc:28
< at >< at > -3058,7 +3046,7 < at >< at > msgstr ""
 
 #: gdi32.rc:41
 msgid "OEM/DOS"
-msgstr ""
+msgstr "OEM/DOS"
 
 #: gphoto2.rc:27
 msgid "Files on Camera"
< at >< at > -9963,7 +9951,7 < at >< at > msgstr "Plats:"
 
 #: hostname.rc:27
 msgid "Usage: hostname\n"
-msgstr ""
+msgstr "Användning: hostname\n"
 
 #: hostname.rc:28
 msgid "Error: Invalid option '%c'.\n"
< at >< at > -10062,6 +10050,12 < at >< at > msgid ""
 "Displays the list of running services if 'service' is omitted. Otherwise "
 "'service' is the name of the service to start.\n"
 msgstr ""
+"Syntax för detta kommando är:\n"
+"\n"
+"NET START [tjänst]\n"
+"\n"
+"Visar listan på tjänster som redan körs om 'tjänst' utelämnas. Annars är "
+"'tjänst' namnet på tjänsten att starta.\n"
 
 #: net.rc:29
 msgid ""
< at >< at > -10071,6 +10065,11 < at >< at > msgid ""
 "\n"
 "Where 'service' is the name of the service to stop.\n"
 msgstr ""
+"Syntax för detta kommando är:\n"
+"\n"
+"NET STOP tjänst\n"
+"\n"
+"Där 'tjänst' är namnet på tjänsten att stoppa.\n"
 
 #: net.rc:30
 msgid "Stopping dependent service: %1\n"

wininet: Moved querying INTERNET_OPTION_REQUEST_FLAGS implementationto HTTPREQ_QueryOption

Jacek Caban — 2012-05-23T16:24:02

---
 dlls/wininet/http.c           |   10 ++++++++++
 dlls/wininet/internet.c       |   20 ++++++++------------
 dlls/wininet/tests/internet.c |   16 ++++++++++++++++
 3 files changed, 34 insertions(+), 12 deletions(-)

[PATCH 5/5] d3d8: Get rid of IDirect3DVolume8Impl.

Henri Verbeet — 2012-05-23T16:14:34

---
 dlls/d3d8/d3d8_private.h |   17 +----
 dlls/d3d8/device.c       |    2 +-
 dlls/d3d8/texture.c      |    6 +-
 dlls/d3d8/volume.c       |  156 +++++++++++++++++++++++----------------------
 4 files changed, 88 insertions(+), 93 deletions(-)

diff --git a/dlls/d3d8/d3d8_private.h b/dlls/d3d8/d3d8_private.h
index c9c604d..13fb707 100644
--- a/dlls/d3d8/d3d8_private.h
+++ b/dlls/d3d8/d3d8_private.h
< at >< at > -100,8 +100,6 < at >< at >
 
 void fixup_caps(WINED3DCAPS *pWineCaps) DECLSPEC_HIDDEN;
 
-typedef struct IDirect3DVolume8Impl IDirect3DVolume8Impl;
-
 struct d3d8
 {
     IDirect3D8 IDirect3D8_iface;
< at >< at > -168,23 +166,16 < at >< at > struct d3d8_device
 HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wined3d *wined3d, UINT adapter,
         D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters) DECLSPEC_HIDDEN;
 
-/* ---------------- */
-/* IDirect3DVolume8 */
-/* ---------------- */
-
-/*****************************************************************************
- * IDirect3DVolume8 implementation structure
- */
-struct IDirect3DVolume8Impl
+struct d3d8_volume
 {
-    IDirect3DVolume8    IDirect3DVolume8_iface;
-    LONG                ref;
+    IDirect3DVolume8 IDirect3DVolume8_iface;
+    LONG refcount;
     struct wined3d_volume *wined3d_volume;
     IUnknown *container;
     IUnknown *forwardReference;
 };
 
-HRESULT volume_init(IDirect3DVolume8Impl *volume, struct d3d8_device *device, UINT width, UINT height,
+HRESULT volume_init(struct d3d8_volume *volume, struct d3d8_device *device, UINT width, UINT height,
         UINT depth, DWORD usage, enum wined3d_format_id format, enum wined3d_pool pool) DECLSPEC_HIDDEN;
 
 struct d3d8_swapchain
diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c
index ddf5c1f..1ec011b 100644
--- a/dlls/d3d8/device.c
+++ b/dlls/d3d8/device.c
< at >< at > -2902,7 +2902,7 < at >< at > static HRESULT CDECL device_parent_create_volume(struct wined3d_device_parent *d
         enum wined3d_pool pool, DWORD usage, struct wined3d_volume **volume)
 {
     struct d3d8_device *device = device_from_device_parent(device_parent);
-    IDirect3DVolume8Impl *object;
+    struct d3d8_volume *object;
     HRESULT hr;
 
     TRACE("device_parent %p, container_parent %p, width %u, height %u, depth %u, "
diff --git a/dlls/d3d8/texture.c b/dlls/d3d8/texture.c
index 032a13b..6b5f95c 100644
--- a/dlls/d3d8/texture.c
+++ b/dlls/d3d8/texture.c
< at >< at > -1031,7 +1031,7 < at >< at > static HRESULT WINAPI d3d8_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture8 *if
 {
     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DVolume8Impl *volume_impl;
+    struct d3d8_volume *volume_impl;
 
     TRACE("iface %p, level %u, volume %p.\n", iface, level, volume);
 
< at >< at > -1055,7 +1055,7 < at >< at > static HRESULT WINAPI d3d8_texture_3d_LockBox(IDirect3DVolumeTexture8 *iface,
 {
     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DVolume8Impl *volume_impl;
+    struct d3d8_volume *volume_impl;
     HRESULT hr;
 
     TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n",
< at >< at > -1078,7 +1078,7 < at >< at > static HRESULT WINAPI d3d8_texture_3d_UnlockBox(IDirect3DVolumeTexture8 *iface,
 {
     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DVolume8Impl *volume_impl;
+    struct d3d8_volume *volume_impl;
     HRESULT hr;
 
     TRACE("iface %p, level %u.\n", iface, level);
diff --git a/dlls/d3d8/volume.c b/dlls/d3d8/volume.c
index d622198..5c77193 100644
--- a/dlls/d3d8/volume.c
+++ b/dlls/d3d8/volume.c
< at >< at > -23,50 +23,52 < at >< at >
 
 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
 
-static inline IDirect3DVolume8Impl *impl_from_IDirect3DVolume8(IDirect3DVolume8 *iface)
+static inline struct d3d8_volume *impl_from_IDirect3DVolume8(IDirect3DVolume8 *iface)
 {
-    return CONTAINING_RECORD(iface, IDirect3DVolume8Impl, IDirect3DVolume8_iface);
+    return CONTAINING_RECORD(iface, struct d3d8_volume, IDirect3DVolume8_iface);
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_QueryInterface(IDirect3DVolume8 *iface, REFIID riid,
-        void **ppobj)
+static HRESULT WINAPI d3d8_volume_QueryInterface(IDirect3DVolume8 *iface, REFIID riid, void **out)
 {
-    TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), ppobj);
+    TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), out);
 
     if (IsEqualGUID(riid, &IID_IDirect3DVolume8)
             || IsEqualGUID(riid, &IID_IUnknown))
     {
         IUnknown_AddRef(iface);
-        *ppobj = iface;
+        *out = iface;
         return S_OK;
     }
 
     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 
-    *ppobj = NULL;
+    *out = NULL;
     return E_NOINTERFACE;
 }
 
-static ULONG WINAPI IDirect3DVolume8Impl_AddRef(IDirect3DVolume8 *iface)
+static ULONG WINAPI d3d8_volume_AddRef(IDirect3DVolume8 *iface)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
 
     TRACE("iface %p.\n", iface);
 
-    if (This->forwardReference) {
+    if (volume->forwardReference)
+    {
         /* Forward to the containerParent */
-        TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
-        return IUnknown_AddRef(This->forwardReference);
-    } else {
+        TRACE("Forwarding to %p,\n", volume->forwardReference);
+        return IUnknown_AddRef(volume->forwardReference);
+    }
+    else
+    {
         /* No container, handle our own refcounting */
-        ULONG ref = InterlockedIncrement(&This->ref);
+        ULONG ref = InterlockedIncrement(&volume->refcount);
 
         TRACE("%p increasing refcount to %u.\n", iface, ref);
 
         if (ref == 1)
         {
             wined3d_mutex_lock();
-            wined3d_volume_incref(This->wined3d_volume);
+            wined3d_volume_incref(volume->wined3d_volume);
             wined3d_mutex_unlock();
         }
 
< at >< at > -74,26 +76,29 < at >< at > static ULONG WINAPI IDirect3DVolume8Impl_AddRef(IDirect3DVolume8 *iface)
     }
 }
 
-static ULONG WINAPI IDirect3DVolume8Impl_Release(IDirect3DVolume8 *iface)
+static ULONG WINAPI d3d8_volume_Release(IDirect3DVolume8 *iface)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
 
     TRACE("iface %p.\n", iface);
 
-    if (This->forwardReference) {
+    if (volume->forwardReference)
+    {
         /* Forward to the containerParent */
-        TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
-        return IUnknown_Release(This->forwardReference);
+        TRACE("Forwarding to %p.\n", volume->forwardReference);
+        return IUnknown_Release(volume->forwardReference);
     }
-    else {
+    else
+    {
         /* No container, handle our own refcounting */
-        ULONG ref = InterlockedDecrement(&This->ref);
+        ULONG ref = InterlockedDecrement(&volume->refcount);
 
         TRACE("%p decreasing refcount to %u.\n", iface, ref);
 
-        if (ref == 0) {
+        if (!ref)
+        {
             wined3d_mutex_lock();
-            wined3d_volume_decref(This->wined3d_volume);
+            wined3d_volume_decref(volume->wined3d_volume);
             wined3d_mutex_unlock();
         }
 
< at >< at > -101,16 +106,15 < at >< at > static ULONG WINAPI IDirect3DVolume8Impl_Release(IDirect3DVolume8 *iface)
     }
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_GetDevice(IDirect3DVolume8 *iface,
-        IDirect3DDevice8 **device)
+static HRESULT WINAPI d3d8_volume_GetDevice(IDirect3DVolume8 *iface, IDirect3DDevice8 **device)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     IDirect3DResource8 *resource;
     HRESULT hr;
 
     TRACE("iface %p, device %p.\n", iface, device);
 
-    hr = IUnknown_QueryInterface(This->forwardReference, &IID_IDirect3DResource8, (void **)&resource);
+    hr = IUnknown_QueryInterface(volume->forwardReference, &IID_IDirect3DResource8, (void **)&resource);
     if (SUCCEEDED(hr))
     {
         hr = IDirect3DResource8_GetDevice(resource, device);
< at >< at > -122,86 +126,86 < at >< at > static HRESULT WINAPI IDirect3DVolume8Impl_GetDevice(IDirect3DVolume8 *iface,
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_SetPrivateData(IDirect3DVolume8 *iface, REFGUID refguid,
-        const void *pData, DWORD SizeOfData, DWORD Flags)
+static HRESULT WINAPI d3d8_volume_SetPrivateData(IDirect3DVolume8 *iface, REFGUID guid,
+        const void *data, DWORD data_size, DWORD flags)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     struct wined3d_resource *resource;
     HRESULT hr;
 
     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
-            iface, debugstr_guid(refguid), pData, SizeOfData, Flags);
+            iface, debugstr_guid(guid), data, data_size, flags);
 
     wined3d_mutex_lock();
-    resource = wined3d_volume_get_resource(This->wined3d_volume);
-    hr = wined3d_resource_set_private_data(resource, refguid, pData, SizeOfData, Flags);
+    resource = wined3d_volume_get_resource(volume->wined3d_volume);
+    hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
     wined3d_mutex_unlock();
 
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_GetPrivateData(IDirect3DVolume8 *iface, REFGUID  refguid,
-        void *pData, DWORD *pSizeOfData)
+static HRESULT WINAPI d3d8_volume_GetPrivateData(IDirect3DVolume8 *iface, REFGUID  guid,
+        void *data, DWORD *data_size)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     struct wined3d_resource *resource;
     HRESULT hr;
 
     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
-            iface, debugstr_guid(refguid), pData, pSizeOfData);
+            iface, debugstr_guid(guid), data, data_size);
 
     wined3d_mutex_lock();
-    resource = wined3d_volume_get_resource(This->wined3d_volume);
-    hr = wined3d_resource_get_private_data(resource, refguid, pData, pSizeOfData);
+    resource = wined3d_volume_get_resource(volume->wined3d_volume);
+    hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
     wined3d_mutex_unlock();
 
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_FreePrivateData(IDirect3DVolume8 *iface, REFGUID refguid)
+static HRESULT WINAPI d3d8_volume_FreePrivateData(IDirect3DVolume8 *iface, REFGUID guid)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     struct wined3d_resource *resource;
     HRESULT hr;
 
-    TRACE("iface %p, guid %s.\n", iface, debugstr_guid(refguid));
+    TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 
     wined3d_mutex_lock();
-    resource = wined3d_volume_get_resource(This->wined3d_volume);
-    hr = wined3d_resource_free_private_data(resource, refguid);
+    resource = wined3d_volume_get_resource(volume->wined3d_volume);
+    hr = wined3d_resource_free_private_data(resource, guid);
     wined3d_mutex_unlock();
 
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_GetContainer(IDirect3DVolume8 *iface, REFIID riid,
-        void **ppContainer)
+static HRESULT WINAPI d3d8_volume_GetContainer(IDirect3DVolume8 *iface, REFIID riid, void **container)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     HRESULT res;
 
     TRACE("iface %p, riid %s, container %p.\n",
-            iface, debugstr_guid(riid), ppContainer);
+            iface, debugstr_guid(riid), container);
 
-    if (!This->container) return E_NOINTERFACE;
+    if (!volume->container)
+        return E_NOINTERFACE;
 
-    res = IUnknown_QueryInterface(This->container, riid, ppContainer);
+    res = IUnknown_QueryInterface(volume->container, riid, container);
 
-    TRACE("Returning ppContainer %p, *ppContainer %p\n", ppContainer, *ppContainer);
+    TRACE("Returning %p.\n", *container);
 
     return res;
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_GetDesc(IDirect3DVolume8 *iface, D3DVOLUME_DESC *desc)
+static HRESULT WINAPI d3d8_volume_GetDesc(IDirect3DVolume8 *iface, D3DVOLUME_DESC *desc)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     struct wined3d_resource_desc wined3d_desc;
     struct wined3d_resource *wined3d_resource;
 
     TRACE("iface %p, desc %p.\n", iface, desc);
 
     wined3d_mutex_lock();
-    wined3d_resource = wined3d_volume_get_resource(This->wined3d_volume);
+    wined3d_resource = wined3d_volume_get_resource(volume->wined3d_volume);
     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
     wined3d_mutex_unlock();
 
< at >< at > -217,10 +221,10 < at >< at > static HRESULT WINAPI IDirect3DVolume8Impl_GetDesc(IDirect3DVolume8 *iface, D3DV
     return D3D_OK;
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_LockBox(IDirect3DVolume8 *iface,
+static HRESULT WINAPI d3d8_volume_LockBox(IDirect3DVolume8 *iface,
         D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     struct wined3d_map_desc map_desc;
     HRESULT hr;
 
< at >< at > -228,7 +232,7 < at >< at > static HRESULT WINAPI IDirect3DVolume8Impl_LockBox(IDirect3DVolume8 *iface,
             iface, locked_box, box, flags);
 
     wined3d_mutex_lock();
-    hr = wined3d_volume_map(This->wined3d_volume, &map_desc, (const struct wined3d_box *)box, flags);
+    hr = wined3d_volume_map(volume->wined3d_volume, &map_desc, (const struct wined3d_box *)box, flags);
     wined3d_mutex_unlock();
 
     locked_box->RowPitch = map_desc.row_pitch;
< at >< at > -238,35 +242,35 < at >< at > static HRESULT WINAPI IDirect3DVolume8Impl_LockBox(IDirect3DVolume8 *iface,
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DVolume8Impl_UnlockBox(IDirect3DVolume8 *iface)
+static HRESULT WINAPI d3d8_volume_UnlockBox(IDirect3DVolume8 *iface)
 {
-    IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
+    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
     HRESULT hr;
 
     TRACE("iface %p.\n", iface);
 
     wined3d_mutex_lock();
-    hr = wined3d_volume_unmap(This->wined3d_volume);
+    hr = wined3d_volume_unmap(volume->wined3d_volume);
     wined3d_mutex_unlock();
 
     return hr;
 }
 
-static const IDirect3DVolume8Vtbl Direct3DVolume8_Vtbl =
+static const IDirect3DVolume8Vtbl d3d8_volume_vtbl =
 {
     /* IUnknown */
-    IDirect3DVolume8Impl_QueryInterface,
-    IDirect3DVolume8Impl_AddRef,
-    IDirect3DVolume8Impl_Release,
+    d3d8_volume_QueryInterface,
+    d3d8_volume_AddRef,
+    d3d8_volume_Release,
     /* IDirect3DVolume8 */
-    IDirect3DVolume8Impl_GetDevice,
-    IDirect3DVolume8Impl_SetPrivateData,
-    IDirect3DVolume8Impl_GetPrivateData,
-    IDirect3DVolume8Impl_FreePrivateData,
-    IDirect3DVolume8Impl_GetContainer,
-    IDirect3DVolume8Impl_GetDesc,
-    IDirect3DVolume8Impl_LockBox,
-    IDirect3DVolume8Impl_UnlockBox
+    d3d8_volume_GetDevice,
+    d3d8_volume_SetPrivateData,
+    d3d8_volume_GetPrivateData,
+    d3d8_volume_FreePrivateData,
+    d3d8_volume_GetContainer,
+    d3d8_volume_GetDesc,
+    d3d8_volume_LockBox,
+    d3d8_volume_UnlockBox,
 };
 
 static void STDMETHODCALLTYPE volume_wined3d_object_destroyed(void *parent)
< at >< at > -279,13 +283,13 < at >< at > static const struct wined3d_parent_ops d3d8_volume_wined3d_parent_ops =
     volume_wined3d_object_destroyed,
 };
 
-HRESULT volume_init(IDirect3DVolume8Impl *volume, struct d3d8_device *device, UINT width, UINT height,
+HRESULT volume_init(struct d3d8_volume *volume, struct d3d8_device *device, UINT width, UINT height,
         UINT depth, DWORD usage, enum wined3d_format_id format, enum wined3d_pool pool)
 {
     HRESULT hr;
 
-    volume->IDirect3DVolume8_iface.lpVtbl = &Direct3DVolume8_Vtbl;
-    volume->ref = 1;
+    volume->IDirect3DVolume8_iface.lpVtbl = &d3d8_volume_vtbl;
+    volume->refcount = 1;
 
     hr = wined3d_volume_create(device->wined3d_device, width, height, depth, usage,
             format, pool, volume, &d3d8_volume_wined3d_parent_ops, &volume->wined3d_volume);

[PATCH 3/5] ddraw/tests: Add a test for the initial color keyingstate.

Henri Verbeet — 2012-05-23T16:14:32

---
 dlls/ddraw/tests/ddraw1.c |  180 +++++++++++++++++++++++++++++++++++++++++++++
 dlls/ddraw/tests/ddraw2.c |  122 ++++++++++++++++++++++++++++++
 dlls/ddraw/tests/ddraw4.c |  118 +++++++++++++++++++++++++++++
 dlls/ddraw/tests/ddraw7.c |  107 +++++++++++++++++++++++++++
 4 files changed, 527 insertions(+), 0 deletions(-)

diff --git a/dlls/ddraw/tests/ddraw1.c b/dlls/ddraw/tests/ddraw1.c
index a3f548c..6063220 100644
--- a/dlls/ddraw/tests/ddraw1.c
+++ b/dlls/ddraw/tests/ddraw1.c
< at >< at > -1284,6 +1284,185 < at >< at > static void test_ck_rgba(void)
     DestroyWindow(window);
 }
 
+static void test_ck_default(void)
+{
+    static D3DRECT clear_rect = {{0}, {0}, {640}, {480}};
+    static D3DTLVERTEX tquad[] =
+    {
+        {{  0.0f}, {480.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {0.0f}},
+        {{  0.0f}, {  0.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {1.0f}},
+        {{640.0f}, {480.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {0.0f}},
+        {{640.0f}, {  0.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {1.0f}},
+    };
+    IDirect3DExecuteBuffer *execute_buffer;
+    IDirectDrawSurface *surface, *rt;
+    D3DTEXTUREHANDLE texture_handle;
+    D3DEXECUTEBUFFERDESC exec_desc;
+    IDirect3DMaterial *background;
+    UINT draw1_offset, draw1_len;
+    UINT draw2_offset, draw2_len;
+    UINT draw3_offset, draw3_len;
+    UINT draw4_offset, draw4_len;
+    IDirect3DViewport *viewport;
+    DDSURFACEDESC surface_desc;
+    IDirect3DTexture *texture;
+    IDirect3DDevice *device;
+    IDirectDraw *ddraw;
+    D3DCOLOR color;
+    HWND window;
+    DDBLTFX fx;
+    HRESULT hr;
+    void *ptr;
+
+    window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
+            0, 0, 640, 480, 0, 0, 0, 0);
+
+    if (!(ddraw = create_ddraw()))
+    {
+        skip("Failed to create ddraw object, skipping test.\n");
+        DestroyWindow(window);
+        return;
+    }
+    if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
+    {
+        skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw_Release(ddraw);
+        DestroyWindow(window);
+        return;
+    }
+
+    hr = IDirect3DDevice_QueryInterface(device, &IID_IDirectDrawSurface, (void **)&rt);
+    ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
+
+    background = create_diffuse_material(device, 0.0, 1.0f, 0.0f, 1.0f);
+    viewport = create_viewport(device, 0, 0, 640, 480);
+    viewport_set_background(device, viewport, background);
+
+    memset(&surface_desc, 0, sizeof(surface_desc));
+    surface_desc.dwSize = sizeof(surface_desc);
+    surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT;
+    surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
+    surface_desc.dwWidth = 256;
+    surface_desc.dwHeight = 256;
+    surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat);
+    surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
+    U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32;
+    U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
+    U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
+    U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0x000000ff;
+    hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &surface, NULL);
+    ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
+    hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DTexture, (void **)&texture);
+    ok(SUCCEEDED(hr), "Failed to get texture interface, hr %#x.\n", hr);
+    hr = IDirect3DTexture_GetHandle(texture, device, &texture_handle);
+    ok(SUCCEEDED(hr), "Failed to get texture handle, hr %#x.\n", hr);
+    IDirect3DTexture_Release(texture);
+
+    memset(&fx, 0, sizeof(fx));
+    fx.dwSize = sizeof(fx);
+    U5(fx).dwFillColor = 0x000000ff;
+    hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
+    ok(SUCCEEDED(hr), "Failed to fill surface, hr %#x.\n", hr);
+
+    memset(&exec_desc, 0, sizeof(exec_desc));
+    exec_desc.dwSize = sizeof(exec_desc);
+    exec_desc.dwFlags = D3DDEB_BUFSIZE | D3DDEB_CAPS;
+    exec_desc.dwBufferSize = 1024;
+    exec_desc.dwCaps = D3DDEBCAPS_SYSTEMMEMORY;
+    hr = IDirect3DDevice_CreateExecuteBuffer(device, &exec_desc, &execute_buffer, NULL);
+    ok(SUCCEEDED(hr), "Failed to create execute buffer, hr %#x.\n", hr);
+
+    hr = IDirect3DExecuteBuffer_Lock(execute_buffer, &exec_desc);
+    ok(SUCCEEDED(hr), "Failed to lock execute buffer, hr %#x.\n", hr);
+    memcpy(exec_desc.lpData, tquad, sizeof(tquad));
+    ptr = (BYTE *)exec_desc.lpData + sizeof(tquad);
+    emit_process_vertices(&ptr, 0, 4);
+    emit_set_rs(&ptr, D3DRENDERSTATE_TEXTUREHANDLE, texture_handle);
+    emit_tquad(&ptr, 0);
+    emit_end(&ptr);
+    draw1_offset = sizeof(tquad);
+    draw1_len = (BYTE *)ptr - (BYTE *)exec_desc.lpData - draw1_offset;
+    emit_process_vertices(&ptr, 0, 4);
+    emit_set_rs(&ptr, D3DRENDERSTATE_COLORKEYENABLE, FALSE);
+    emit_tquad(&ptr, 0);
+    emit_end(&ptr);
+    draw2_offset = draw1_offset + draw1_len;
+    draw2_len = (BYTE *)ptr - (BYTE *)exec_desc.lpData - draw2_offset;
+    emit_process_vertices(&ptr, 0, 4);
+    emit_tquad(&ptr, 0);
+    emit_end(&ptr);
+    draw3_offset = draw2_offset + draw2_len;
+    draw3_len = (BYTE *)ptr - (BYTE *)exec_desc.lpData - draw3_offset;
+    emit_process_vertices(&ptr, 0, 4);
+    emit_set_rs(&ptr, D3DRENDERSTATE_COLORKEYENABLE, TRUE);
+    emit_tquad(&ptr, 0);
+    emit_set_rs(&ptr, D3DRENDERSTATE_TEXTUREHANDLE, 0);
+    emit_end(&ptr);
+    draw4_offset = draw3_offset + draw3_len;
+    draw4_len = (BYTE *)ptr - (BYTE *)exec_desc.lpData - draw4_offset;
+    hr = IDirect3DExecuteBuffer_Unlock(execute_buffer);
+    ok(SUCCEEDED(hr), "Failed to unlock execute buffer, hr %#x.\n", hr);
+
+    hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    set_execute_data(execute_buffer, 4, draw1_offset, draw1_len);
+    hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
+    ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
+    hr = IDirect3DDevice_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
+
+    hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    set_execute_data(execute_buffer, 4, draw2_offset, draw2_len);
+    hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
+    ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
+    hr = IDirect3DDevice_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    todo_wine ok(compare_color(color, 0x000000ff, 1), "Got unexpected color 0x%08x.\n", color);
+
+    hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    set_execute_data(execute_buffer, 4, draw3_offset, draw3_len);
+    hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
+    ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
+    hr = IDirect3DDevice_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    todo_wine ok(compare_color(color, 0x000000ff, 1), "Got unexpected color 0x%08x.\n", color);
+
+    hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    set_execute_data(execute_buffer, 4, draw4_offset, draw4_len);
+    hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
+    ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
+    hr = IDirect3DDevice_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
+
+    IDirect3DExecuteBuffer_Release(execute_buffer);
+    IDirectDrawSurface_Release(surface);
+    destroy_viewport(device, viewport);
+    destroy_material(background);
+    IDirectDrawSurface_Release(rt);
+    IDirect3DDevice_Release(device);
+    IDirectDraw_Release(ddraw);
+    DestroyWindow(window);
+}
+
 struct qi_test
 {
     REFIID iid;
< at >< at > -1508,6 +1687,7 < at >< at > START_TEST(ddraw1)
     test_viewport_interfaces();
     test_zenable();
     test_ck_rgba();
+    test_ck_default();
     test_surface_qi();
     test_device_qi();
 }
diff --git a/dlls/ddraw/tests/ddraw2.c b/dlls/ddraw/tests/ddraw2.c
index 02d0d6b..221f308 100644
--- a/dlls/ddraw/tests/ddraw2.c
+++ b/dlls/ddraw/tests/ddraw2.c
< at >< at > -1480,6 +1480,127 < at >< at > static void test_ck_rgba(void)
     DestroyWindow(window);
 }
 
+static void test_ck_default(void)
+{
+    static D3DRECT clear_rect = {{0}, {0}, {640}, {480}};
+    static D3DTLVERTEX tquad[] =
+    {
+        {{  0.0f}, {480.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {0.0f}},
+        {{  0.0f}, {  0.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {1.0f}},
+        {{640.0f}, {480.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {0.0f}},
+        {{640.0f}, {  0.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {1.0f}},
+    };
+    IDirectDrawSurface *surface, *rt;
+    D3DTEXTUREHANDLE texture_handle;
+    IDirect3DMaterial2 *background;
+    IDirect3DViewport2 *viewport;
+    DDSURFACEDESC surface_desc;
+    IDirect3DTexture2 *texture;
+    IDirect3DDevice2 *device;
+    IDirectDraw2 *ddraw;
+    D3DCOLOR color;
+    DWORD value;
+    HWND window;
+    DDBLTFX fx;
+    HRESULT hr;
+
+    window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
+            0, 0, 640, 480, 0, 0, 0, 0);
+
+    if (!(ddraw = create_ddraw()))
+    {
+        skip("Failed to create ddraw object, skipping test.\n");
+        DestroyWindow(window);
+        return;
+    }
+    if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
+    {
+        skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw2_Release(ddraw);
+        DestroyWindow(window);
+        return;
+    }
+
+    hr = IDirect3DDevice2_GetRenderTarget(device, &rt);
+    ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
+
+    background = create_diffuse_material(device, 0.0, 1.0f, 0.0f, 1.0f);
+    viewport = create_viewport(device, 0, 0, 640, 480);
+    viewport_set_background(device, viewport, background);
+    hr = IDirect3DDevice2_SetCurrentViewport(device, viewport);
+    ok(SUCCEEDED(hr), "Failed to set current viewport, hr %#x.\n", hr);
+
+    memset(&surface_desc, 0, sizeof(surface_desc));
+    surface_desc.dwSize = sizeof(surface_desc);
+    surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT;
+    surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
+    surface_desc.dwWidth = 256;
+    surface_desc.dwHeight = 256;
+    surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat);
+    surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
+    U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32;
+    U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
+    U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
+    U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0x000000ff;
+    hr = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &surface, NULL);
+    ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
+    hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DTexture2, (void **)&texture);
+    ok(SUCCEEDED(hr), "Failed to get texture interface, hr %#x.\n", hr);
+    hr = IDirect3DTexture2_GetHandle(texture, device, &texture_handle);
+    ok(SUCCEEDED(hr), "Failed to get texture handle, hr %#x.\n", hr);
+    IDirect3DTexture_Release(texture);
+
+    memset(&fx, 0, sizeof(fx));
+    fx.dwSize = sizeof(fx);
+    U5(fx).dwFillColor = 0x000000ff;
+    hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
+    ok(SUCCEEDED(hr), "Failed to fill surface, hr %#x.\n", hr);
+
+    hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_TEXTUREHANDLE, texture_handle);
+    ok(SUCCEEDED(hr), "Failed to set texture handle, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
+    ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
+    ok(!value, "Got unexpected color keying state %#x.\n", value);
+    hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_TLVERTEX, &tquad[0], 4, 0);
+    ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x000000ff, 1), "Got unexpected color 0x%08x.\n", color);
+
+    hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, TRUE);
+    ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_TLVERTEX, &tquad[0], 4, 0);
+    ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
+    ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
+    ok(!!value, "Got unexpected color keying state %#x.\n", value);
+    hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_TEXTUREHANDLE, 0);
+    ok(SUCCEEDED(hr), "Failed to set texture handle, hr %#x.\n", hr);
+    hr = IDirect3DDevice2_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
+
+    IDirectDrawSurface_Release(surface);
+    destroy_viewport(device, viewport);
+    destroy_material(background);
+    IDirectDrawSurface_Release(rt);
+    IDirect3DDevice2_Release(device);
+    IDirectDraw2_Release(ddraw);
+    DestroyWindow(window);
+}
+
 struct qi_test
 {
     REFIID iid;
< at >< at > -1705,6 +1826,7 < at >< at > START_TEST(ddraw2)
     test_viewport_interfaces();
     test_zenable();
     test_ck_rgba();
+    test_ck_default();
     test_surface_qi();
     test_device_qi();
 }
diff --git a/dlls/ddraw/tests/ddraw4.c b/dlls/ddraw/tests/ddraw4.c
index 5d37205..493ca97 100644
--- a/dlls/ddraw/tests/ddraw4.c
+++ b/dlls/ddraw/tests/ddraw4.c
< at >< at > -1616,6 +1616,123 < at >< at > static void test_ck_rgba(void)
     DestroyWindow(window);
 }
 
+static void test_ck_default(void)
+{
+    static D3DRECT clear_rect = {{0}, {0}, {640}, {480}};
+    static struct
+    {
+        struct vec4 position;
+        struct vec2 texcoord;
+    }
+    tquad[] =
+    {
+        {{  0.0f, 480.0f, 0.0f, 1.0f}, {0.0f, 0.0f}},
+        {{  0.0f,   0.0f, 0.0f, 1.0f}, {0.0f, 1.0f}},
+        {{640.0f, 480.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
+        {{640.0f,   0.0f, 0.0f, 1.0f}, {1.0f, 1.0f}},
+    };
+    IDirectDrawSurface4 *surface, *rt;
+    IDirect3DViewport3 *viewport;
+    DDSURFACEDESC2 surface_desc;
+    IDirect3DTexture2 *texture;
+    IDirect3DDevice3 *device;
+    IDirectDraw4 *ddraw;
+    IDirect3D3 *d3d;
+    D3DCOLOR color;
+    DWORD value;
+    HWND window;
+    DDBLTFX fx;
+    HRESULT hr;
+
+    window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
+            0, 0, 640, 480, 0, 0, 0, 0);
+
+    if (!(device = create_device(window, DDSCL_NORMAL)))
+    {
+        skip("Failed to create D3D device, skipping test.\n");
+        DestroyWindow(window);
+        return;
+    }
+
+    hr = IDirect3DDevice3_GetDirect3D(device, &d3d);
+    ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
+    hr = IDirect3D3_QueryInterface(d3d, &IID_IDirectDraw4, (void **)&ddraw);
+    ok(SUCCEEDED(hr), "Failed to get ddraw interface, hr %#x.\n", hr);
+    IDirect3D3_Release(d3d);
+
+    hr = IDirect3DDevice3_GetRenderTarget(device, &rt);
+    ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
+
+    viewport = create_viewport(device, 0, 0, 640, 480);
+    hr = IDirect3DDevice3_SetCurrentViewport(device, viewport);
+    ok(SUCCEEDED(hr), "Failed to set current viewport, hr %#x.\n", hr);
+
+    memset(&surface_desc, 0, sizeof(surface_desc));
+    surface_desc.dwSize = sizeof(surface_desc);
+    surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT;
+    surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
+    surface_desc.dwWidth = 256;
+    surface_desc.dwHeight = 256;
+    U4(surface_desc).ddpfPixelFormat.dwSize = sizeof(U4(surface_desc).ddpfPixelFormat);
+    U4(surface_desc).ddpfPixelFormat.dwFlags = DDPF_RGB;
+    U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount = 32;
+    U2(U4(surface_desc).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
+    U3(U4(surface_desc).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
+    U4(U4(surface_desc).ddpfPixelFormat).dwBBitMask = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0x000000ff;
+    hr = IDirectDraw4_CreateSurface(ddraw, &surface_desc, &surface, NULL);
+    ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
+    hr = IDirectDrawSurface4_QueryInterface(surface, &IID_IDirect3DTexture2, (void **)&texture);
+    ok(SUCCEEDED(hr), "Failed to get texture interface, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_SetTexture(device, 0, texture);
+    ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr);
+
+    memset(&fx, 0, sizeof(fx));
+    fx.dwSize = sizeof(fx);
+    U5(fx).dwFillColor = 0x000000ff;
+    hr = IDirectDrawSurface4_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
+    ok(SUCCEEDED(hr), "Failed to fill surface, hr %#x.\n", hr);
+
+    hr = IDirect3DViewport3_Clear2(viewport, 1, &clear_rect, D3DCLEAR_TARGET, 0xff00ff00, 1.0f, 0);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
+    ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
+    ok(!value, "Got unexpected color keying state %#x.\n", value);
+    hr = IDirect3DDevice3_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[0], 4, 0);
+    ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x000000ff, 1), "Got unexpected color 0x%08x.\n", color);
+
+    hr = IDirect3DViewport3_Clear2(viewport, 1, &clear_rect, D3DCLEAR_TARGET, 0xff00ff00, 1.0f, 0);
+    ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, TRUE);
+    ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[0], 4, 0);
+    ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+    hr = IDirect3DDevice3_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
+    ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
+    ok(!!value, "Got unexpected color keying state %#x.\n", value);
+    hr = IDirect3DDevice3_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
+
+    IDirect3DTexture_Release(texture);
+    IDirectDrawSurface4_Release(surface);
+    destroy_viewport(device, viewport);
+    IDirectDrawSurface4_Release(rt);
+    IDirect3DDevice3_Release(device);
+    IDirectDraw4_Release(ddraw);
+    DestroyWindow(window);
+}
+
 struct qi_test
 {
     REFIID iid;
< at >< at > -1834,6 +1951,7 < at >< at > START_TEST(ddraw4)
     test_viewport_interfaces();
     test_zenable();
     test_ck_rgba();
+    test_ck_default();
     test_surface_qi();
     test_device_qi();
 }
diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c
index 2465c0c..1d1e5dd 100644
--- a/dlls/ddraw/tests/ddraw7.c
+++ b/dlls/ddraw/tests/ddraw7.c
< at >< at > -1435,6 +1435,112 < at >< at > static void test_ck_rgba(void)
     DestroyWindow(window);
 }
 
+static void test_ck_default(void)
+{
+    static struct
+    {
+        struct vec4 position;
+        struct vec2 texcoord;
+    }
+    tquad[] =
+    {
+        {{  0.0f, 480.0f, 0.0f, 1.0f}, {0.0f, 0.0f}},
+        {{  0.0f,   0.0f, 0.0f, 1.0f}, {0.0f, 1.0f}},
+        {{640.0f, 480.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
+        {{640.0f,   0.0f, 0.0f, 1.0f}, {1.0f, 1.0f}},
+    };
+    IDirectDrawSurface7 *surface, *rt;
+    DDSURFACEDESC2 surface_desc;
+    IDirect3DDevice7 *device;
+    IDirectDraw7 *ddraw;
+    IDirect3D7 *d3d;
+    D3DCOLOR color;
+    DWORD value;
+    HWND window;
+    DDBLTFX fx;
+    HRESULT hr;
+
+    window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
+            0, 0, 640, 480, 0, 0, 0, 0);
+
+    if (!(device = create_device(window, DDSCL_NORMAL)))
+    {
+        skip("Failed to create D3D device, skipping test.\n");
+        DestroyWindow(window);
+        return;
+    }
+
+    hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
+    ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
+    hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
+    ok(SUCCEEDED(hr), "Failed to get ddraw interface, hr %#x.\n", hr);
+    IDirect3D7_Release(d3d);
+
+    hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
+    ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
+
+    memset(&surface_desc, 0, sizeof(surface_desc));
+    surface_desc.dwSize = sizeof(surface_desc);
+    surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT;
+    surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
+    surface_desc.dwWidth = 256;
+    surface_desc.dwHeight = 256;
+    U4(surface_desc).ddpfPixelFormat.dwSize = sizeof(U4(surface_desc).ddpfPixelFormat);
+    U4(surface_desc).ddpfPixelFormat.dwFlags = DDPF_RGB;
+    U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount = 32;
+    U2(U4(surface_desc).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
+    U3(U4(surface_desc).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
+    U4(U4(surface_desc).ddpfPixelFormat).dwBBitMask = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0x000000ff;
+    surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0x000000ff;
+    hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &surface, NULL);
+    ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_SetTexture(device, 0, surface);
+    ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr);
+
+    memset(&fx, 0, sizeof(fx));
+    fx.dwSize = sizeof(fx);
+    U5(fx).dwFillColor = 0x000000ff;
+    hr = IDirectDrawSurface7_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
+    ok(SUCCEEDED(hr), "Failed to fill surface, hr %#x.\n", hr);
+
+    hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 1.0f, 0);
+    ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
+    ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
+    ok(!value, "Got unexpected color keying state %#x.\n", value);
+    hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[0], 4, 0);
+    ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x000000ff, 1), "Got unexpected color 0x%08x.\n", color);
+
+    hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 1.0f, 0);
+    ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_BeginScene(device);
+    ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, TRUE);
+    ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[0], 4, 0);
+    ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
+    ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
+    ok(!!value, "Got unexpected color keying state %#x.\n", value);
+    hr = IDirect3DDevice7_EndScene(device);
+    ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+    color = get_surface_color(rt, 320, 240);
+    ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
+
+    IDirectDrawSurface7_Release(surface);
+    IDirectDrawSurface7_Release(rt);
+    IDirect3DDevice7_Release(device);
+    IDirectDraw7_Release(ddraw);
+    DestroyWindow(window);
+}
+
 struct qi_test
 {
     REFIID iid;
< at >< at > -1661,6 +1767,7 < at >< at > START_TEST(ddraw7)
     test_texture_load_ckey();
     test_zenable();
     test_ck_rgba();
+    test_ck_default();
     test_surface_qi();
     test_device_qi();
 }

[PATCH 2/5] ddraw/tests: Properly cleanup on failed device creationin a couple of places.

Henri Verbeet — 2012-05-23T16:14:31

---
 dlls/ddraw/tests/ddraw1.c |    4 ++++
 dlls/ddraw/tests/ddraw2.c |    4 ++++
 2 files changed, 8 insertions(+), 0 deletions(-)

diff --git a/dlls/ddraw/tests/ddraw1.c b/dlls/ddraw/tests/ddraw1.c
index 158f92d..a3f548c 100644
--- a/dlls/ddraw/tests/ddraw1.c
+++ b/dlls/ddraw/tests/ddraw1.c
< at >< at > -1158,6 +1158,7 < at >< at > static void test_ck_rgba(void)
     if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
     {
         skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw_Release(ddraw);
         DestroyWindow(window);
         return;
     }
< at >< at > -1390,6 +1391,7 < at >< at > static void test_surface_qi(void)
     if (!(ddraw = create_ddraw()))
     {
         skip("Failed to create a ddraw object, skipping test.\n");
+        DestroyWindow(window);
         return;
     }
     /* Try to create a D3D device to see if the ddraw implementation supports
< at >< at > -1398,6 +1400,7 < at >< at > static void test_surface_qi(void)
     if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
     {
         skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw_Release(ddraw);
         DestroyWindow(window);
         return;
     }
< at >< at > -1483,6 +1486,7 < at >< at > static void test_device_qi(void)
     if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
     {
         skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw_Release(ddraw);
         DestroyWindow(window);
         return;
     }
diff --git a/dlls/ddraw/tests/ddraw2.c b/dlls/ddraw/tests/ddraw2.c
index 45a5cfd..02d0d6b 100644
--- a/dlls/ddraw/tests/ddraw2.c
+++ b/dlls/ddraw/tests/ddraw2.c
< at >< at > -1373,6 +1373,7 < at >< at > static void test_ck_rgba(void)
     if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
     {
         skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw2_Release(ddraw);
         DestroyWindow(window);
         return;
     }
< at >< at > -1586,6 +1587,7 < at >< at > static void test_surface_qi(void)
     if (!(ddraw = create_ddraw()))
     {
         skip("Failed to create a ddraw object, skipping test.\n");
+        DestroyWindow(window);
         return;
     }
     /* Try to create a D3D device to see if the ddraw implementation supports
< at >< at > -1594,6 +1596,7 < at >< at > static void test_surface_qi(void)
     if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
     {
         skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw2_Release(ddraw);
         DestroyWindow(window);
         return;
     }
< at >< at > -1678,6 +1681,7 < at >< at > static void test_device_qi(void)
     if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
     {
         skip("Failed to create D3D device, skipping test.\n");
+        IDirectDraw2_Release(ddraw);
         DestroyWindow(window);
         return;
     }

[PATCH 1/5] ddraw/tests: Add a helper function to setup executebuffers.

Henri Verbeet — 2012-05-23T16:14:30

---
 dlls/ddraw/tests/ddraw1.c |   40 +++++++++++++++++-----------------------
 1 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/dlls/ddraw/tests/ddraw1.c b/dlls/ddraw/tests/ddraw1.c
index b5c50c5..158f92d 100644
--- a/dlls/ddraw/tests/ddraw1.c
+++ b/dlls/ddraw/tests/ddraw1.c
< at >< at > -186,6 +186,20 < at >< at > static void emit_end(void **ptr)
     *ptr = inst + 1;
 }
 
+static void set_execute_data(IDirect3DExecuteBuffer *execute_buffer, UINT vertex_count, UINT offset, UINT len)
+{
+    D3DEXECUTEDATA exec_data;
+    HRESULT hr;
+
+    memset(&exec_data, 0, sizeof(exec_data));
+    exec_data.dwSize = sizeof(exec_data);
+    exec_data.dwVertexCount = vertex_count;
+    exec_data.dwInstructionOffset = offset;
+    exec_data.dwInstructionLength = len;
+    hr = IDirect3DExecuteBuffer_SetExecuteData(execute_buffer, &exec_data);
+    ok(SUCCEEDED(hr), "Failed to set execute data, hr %#x.\n", hr);
+}
+
 static HRESULT CALLBACK enum_z_fmt(GUID *guid, char *description, char *name,
         D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc, void *ctx)
 {
< at >< at > -997,7 +1011,6 < at >< at > static void test_zenable(void)
     D3DEXECUTEBUFFERDESC exec_desc;
     IDirect3DMaterial *background;
     IDirect3DViewport *viewport;
-    D3DEXECUTEDATA exec_data;
     IDirect3DDevice *device;
     IDirectDrawSurface *rt;
     IDirectDraw *ddraw;
< at >< at > -1050,18 +1063,11 < at >< at > static void test_zenable(void)
     hr = IDirect3DExecuteBuffer_Unlock(execute_buffer);
     ok(SUCCEEDED(hr), "Failed to unlock execute buffer, hr %#x.\n", hr);
 
-    memset(&exec_data, 0, sizeof(exec_data));
-    exec_data.dwSize = sizeof(exec_data);
-    exec_data.dwVertexCount = 4;
-    exec_data.dwInstructionOffset = sizeof(tquad);
-    exec_data.dwInstructionLength = inst_length;
-    hr = IDirect3DExecuteBuffer_SetExecuteData(execute_buffer, &exec_data);
-    ok(SUCCEEDED(hr), "Failed to set execute data, hr %#x.\n", hr);
-
     hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
     ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
     hr = IDirect3DDevice_BeginScene(device);
     ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+    set_execute_data(execute_buffer, 4, sizeof(tquad), inst_length);
     hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
     ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
     hr = IDirect3DDevice_EndScene(device);
< at >< at > -1197,7 +1203,6 < at >< at > static void test_ck_rgba(void)
     for (i = 0; i < sizeof(tests) / sizeof(*tests); ++i)
     {
         UINT draw1_len, draw2_len;
-        D3DEXECUTEDATA exec_data;
         void *ptr;
 
         hr = IDirect3DExecuteBuffer_Lock(execute_buffer, &exec_desc);
< at >< at > -1227,18 +1232,11 < at >< at > static void test_ck_rgba(void)
         hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
         ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr);
 
-        memset(&exec_data, 0, sizeof(exec_data));
-        exec_data.dwSize = sizeof(exec_data);
-        exec_data.dwVertexCount = 8;
-        exec_data.dwInstructionOffset = sizeof(tquad);
-        exec_data.dwInstructionLength = draw1_len;
-        hr = IDirect3DExecuteBuffer_SetExecuteData(execute_buffer, &exec_data);
-        ok(SUCCEEDED(hr), "Failed to set execute data, hr %#x.\n", hr);
-
         hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER);
         ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
         hr = IDirect3DDevice_BeginScene(device);
         ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+        set_execute_data(execute_buffer, 8, sizeof(tquad), draw1_len);
         hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
         ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
         hr = IDirect3DDevice_EndScene(device);
< at >< at > -1256,13 +1254,9 < at >< at > static void test_ck_rgba(void)
         hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
         ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr);
 
-        exec_data.dwInstructionOffset = sizeof(tquad) + draw1_len;
-        exec_data.dwInstructionLength = draw2_len;
-        hr = IDirect3DExecuteBuffer_SetExecuteData(execute_buffer, &exec_data);
-        ok(SUCCEEDED(hr), "Failed to set execute data, hr %#x.\n", hr);
-
         hr = IDirect3DDevice_BeginScene(device);
         ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+        set_execute_data(execute_buffer, 8, sizeof(tquad) + draw1_len, draw2_len);
         hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
         ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
         hr = IDirect3DDevice_EndScene(device);

[PATCH 4/5] d3d8: Get rid of IDirect3DSurface8Impl.

Henri Verbeet — 2012-05-23T16:14:33

---
 dlls/d3d8/d3d8_private.h |   18 ++----
 dlls/d3d8/device.c       |   37 +++++------
 dlls/d3d8/surface.c      |  163 ++++++++++++++++++++++++----------------------
 dlls/d3d8/swapchain.c    |    2 +-
 dlls/d3d8/texture.c      |   12 ++--
 5 files changed, 114 insertions(+), 118 deletions(-)

diff --git a/dlls/d3d8/d3d8_private.h b/dlls/d3d8/d3d8_private.h
index cca05ea..c9c604d 100644
--- a/dlls/d3d8/d3d8_private.h
+++ b/dlls/d3d8/d3d8_private.h
< at >< at > -100,7 +100,6 < at >< at >
 
 void fixup_caps(WINED3DCAPS *pWineCaps) DECLSPEC_HIDDEN;
 
-typedef struct IDirect3DSurface8Impl IDirect3DSurface8Impl;
 typedef struct IDirect3DVolume8Impl IDirect3DVolume8Impl;
 
 struct d3d8
< at >< at > -199,19 +198,12 < at >< at > struct d3d8_swapchain
 HRESULT swapchain_init(struct d3d8_swapchain *swapchain, struct d3d8_device *device,
         D3DPRESENT_PARAMETERS *present_parameters) DECLSPEC_HIDDEN;
 
-/* ----------------- */
-/* IDirect3DSurface8 */
-/* ----------------- */
-
-/*****************************************************************************
- * IDirect3DSurface8 implementation structure
- */
-struct IDirect3DSurface8Impl
+struct d3d8_surface
 {
     IDirect3DSurface8 IDirect3DSurface8_iface;
-    LONG ref;
+    LONG refcount;
     struct wined3d_surface *wined3d_surface;
-    IDirect3DDevice8 *parentDevice;
+    IDirect3DDevice8 *parent_device;
 
     /* The surface container */
     IUnknown                    *container;
< at >< at > -220,10 +212,10 < at >< at > struct IDirect3DSurface8Impl
     IUnknown                    *forwardReference;
 };
 
-HRESULT surface_init(IDirect3DSurface8Impl *surface, struct d3d8_device *device,
+HRESULT surface_init(struct d3d8_surface *surface, struct d3d8_device *device,
         UINT width, UINT height, D3DFORMAT format, BOOL lockable, BOOL discard, UINT level,
         DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality) DECLSPEC_HIDDEN;
-IDirect3DSurface8Impl *unsafe_impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface) DECLSPEC_HIDDEN;
+struct d3d8_surface *unsafe_impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface) DECLSPEC_HIDDEN;
 
 struct d3d8_vertexbuffer
 {
diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c
index 837e847..ddf5c1f 100644
--- a/dlls/d3d8/device.c
+++ b/dlls/d3d8/device.c
< at >< at > -449,7 +449,7 < at >< at > static HRESULT WINAPI d3d8_device_SetCursorProperties(IDirect3DDevice8 *iface,
         UINT hotspot_x, UINT hotspot_y, IDirect3DSurface8 *bitmap)
 {
     struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
-    IDirect3DSurface8Impl *bitmap_impl = unsafe_impl_from_IDirect3DSurface8(bitmap);
+    struct d3d8_surface *bitmap_impl = unsafe_impl_from_IDirect3DSurface8(bitmap);
     HRESULT hr;
 
     TRACE("iface %p, hotspot_x %u, hotspot_y %u, bitmap %p.\n",
< at >< at > -532,7 +532,7 < at >< at > static HRESULT CDECL reset_enum_callback(struct wined3d_resource *resource)
     wined3d_resource_get_desc(resource, &desc);
     if (desc.pool == WINED3D_POOL_DEFAULT)
     {
-        IDirect3DSurface8Impl *surface;
+        struct d3d8_surface *surface;
 
         if (desc.resource_type != WINED3D_RTYPE_SURFACE)
         {
< at >< at > -541,7 +541,7 < at >< at > static HRESULT CDECL reset_enum_callback(struct wined3d_resource *resource)
         }
 
         surface = wined3d_resource_get_parent(resource);
-        if (surface->ref)
+        if (surface->refcount)
         {
             WARN("Surface %p (resource %p) in pool D3DPOOL_DEFAULT blocks the Reset call.\n", surface, resource);
             return D3DERR_DEVICELOST;
< at >< at > -615,7 +615,7 < at >< at > static HRESULT WINAPI d3d8_device_GetBackBuffer(IDirect3DDevice8 *iface,
 {
     struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
     struct wined3d_surface *wined3d_surface = NULL;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     HRESULT hr;
 
     TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n",
< at >< at > -836,7 +836,7 < at >< at > static HRESULT d3d8_device_CreateSurface(struct d3d8_device *device, UINT width,
         IDirect3DSurface8 **surface, UINT usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type,
         DWORD multisample_quality)
 {
-    IDirect3DSurface8Impl *object;
+    struct d3d8_surface *object;
     HRESULT hr;
 
     TRACE("device %p, width %u, height %u, format %#x, lockable %#x, discard %#x, level %u, surface %p,\n"
< at >< at > -844,8 +844,7 < at >< at > static HRESULT d3d8_device_CreateSurface(struct d3d8_device *device, UINT width,
             device, width, height, format, lockable, discard, level, surface,
             usage, pool, multisample_type, multisample_quality);
 
-    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface8Impl));
-    if (!object)
+    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
     {
         FIXME("Failed to allocate surface memory.\n");
         return D3DERR_OUTOFVIDEOMEMORY;
< at >< at > -920,8 +919,8 < at >< at > static HRESULT WINAPI d3d8_device_CopyRects(IDirect3DDevice8 *iface,
         IDirect3DSurface8 *src_surface, const RECT *src_rects, UINT rect_count,
         IDirect3DSurface8 *dst_surface, const POINT *dst_points)
 {
-    IDirect3DSurface8Impl *src = unsafe_impl_from_IDirect3DSurface8(src_surface);
-    IDirect3DSurface8Impl *dst = unsafe_impl_from_IDirect3DSurface8(dst_surface);
+    struct d3d8_surface *src = unsafe_impl_from_IDirect3DSurface8(src_surface);
+    struct d3d8_surface *dst = unsafe_impl_from_IDirect3DSurface8(dst_surface);
     enum wined3d_format_id src_format, dst_format;
     struct wined3d_resource_desc wined3d_desc;
     struct wined3d_resource *wined3d_resource;
< at >< at > -1042,7 +1041,7 < at >< at > static HRESULT WINAPI d3d8_device_UpdateTexture(IDirect3DDevice8 *iface,
 static HRESULT WINAPI d3d8_device_GetFrontBuffer(IDirect3DDevice8 *iface, IDirect3DSurface8 *dst_surface)
 {
     struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
-    IDirect3DSurface8Impl *dst_impl = unsafe_impl_from_IDirect3DSurface8(dst_surface);
+    struct d3d8_surface *dst_impl = unsafe_impl_from_IDirect3DSurface8(dst_surface);
     HRESULT hr;
 
     TRACE("iface %p, dst_surface %p.\n", iface, dst_surface);
< at >< at > -1064,8 +1063,8 < at >< at > static HRESULT WINAPI d3d8_device_SetRenderTarget(IDirect3DDevice8 *iface,
         IDirect3DSurface8 *render_target, IDirect3DSurface8 *depth_stencil)
 {
     struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
-    IDirect3DSurface8Impl *rt_impl = unsafe_impl_from_IDirect3DSurface8(render_target);
-    IDirect3DSurface8Impl *ds_impl = unsafe_impl_from_IDirect3DSurface8(depth_stencil);
+    struct d3d8_surface *rt_impl = unsafe_impl_from_IDirect3DSurface8(render_target);
+    struct d3d8_surface *ds_impl = unsafe_impl_from_IDirect3DSurface8(depth_stencil);
     struct wined3d_surface *original_ds = NULL;
     HRESULT hr;
 
< at >< at > -1129,7 +1128,7 < at >< at > static HRESULT WINAPI d3d8_device_GetRenderTarget(IDirect3DDevice8 *iface, IDire
 {
     struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
     struct wined3d_surface *wined3d_surface;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     HRESULT hr;
 
     TRACE("iface %p, render_target %p.\n", iface, render_target);
< at >< at > -1160,7 +1159,7 < at >< at > static HRESULT WINAPI d3d8_device_GetDepthStencilSurface(IDirect3DDevice8 *iface
 {
     struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
     struct wined3d_surface *wined3d_surface;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     HRESULT hr;
 
     TRACE("iface %p, depth_stencil %p.\n", iface, depth_stencil);
< at >< at > -2802,7 +2801,7 < at >< at > static HRESULT CDECL device_parent_create_surface(struct wined3d_device_parent *
         enum wined3d_pool pool, UINT level, enum wined3d_cubemap_face face, struct wined3d_surface **surface)
 {
     struct d3d8_device *device = device_from_device_parent(device_parent);
-    IDirect3DSurface8Impl *d3d_surface;
+    struct d3d8_surface *d3d_surface;
     BOOL lockable = TRUE;
     HRESULT hr;
 
< at >< at > -2827,8 +2826,8 < at >< at > static HRESULT CDECL device_parent_create_surface(struct wined3d_device_parent *
     wined3d_surface_incref(*surface);
 
     d3d_surface->container = container_parent;
-    IUnknown_Release(d3d_surface->parentDevice);
-    d3d_surface->parentDevice = NULL;
+    IUnknown_Release(d3d_surface->parent_device);
+    d3d_surface->parent_device = NULL;
 
     IDirect3DSurface8_Release(&d3d_surface->IDirect3DSurface8_iface);
     d3d_surface->forwardReference = container_parent;
< at >< at > -2842,7 +2841,7 < at >< at > static HRESULT CDECL device_parent_create_rendertarget(struct wined3d_device_par
         struct wined3d_surface **surface)
 {
     struct d3d8_device *device = device_from_device_parent(device_parent);
-    IDirect3DSurface8Impl *d3d_surface;
+    struct d3d8_surface *d3d_surface;
     HRESULT hr;
 
     TRACE("device_parent %p, container_parent %p, width %u, height %u, format %#x, multisample_type %#x,\n"
< at >< at > -2873,7 +2872,7 < at >< at > static HRESULT CDECL device_parent_create_depth_stencil(struct wined3d_device_pa
         DWORD multisample_quality, BOOL discard, struct wined3d_surface **surface)
 {
     struct d3d8_device *device = device_from_device_parent(device_parent);
-    IDirect3DSurface8Impl *d3d_surface;
+    struct d3d8_surface *d3d_surface;
     HRESULT hr;
 
     TRACE("device_parent %p, width %u, height %u, format %#x, multisample_type %#x,\n"
diff --git a/dlls/d3d8/surface.c b/dlls/d3d8/surface.c
index 89597f0..91d263c 100644
--- a/dlls/d3d8/surface.c
+++ b/dlls/d3d8/surface.c
< at >< at > -23,53 +23,55 < at >< at >
 
 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
 
-static inline IDirect3DSurface8Impl *impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface)
+static inline struct d3d8_surface *impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface)
 {
-    return CONTAINING_RECORD(iface, IDirect3DSurface8Impl, IDirect3DSurface8_iface);
+    return CONTAINING_RECORD(iface, struct d3d8_surface, IDirect3DSurface8_iface);
 }
 
-/* IDirect3DSurface8 IUnknown parts follow: */
-static HRESULT WINAPI IDirect3DSurface8Impl_QueryInterface(IDirect3DSurface8 *iface, REFIID riid,
-        void **ppobj)
+static HRESULT WINAPI d3d8_surface_QueryInterface(IDirect3DSurface8 *iface, REFIID riid, void **out)
 {
-    TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), ppobj);
+    TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), out);
 
     if (IsEqualGUID(riid, &IID_IDirect3DSurface8)
             || IsEqualGUID(riid, &IID_IDirect3DResource8)
             || IsEqualGUID(riid, &IID_IUnknown))
     {
         IUnknown_AddRef(iface);
-        *ppobj = iface;
+        *out = iface;
         return S_OK;
     }
 
     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 
-    *ppobj = NULL;
+    *out = NULL;
     return E_NOINTERFACE;
 }
 
-static ULONG WINAPI IDirect3DSurface8Impl_AddRef(IDirect3DSurface8 *iface)
+static ULONG WINAPI d3d8_surface_AddRef(IDirect3DSurface8 *iface)
 {
-    IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
 
     TRACE("iface %p.\n", iface);
 
-    if (This->forwardReference) {
+    if (surface->forwardReference)
+    {
         /* Forward refcounting */
-        TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
-        return IUnknown_AddRef(This->forwardReference);
-    } else {
+        TRACE("Forwarding to %p.\n", surface->forwardReference);
+        return IUnknown_AddRef(surface->forwardReference);
+    }
+    else
+    {
         /* No container, handle our own refcounting */
-        ULONG ref = InterlockedIncrement(&This->ref);
+        ULONG ref = InterlockedIncrement(&surface->refcount);
 
         TRACE("%p increasing refcount to %u.\n", iface, ref);
 
         if (ref == 1)
         {
-            if (This->parentDevice) IUnknown_AddRef(This->parentDevice);
+            if (surface->parent_device)
+                IUnknown_AddRef(surface->parent_device);
             wined3d_mutex_lock();
-            wined3d_surface_incref(This->wined3d_surface);
+            wined3d_surface_incref(surface->wined3d_surface);
             wined3d_mutex_unlock();
         }
 
< at >< at > -77,51 +79,54 < at >< at > static ULONG WINAPI IDirect3DSurface8Impl_AddRef(IDirect3DSurface8 *iface)
     }
 }
 
-static ULONG WINAPI IDirect3DSurface8Impl_Release(IDirect3DSurface8 *iface)
+static ULONG WINAPI d3d8_surface_Release(IDirect3DSurface8 *iface)
 {
-    IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
 
     TRACE("iface %p.\n", iface);
 
-    if (This->forwardReference) {
+    if (surface->forwardReference)
+    {
         /* Forward refcounting */
-        TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
-        return IUnknown_Release(This->forwardReference);
-    } else {
+        TRACE("Forwarding to %p.\n", surface->forwardReference);
+        return IUnknown_Release(surface->forwardReference);
+    }
+    else
+    {
         /* No container, handle our own refcounting */
-        ULONG ref = InterlockedDecrement(&This->ref);
+        ULONG ref = InterlockedDecrement(&surface->refcount);
 
         TRACE("%p decreasing refcount to %u.\n", iface, ref);
 
-        if (ref == 0) {
-            IDirect3DDevice8 *parentDevice = This->parentDevice;
+        if (!ref)
+        {
+            IDirect3DDevice8 *parent_device = surface->parent_device;
 
             /* Implicit surfaces are destroyed with the device, not if refcount reaches 0. */
             wined3d_mutex_lock();
-            wined3d_surface_decref(This->wined3d_surface);
+            wined3d_surface_decref(surface->wined3d_surface);
             wined3d_mutex_unlock();
 
-            if (parentDevice) IDirect3DDevice8_Release(parentDevice);
+            if (parent_device)
+                IDirect3DDevice8_Release(parent_device);
         }
 
         return ref;
     }
 }
 
-/* IDirect3DSurface8 IDirect3DResource8 Interface follow: */
-static HRESULT WINAPI IDirect3DSurface8Impl_GetDevice(IDirect3DSurface8 *iface,
-        IDirect3DDevice8 **device)
+static HRESULT WINAPI d3d8_surface_GetDevice(IDirect3DSurface8 *iface, IDirect3DDevice8 **device)
 {
-    IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
 
     TRACE("iface %p, device %p.\n", iface, device);
 
-    if (This->forwardReference)
+    if (surface->forwardReference)
     {
         IDirect3DResource8 *resource;
         HRESULT hr;
 
-        hr = IUnknown_QueryInterface(This->forwardReference, &IID_IDirect3DResource8, (void **)&resource);
+        hr = IUnknown_QueryInterface(surface->forwardReference, &IID_IDirect3DResource8, (void **)&resource);
         if (SUCCEEDED(hr))
         {
             hr = IDirect3DResource8_GetDevice(resource, device);
< at >< at > -133,7 +138,7 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_GetDevice(IDirect3DSurface8 *iface,
         return hr;
     }
 
-    *device = This->parentDevice;
+    *device = surface->parent_device;
     IDirect3DDevice8_AddRef(*device);
 
     TRACE("Returning device %p.\n", *device);
< at >< at > -141,10 +146,10 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_GetDevice(IDirect3DSurface8 *iface,
     return D3D_OK;
 }
 
-static HRESULT WINAPI IDirect3DSurface8Impl_SetPrivateData(IDirect3DSurface8 *iface, REFGUID guid,
+static HRESULT WINAPI d3d8_surface_SetPrivateData(IDirect3DSurface8 *iface, REFGUID guid,
         const void *data, DWORD data_size, DWORD flags)
 {
-    IDirect3DSurface8Impl *surface = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
     struct wined3d_resource *resource;
     HRESULT hr;
 
< at >< at > -159,10 +164,10 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_SetPrivateData(IDirect3DSurface8 *if
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DSurface8Impl_GetPrivateData(IDirect3DSurface8 *iface, REFGUID guid,
+static HRESULT WINAPI d3d8_surface_GetPrivateData(IDirect3DSurface8 *iface, REFGUID guid,
         void *data, DWORD *data_size)
 {
-    IDirect3DSurface8Impl *surface = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
     struct wined3d_resource *resource;
     HRESULT hr;
 
< at >< at > -177,9 +182,9 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_GetPrivateData(IDirect3DSurface8 *if
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DSurface8Impl_FreePrivateData(IDirect3DSurface8 *iface, REFGUID guid)
+static HRESULT WINAPI d3d8_surface_FreePrivateData(IDirect3DSurface8 *iface, REFGUID guid)
 {
-    IDirect3DSurface8Impl *surface = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
     struct wined3d_resource *resource;
     HRESULT hr;
 
< at >< at > -193,33 +198,33 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_FreePrivateData(IDirect3DSurface8 *i
     return hr;
 }
 
-/* IDirect3DSurface8 Interface follow: */
-static HRESULT WINAPI IDirect3DSurface8Impl_GetContainer(IDirect3DSurface8 *iface, REFIID riid,
-        void **ppContainer)
+static HRESULT WINAPI d3d8_surface_GetContainer(IDirect3DSurface8 *iface, REFIID riid, void **container)
 {
-    IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface);
-    HRESULT res;
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
+    HRESULT hr;
 
-    TRACE("iface %p, riid %s, container %p.\n", iface, debugstr_guid(riid), ppContainer);
+    TRACE("iface %p, riid %s, container %p.\n", iface, debugstr_guid(riid), container);
 
-    if (!This->container) return E_NOINTERFACE;
+    if (!surface->container)
+        return E_NOINTERFACE;
 
-    res = IUnknown_QueryInterface(This->container, riid, ppContainer);
+    hr = IUnknown_QueryInterface(surface->container, riid, container);
 
-    TRACE("(%p) : returning %p\n", This, *ppContainer);
-    return res;
+    TRACE("Returning %p.\n", *container);
+
+    return hr;
 }
 
-static HRESULT WINAPI IDirect3DSurface8Impl_GetDesc(IDirect3DSurface8 *iface, D3DSURFACE_DESC *desc)
+static HRESULT WINAPI d3d8_surface_GetDesc(IDirect3DSurface8 *iface, D3DSURFACE_DESC *desc)
 {
-    IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
     struct wined3d_resource_desc wined3d_desc;
     struct wined3d_resource *wined3d_resource;
 
     TRACE("iface %p, desc %p.\n", iface, desc);
 
     wined3d_mutex_lock();
-    wined3d_resource = wined3d_surface_get_resource(This->wined3d_surface);
+    wined3d_resource = wined3d_surface_get_resource(surface->wined3d_surface);
     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
     wined3d_mutex_unlock();
 
< at >< at > -235,10 +240,10 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_GetDesc(IDirect3DSurface8 *iface, D3
     return D3D_OK;
 }
 
-static HRESULT WINAPI IDirect3DSurface8Impl_LockRect(IDirect3DSurface8 *iface,
+static HRESULT WINAPI d3d8_surface_LockRect(IDirect3DSurface8 *iface,
         D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
 {
-    IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
     struct wined3d_map_desc map_desc;
     HRESULT hr;
 
< at >< at > -265,7 +270,7 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_LockRect(IDirect3DSurface8 *iface,
         }
     }
 
-    hr = wined3d_surface_map(This->wined3d_surface, &map_desc, rect, flags);
+    hr = wined3d_surface_map(surface->wined3d_surface, &map_desc, rect, flags);
     wined3d_mutex_unlock();
 
     locked_rect->Pitch = map_desc.row_pitch;
< at >< at > -274,15 +279,15 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_LockRect(IDirect3DSurface8 *iface,
     return hr;
 }
 
-static HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(IDirect3DSurface8 *iface)
+static HRESULT WINAPI d3d8_surface_UnlockRect(IDirect3DSurface8 *iface)
 {
-    IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface);
+    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
     HRESULT hr;
 
     TRACE("iface %p.\n", iface);
 
     wined3d_mutex_lock();
-    hr = wined3d_surface_unmap(This->wined3d_surface);
+    hr = wined3d_surface_unmap(surface->wined3d_surface);
     wined3d_mutex_unlock();
 
     switch(hr)
< at >< at > -292,22 +297,22 < at >< at > static HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(IDirect3DSurface8 *iface)
     }
 }
 
-static const IDirect3DSurface8Vtbl Direct3DSurface8_Vtbl =
+static const IDirect3DSurface8Vtbl d3d8_surface_vtbl =
 {
     /* IUnknown */
-    IDirect3DSurface8Impl_QueryInterface,
-    IDirect3DSurface8Impl_AddRef,
-    IDirect3DSurface8Impl_Release,
+    d3d8_surface_QueryInterface,
+    d3d8_surface_AddRef,
+    d3d8_surface_Release,
     /* IDirect3DResource8 */
-    IDirect3DSurface8Impl_GetDevice,
-    IDirect3DSurface8Impl_SetPrivateData,
-    IDirect3DSurface8Impl_GetPrivateData,
-    IDirect3DSurface8Impl_FreePrivateData,
+    d3d8_surface_GetDevice,
+    d3d8_surface_SetPrivateData,
+    d3d8_surface_GetPrivateData,
+    d3d8_surface_FreePrivateData,
     /* IDirect3DSurface8 */
-    IDirect3DSurface8Impl_GetContainer,
-    IDirect3DSurface8Impl_GetDesc,
-    IDirect3DSurface8Impl_LockRect,
-    IDirect3DSurface8Impl_UnlockRect
+    d3d8_surface_GetContainer,
+    d3d8_surface_GetDesc,
+    d3d8_surface_LockRect,
+    d3d8_surface_UnlockRect,
 };
 
 static void STDMETHODCALLTYPE surface_wined3d_object_destroyed(void *parent)
< at >< at > -320,15 +325,15 < at >< at > static const struct wined3d_parent_ops d3d8_surface_wined3d_parent_ops =
     surface_wined3d_object_destroyed,
 };
 
-HRESULT surface_init(IDirect3DSurface8Impl *surface, struct d3d8_device *device,
+HRESULT surface_init(struct d3d8_surface *surface, struct d3d8_device *device,
         UINT width, UINT height, D3DFORMAT format, BOOL lockable, BOOL discard, UINT level,
         DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality)
 {
     DWORD flags = 0;
     HRESULT hr;
 
-    surface->IDirect3DSurface8_iface.lpVtbl = &Direct3DSurface8_Vtbl;
-    surface->ref = 1;
+    surface->IDirect3DSurface8_iface.lpVtbl = &d3d8_surface_vtbl;
+    surface->refcount = 1;
 
     /* FIXME: Check MAX bounds of MultisampleQuality. */
     if (multisample_quality > 0)
< at >< at > -353,17 +358,17 < at >< at > HRESULT surface_init(IDirect3DSurface8Impl *surface, struct d3d8_device *device,
         return hr;
     }
 
-    surface->parentDevice = &device->IDirect3DDevice8_iface;
-    IUnknown_AddRef(surface->parentDevice);
+    surface->parent_device = &device->IDirect3DDevice8_iface;
+    IUnknown_AddRef(surface->parent_device);
 
     return D3D_OK;
 }
 
-IDirect3DSurface8Impl *unsafe_impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface)
+struct d3d8_surface *unsafe_impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface)
 {
     if (!iface)
         return NULL;
-    assert(iface->lpVtbl == &Direct3DSurface8_Vtbl);
+    assert(iface->lpVtbl == &d3d8_surface_vtbl);
 
     return impl_from_IDirect3DSurface8(iface);
 }
diff --git a/dlls/d3d8/swapchain.c b/dlls/d3d8/swapchain.c
index 68706f3..44719d5 100644
--- a/dlls/d3d8/swapchain.c
+++ b/dlls/d3d8/swapchain.c
< at >< at > -109,7 +109,7 < at >< at > static HRESULT WINAPI d3d8_swapchain_GetBackBuffer(IDirect3DSwapChain8 *iface,
 {
     struct d3d8_swapchain *swapchain = impl_from_IDirect3DSwapChain8(iface);
     struct wined3d_surface *wined3d_surface = NULL;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     HRESULT hr;
 
     TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n",
diff --git a/dlls/d3d8/texture.c b/dlls/d3d8/texture.c
index 49605d2..032a13b 100644
--- a/dlls/d3d8/texture.c
+++ b/dlls/d3d8/texture.c
< at >< at > -284,7 +284,7 < at >< at > static HRESULT WINAPI d3d8_texture_2d_GetSurfaceLevel(IDirect3DTexture8 *iface,
 {
     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
 
     TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
 
< at >< at > -308,7 +308,7 < at >< at > static HRESULT WINAPI d3d8_texture_2d_LockRect(IDirect3DTexture8 *iface, UINT le
 {
     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     HRESULT hr;
 
     TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n",
< at >< at > -331,7 +331,7 < at >< at > static HRESULT WINAPI d3d8_texture_2d_UnlockRect(IDirect3DTexture8 *iface, UINT
 {
     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     HRESULT hr;
 
     TRACE("iface %p, level %u.\n", iface, level);
< at >< at > -654,7 +654,7 < at >< at > static HRESULT WINAPI d3d8_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture8
 {
     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     UINT sub_resource_idx;
 
     TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
< at >< at > -681,7 +681,7 < at >< at > static HRESULT WINAPI d3d8_texture_cube_LockRect(IDirect3DCubeTexture8 *iface,
 {
     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     UINT sub_resource_idx;
     HRESULT hr;
 
< at >< at > -707,7 +707,7 < at >< at > static HRESULT WINAPI d3d8_texture_cube_UnlockRect(IDirect3DCubeTexture8 *iface,
 {
     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
     struct wined3d_resource *sub_resource;
-    IDirect3DSurface8Impl *surface_impl;
+    struct d3d8_surface *surface_impl;
     UINT sub_resource_idx;
     HRESULT hr;

d3d8: Add a trailing '\n' to an ERR() message.

Francois Gouget — 2012-05-23T13:41:14

---
 dlls/d3d8/device.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c
index 837e847..0f9cc59 100644
--- a/dlls/d3d8/device.c
+++ b/dlls/d3d8/device.c
< at >< at > -2373,7 +2373,7 < at >< at > static HRESULT WINAPI d3d8_device_GetIndices(IDirect3DDevice8 *iface,
     else
     {
         if (FAILED(hr))
-            ERR("Failed to get wined3d index buffer, hr %#x.", hr);
+            ERR("Failed to get wined3d index buffer, hr %#x.\n", hr);
         *buffer = NULL;
     }
     wined3d_mutex_unlock();

vbscript: Add support for integer values in conditional jumps.

Francois Gouget — 2012-05-23T13:36:04

---
 dlls/vbscript/interp.c       |   52 +++++++++++++++++++++++++++---------------
 dlls/vbscript/tests/lang.vbs |    8 +++++++
 2 files changed, 42 insertions(+), 18 deletions(-)

diff --git a/dlls/vbscript/interp.c b/dlls/vbscript/interp.c
index 67e1070..3f3e9c8 100644
--- a/dlls/vbscript/interp.c
+++ b/dlls/vbscript/interp.c
< at >< at > -350,6 +350,34 < at >< at > static inline void release_val(variant_val_t *v)
         VariantClear(v->v);
 }
 
+static int stack_pop_bool(exec_ctx_t *ctx, BOOL *b)
+{
+    variant_val_t val;
+    HRESULT hres;
+
+    hres = stack_pop_val(ctx, &val);
+    if(FAILED(hres))
+        return hres;
+
+    switch (V_VT(val.v))
+    {
+    case VT_BOOL:
+        *b = V_BOOL(val.v);
+        break;
+    case VT_I2:
+        *b = V_I2(val.v);
+        break;
+    case VT_I4:
+        *b = V_I4(val.v);
+        break;
+    default:
+        FIXME("unsupported for %s\n", debugstr_variant(val.v));
+        release_val(&val);
+        return E_NOTIMPL;
+    }
+    return S_OK;
+}
+
 static HRESULT stack_pop_disp(exec_ctx_t *ctx, IDispatch **ret)
 {
     VARIANT *v = stack_pop(ctx);
< at >< at > -886,22 +914,16 < at >< at > static HRESULT interp_jmp(exec_ctx_t *ctx)
 static HRESULT interp_jmp_false(exec_ctx_t *ctx)
 {
     const unsigned arg = ctx->instr->arg1.uint;
-    variant_val_t val;
     HRESULT hres;
+    BOOL b;
 
     TRACE("%u\n", arg);
 
-    hres = stack_pop_val(ctx, &val);
+    hres = stack_pop_bool(ctx, &b);
     if(FAILED(hres))
         return hres;
 
-    if(V_VT(val.v) != VT_BOOL) {
-        FIXME("unsupported for %s\n", debugstr_variant(val.v));
-        release_val(&val);
-        return E_NOTIMPL;
-    }
-
-    if(V_BOOL(val.v))
+    if(b)
         ctx->instr++;
     else
         instr_jmp(ctx, ctx->instr->arg1.uint);
< at >< at > -911,22 +933,16 < at >< at > static HRESULT interp_jmp_false(exec_ctx_t *ctx)
 static HRESULT interp_jmp_true(exec_ctx_t *ctx)
 {
     const unsigned arg = ctx->instr->arg1.uint;
-    variant_val_t val;
     HRESULT hres;
+    BOOL b;
 
     TRACE("%u\n", arg);
 
-    hres = stack_pop_val(ctx, &val);
+    hres = stack_pop_bool(ctx, &b);
     if(FAILED(hres))
         return hres;
 
-    if(V_VT(val.v) != VT_BOOL) {
-        FIXME("unsupported for %s\n", debugstr_variant(val.v));
-        release_val(&val);
-        return E_NOTIMPL;
-    }
-
-    if(V_BOOL(val.v))
+    if(b)
         instr_jmp(ctx, ctx->instr->arg1.uint);
     else
         ctx->instr++;
diff --git a/dlls/vbscript/tests/lang.vbs b/dlls/vbscript/tests/lang.vbs
index 1015e34..4900a52 100644
--- a/dlls/vbscript/tests/lang.vbs
+++ b/dlls/vbscript/tests/lang.vbs
< at >< at > -260,6 +260,14 < at >< at > End If
 Call ok(x, "elseif not called?")
 
 x = false
+if 1 then x = true
+Call ok(x, "if 1 not run?")
+
+x = false
+if &h10000& then x = true
+Call ok(x, "if &h10000& not run?")
+
+x = false
 y = false
 while not (x and y)
     if x then

axextend.idl: Added VIDEO_STREAM_CONFIG_CAPS andAUDIO_STREAM_CONFIG_CAPS declarations

Jacek Caban — 2012-05-23T12:37:36

---
 include/axextend.idl |   37 +++++++++++++++++++++++++++++++++++++
 1 files changed, 37 insertions(+), 0 deletions(-)