dlls/d3d9/surface.c

   1 /*
   2  * IDirect3DSurface9 implementation
   3  *
   4  * Copyright 2002-2005 Jason Edmeades
   5  *                     Raphael Junqueira
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "d3d9_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
  26
  27 /* IDirect3DSurface9 IUnknown parts follow: */
  28 static HRESULT WINAPI IDirect3DSurface9Impl_QueryInterface(LPDIRECT3DSURFACE9 iface, REFIID riid, LPVOID* ppobj) {
  29     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
  30
  31     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), ppobj);
  32
  33     if (IsEqualGUID(riid, &IID_IUnknown)
  34         || IsEqualGUID(riid, &IID_IDirect3DResource9)
  35         || IsEqualGUID(riid, &IID_IDirect3DSurface9)) {
  36         IDirect3DSurface9_AddRef(iface);
  37         *ppobj = This;
  38         return S_OK;
  39     }
  40
  41     WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
  42     *ppobj = NULL;
  43     return E_NOINTERFACE;
  44 }
  45
  46 static ULONG WINAPI IDirect3DSurface9Impl_AddRef(LPDIRECT3DSURFACE9 iface) {
  47     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
  48
  49     TRACE("iface %p.\n", iface);
  50
  51     if (This->forwardReference) {
  52         /* Forward refcounting */
  53         TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
  54         return IUnknown_AddRef(This->forwardReference);
  55     } else {
  56         /* No container, handle our own refcounting */
  57         ULONG ref = InterlockedIncrement(&This->ref);
  58
  59         TRACE("%p increasing refcount to %u.\n", iface, ref);
  60
  61         if (ref == 1)
  62         {
  63             if (This->parentDevice) IDirect3DDevice9Ex_AddRef(This->parentDevice);
  64             wined3d_mutex_lock();
  65             IWineD3DSurface_AddRef(This->wineD3DSurface);
  66             wined3d_mutex_unlock();
  67         }
  68
  69         return ref;
  70     }
  71
  72 }
  73
  74 static ULONG WINAPI IDirect3DSurface9Impl_Release(LPDIRECT3DSURFACE9 iface) {
  75     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
  76
  77     TRACE("iface %p.\n", iface);
  78
  79     if (This->forwardReference) {
  80         /* Forward to the containerParent */
  81         TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
  82         return IUnknown_Release(This->forwardReference);
  83     } else {
  84         /* No container, handle our own refcounting */
  85         ULONG ref = InterlockedDecrement(&This->ref);
  86
  87         TRACE("%p decreasing refcount to %u.\n", iface, ref);
  88
  89         if (ref == 0) {
  90             IDirect3DDevice9Ex *parentDevice = This->parentDevice;
  91
  92             wined3d_mutex_lock();
  93             IWineD3DSurface_Release(This->wineD3DSurface);
  94             wined3d_mutex_unlock();
  95
  96             /* Release the device last, as it may cause the device to be destroyed. */
  97             if (parentDevice) IDirect3DDevice9Ex_Release(parentDevice);
  98         }
  99
 100         return ref;
 101     }
 102 }
 103
 104 /* IDirect3DSurface9 IDirect3DResource9 Interface follow: */
 105 static HRESULT WINAPI IDirect3DSurface9Impl_GetDevice(IDirect3DSurface9 *iface, IDirect3DDevice9 **device)
 106 {
 107     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 108
 109     TRACE("iface %p, device %p.\n", iface, device);
 110
 111     *device = (IDirect3DDevice9 *)This->parentDevice;
 112     IDirect3DDevice9_AddRef(*device);
 113
 114     TRACE("Returning device %p.\n", *device);
 115
 116     return D3D_OK;
 117 }
 118
 119 static HRESULT WINAPI IDirect3DSurface9Impl_SetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) {
 120     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 121     HRESULT hr;
 122
 123     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 124             iface, debugstr_guid(refguid), pData, SizeOfData, Flags);
 125
 126     wined3d_mutex_lock();
 127     hr = IWineD3DSurface_SetPrivateData(This->wineD3DSurface, refguid, pData, SizeOfData, Flags);
 128     wined3d_mutex_unlock();
 129
 130     return hr;
 131 }
 132
 133 static HRESULT WINAPI IDirect3DSurface9Impl_GetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) {
 134     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 135     HRESULT hr;
 136
 137     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 138             iface, debugstr_guid(refguid), pData, pSizeOfData);
 139
 140     wined3d_mutex_lock();
 141     hr = IWineD3DSurface_GetPrivateData(This->wineD3DSurface, refguid, pData, pSizeOfData);
 142     wined3d_mutex_unlock();
 143
 144     return hr;
 145 }
 146
 147 static HRESULT WINAPI IDirect3DSurface9Impl_FreePrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid) {
 148     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 149     HRESULT hr;
 150
 151     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(refguid));
 152
 153     wined3d_mutex_lock();
 154     hr = IWineD3DSurface_FreePrivateData(This->wineD3DSurface, refguid);
 155     wined3d_mutex_unlock();
 156
 157     return hr;
 158 }
 159
 160 static DWORD WINAPI IDirect3DSurface9Impl_SetPriority(LPDIRECT3DSURFACE9 iface, DWORD PriorityNew) {
 161     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 162     HRESULT hr;
 163
 164     TRACE("iface %p, priority %u.\n", iface, PriorityNew);
 165
 166     wined3d_mutex_lock();
 167     hr = IWineD3DSurface_SetPriority(This->wineD3DSurface, PriorityNew);
 168     wined3d_mutex_unlock();
 169
 170     return hr;
 171 }
 172
 173 static DWORD WINAPI IDirect3DSurface9Impl_GetPriority(LPDIRECT3DSURFACE9 iface) {
 174     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 175     HRESULT hr;
 176
 177     TRACE("iface %p.\n", iface);
 178
 179     wined3d_mutex_lock();
 180     hr = IWineD3DSurface_GetPriority(This->wineD3DSurface);
 181     wined3d_mutex_unlock();
 182
 183     return hr;
 184 }
 185
 186 static void WINAPI IDirect3DSurface9Impl_PreLoad(LPDIRECT3DSURFACE9 iface) {
 187     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 188
 189     TRACE("iface %p.\n", iface);
 190
 191     wined3d_mutex_lock();
 192     IWineD3DSurface_PreLoad(This->wineD3DSurface);
 193     wined3d_mutex_unlock();
 194 }
 195
 196 static D3DRESOURCETYPE WINAPI IDirect3DSurface9Impl_GetType(LPDIRECT3DSURFACE9 iface) {
 197     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 198     D3DRESOURCETYPE ret;
 199
 200     TRACE("iface %p.\n", iface);
 201
 202     wined3d_mutex_lock();
 203     ret = IWineD3DSurface_GetType(This->wineD3DSurface);
 204     wined3d_mutex_unlock();
 205
 206     return ret;
 207 }
 208
 209 /* IDirect3DSurface9 Interface follow: */
 210 static HRESULT WINAPI IDirect3DSurface9Impl_GetContainer(LPDIRECT3DSURFACE9 iface, REFIID riid, void** ppContainer) {
 211     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 212     HRESULT res;
 213
 214     TRACE("iface %p, riid %s, container %p.\n", iface, debugstr_guid(riid), ppContainer);
 215
 216     if (!This->container) return E_NOINTERFACE;
 217
 218     if (!ppContainer) {
 219         ERR("Called without a valid ppContainer\n");
 220     }
 221
 222     res = IUnknown_QueryInterface(This->container, riid, ppContainer);
 223
 224     TRACE("Returning ppContainer %p, *ppContainer %p\n", ppContainer, *ppContainer);
 225
 226     return res;
 227 }
 228
 229 static HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(LPDIRECT3DSURFACE9 iface, D3DSURFACE_DESC* pDesc) {
 230     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 231     WINED3DSURFACE_DESC wined3ddesc;
 232     HRESULT hr;
 233
 234     TRACE("iface %p, desc %p.\n", iface, pDesc);
 235
 236     wined3d_mutex_lock();
 237     hr = IWineD3DSurface_GetDesc(This->wineD3DSurface, &wined3ddesc);
 238     wined3d_mutex_unlock();
 239
 240     if (SUCCEEDED(hr))
 241     {
 242         pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.format);
 243         pDesc->Type = wined3ddesc.resource_type;
 244         pDesc->Usage = wined3ddesc.usage;
 245         pDesc->Pool = wined3ddesc.pool;
 246         pDesc->MultiSampleType = wined3ddesc.multisample_type;
 247         pDesc->MultiSampleQuality = wined3ddesc.multisample_quality;
 248         pDesc->Width = wined3ddesc.width;
 249         pDesc->Height = wined3ddesc.height;
 250     }
 251
 252     return hr;
 253 }
 254
 255 static HRESULT WINAPI IDirect3DSurface9Impl_LockRect(LPDIRECT3DSURFACE9 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) {
 256     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 257     HRESULT hr;
 258
 259     TRACE("iface %p, locked_rect %p, rect %p, flags %#x.\n", iface, pLockedRect, pRect, Flags);
 260
 261     wined3d_mutex_lock();
 262     hr = IWineD3DSurface_LockRect(This->wineD3DSurface, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags);
 263     wined3d_mutex_unlock();
 264
 265     return hr;
 266 }
 267
 268 static HRESULT WINAPI IDirect3DSurface9Impl_UnlockRect(LPDIRECT3DSURFACE9 iface) {
 269     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 270     HRESULT hr;
 271
 272     TRACE("iface %p.\n", iface);
 273
 274     wined3d_mutex_lock();
 275     hr = IWineD3DSurface_UnlockRect(This->wineD3DSurface);
 276     wined3d_mutex_unlock();
 277
 278     switch(hr)
 279     {
 280         case WINEDDERR_NOTLOCKED:       return D3DERR_INVALIDCALL;
 281         default:                        return hr;
 282     }
 283 }
 284
 285 static HRESULT WINAPI IDirect3DSurface9Impl_GetDC(LPDIRECT3DSURFACE9 iface, HDC* phdc) {
 286     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 287     HRESULT hr;
 288
 289     TRACE("iface %p, hdc %p.\n", iface, phdc);
 290
 291     if(!This->getdc_supported)
 292     {
 293         WARN("Surface does not support GetDC, returning D3DERR_INVALIDCALL\n");
 294         /* Don't touch the DC */
 295         return D3DERR_INVALIDCALL;
 296     }
 297
 298     wined3d_mutex_lock();
 299     hr = IWineD3DSurface_GetDC(This->wineD3DSurface, phdc);
 300     wined3d_mutex_unlock();
 301
 302     return hr;
 303 }
 304
 305 static HRESULT WINAPI IDirect3DSurface9Impl_ReleaseDC(LPDIRECT3DSURFACE9 iface, HDC hdc) {
 306     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 307     HRESULT hr;
 308
 309     TRACE("iface %p, hdc %p.\n", iface, hdc);
 310
 311     wined3d_mutex_lock();
 312     hr = IWineD3DSurface_ReleaseDC(This->wineD3DSurface, hdc);
 313     wined3d_mutex_unlock();
 314
 315     switch(hr) {
 316         case WINEDDERR_NODC:    return WINED3DERR_INVALIDCALL;
 317         default:                return hr;
 318     }
 319 }
 320
 321 static const IDirect3DSurface9Vtbl Direct3DSurface9_Vtbl =
 322 {
 323     /* IUnknown */
 324     IDirect3DSurface9Impl_QueryInterface,
 325     IDirect3DSurface9Impl_AddRef,
 326     IDirect3DSurface9Impl_Release,
 327     /* IDirect3DResource9 */
 328     IDirect3DSurface9Impl_GetDevice,
 329     IDirect3DSurface9Impl_SetPrivateData,
 330     IDirect3DSurface9Impl_GetPrivateData,
 331     IDirect3DSurface9Impl_FreePrivateData,
 332     IDirect3DSurface9Impl_SetPriority,
 333     IDirect3DSurface9Impl_GetPriority,
 334     IDirect3DSurface9Impl_PreLoad,
 335     IDirect3DSurface9Impl_GetType,
 336     /* IDirect3DSurface9 */
 337     IDirect3DSurface9Impl_GetContainer,
 338     IDirect3DSurface9Impl_GetDesc,
 339     IDirect3DSurface9Impl_LockRect,
 340     IDirect3DSurface9Impl_UnlockRect,
 341     IDirect3DSurface9Impl_GetDC,
 342     IDirect3DSurface9Impl_ReleaseDC
 343 };
 344
 345 static void STDMETHODCALLTYPE surface_wined3d_object_destroyed(void *parent)
 346 {
 347     HeapFree(GetProcessHeap(), 0, parent);
 348 }
 349
 350 static const struct wined3d_parent_ops d3d9_surface_wined3d_parent_ops =
 351 {
 352     surface_wined3d_object_destroyed,
 353 };
 354
 355 HRESULT surface_init(IDirect3DSurface9Impl *surface, IDirect3DDevice9Impl *device,
 356         UINT width, UINT height, D3DFORMAT format, BOOL lockable, BOOL discard, UINT level,
 357         DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality)
 358 {
 359     HRESULT hr;
 360
 361     surface->lpVtbl = &Direct3DSurface9_Vtbl;
 362     surface->ref = 1;
 363
 364     switch (format)
 365     {
 366         case D3DFMT_A8R8G8B8:
 367         case D3DFMT_X8R8G8B8:
 368         case D3DFMT_R5G6B5:
 369         case D3DFMT_X1R5G5B5:
 370         case D3DFMT_A1R5G5B5:
 371         case D3DFMT_R8G8B8:
 372             surface->getdc_supported = TRUE;
 373             break;
 374
 375         default:
 376             surface->getdc_supported = FALSE;
 377             break;
 378     }
 379
 380     /* FIXME: Check MAX bounds of MultisampleQuality. */
 381     if (multisample_quality > 0)
 382     {
 383         FIXME("Multisample quality set to %u, substituting 0.\n", multisample_quality);
 384         multisample_quality = 0;
 385     }
 386
 387     wined3d_mutex_lock();
 388     hr = IWineD3DDevice_CreateSurface(device->WineD3DDevice, width, height, wined3dformat_from_d3dformat(format),
 389             lockable, discard, level, &surface->wineD3DSurface, usage & WINED3DUSAGE_MASK, (WINED3DPOOL)pool,
 390             multisample_type, multisample_quality, SURFACE_OPENGL, (IUnknown *)surface,
 391             &d3d9_surface_wined3d_parent_ops);
 392     wined3d_mutex_unlock();
 393     if (FAILED(hr))
 394     {
 395         WARN("Failed to create wined3d surface, hr %#x.\n", hr);
 396         return hr;
 397     }
 398
 399     surface->parentDevice = (IDirect3DDevice9Ex *)device;
 400     IDirect3DDevice9Ex_AddRef(surface->parentDevice);
 401
 402     return D3D_OK;
 403 }