dlls/ddraw/surface.c

   1 /* DirectDraw Surface Implementation
   2  *
   3  * Copyright (c) 1997-2000 Marcus Meissner
   4  * Copyright (c) 1998-2000 Lionel Ulmer
   5  * Copyright (c) 2000-2001 TransGaming Technologies Inc.
   6  * Copyright (c) 2006 Stefan Dösinger
   7  * Copyright (c) 2011 Ričardas Barkauskas for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include "ddraw_private.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  30
  31 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface2(IDirectDrawSurface2 *iface);
  32 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface3(IDirectDrawSurface3 *iface);
  33
  34 static inline struct ddraw_surface *impl_from_IDirectDrawGammaControl(IDirectDrawGammaControl *iface)
  35 {
  36     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawGammaControl_iface);
  37 }
  38
  39 /* This is slow, of course. Also, in case of locks, we can't prevent other
  40  * applications from drawing to the screen while we've locked the frontbuffer.
  41  * We'd like to do this in wined3d instead, but for that to work wined3d needs
  42  * to support windowless rendering first. */
  43 HRESULT ddraw_surface_update_frontbuffer(struct ddraw_surface *surface, const RECT *rect, BOOL read)
  44 {
  45     HDC surface_dc, screen_dc;
  46     int x, y, w, h;
  47     HRESULT hr;
  48     BOOL ret;
  49
  50     if (!rect)
  51     {
  52         x = 0;
  53         y = 0;
  54         w = surface->surface_desc.dwWidth;
  55         h = surface->surface_desc.dwHeight;
  56     }
  57     else
  58     {
  59         x = rect->left;
  60         y = rect->top;
  61         w = rect->right - rect->left;
  62         h = rect->bottom - rect->top;
  63     }
  64
  65     if (w <= 0 || h <= 0)
  66         return DD_OK;
  67
  68     if (surface->ddraw->swapchain_window)
  69     {
  70         /* Nothing to do, we control the frontbuffer, or at least the parts we
  71          * care about. */
  72         if (read)
  73             return DD_OK;
  74
  75         return wined3d_surface_blt(surface->ddraw->wined3d_frontbuffer, rect,
  76                 surface->wined3d_surface, rect, 0, NULL, WINED3D_TEXF_POINT);
  77     }
  78
  79     if (FAILED(hr = wined3d_surface_getdc(surface->wined3d_surface, &surface_dc)))
  80     {
  81         ERR("Failed to get surface DC, hr %#x.\n", hr);
  82         return hr;
  83     }
  84     if (surface->palette)
  85         wined3d_palette_apply_to_dc(surface->palette->wineD3DPalette, surface_dc);
  86
  87     if (!(screen_dc = GetDC(NULL)))
  88     {
  89         wined3d_surface_releasedc(surface->wined3d_surface, surface_dc);
  90         ERR("Failed to get screen DC.\n");
  91         return E_FAIL;
  92     }
  93
  94     if (read)
  95         ret = BitBlt(surface_dc, x, y, w, h,
  96                 screen_dc, x, y, SRCCOPY);
  97     else
  98         ret = BitBlt(screen_dc, x, y, w, h,
  99                 surface_dc, x, y, SRCCOPY);
 100
 101     ReleaseDC(NULL, screen_dc);
 102     wined3d_surface_releasedc(surface->wined3d_surface, surface_dc);
 103
 104     if (!ret)
 105     {
 106         ERR("Failed to blit to/from screen.\n");
 107         return E_FAIL;
 108     }
 109
 110     return DD_OK;
 111 }
 112
 113 /*****************************************************************************
 114  * IUnknown parts follow
 115  *****************************************************************************/
 116
 117 /*****************************************************************************
 118  * IDirectDrawSurface7::QueryInterface
 119  *
 120  * A normal QueryInterface implementation. For QueryInterface rules
 121  * see ddraw.c, IDirectDraw7::QueryInterface. This method
 122  * can Query IDirectDrawSurface interfaces in all version, IDirect3DTexture
 123  * in all versions, the IDirectDrawGammaControl interface and it can
 124  * create an IDirect3DDevice. (Uses IDirect3D7::CreateDevice)
 125  *
 126  * Params:
 127  *  riid: The interface id queried for
 128  *  obj: Address to write the pointer to
 129  *
 130  * Returns:
 131  *  S_OK on success
 132  *  E_NOINTERFACE if the requested interface wasn't found
 133  *
 134  *****************************************************************************/
 135 static HRESULT WINAPI ddraw_surface7_QueryInterface(IDirectDrawSurface7 *iface, REFIID riid, void **obj)
 136 {
 137     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
 138
 139     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), obj);
 140
 141     /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
 142     *obj = NULL;
 143
 144     if(!riid)
 145         return DDERR_INVALIDPARAMS;
 146
 147     if (IsEqualGUID(riid, &IID_IDirectDrawSurface7))
 148     {
 149         IDirectDrawSurface7_AddRef(iface);
 150         *obj = iface;
 151         TRACE("(%p) returning IDirectDrawSurface7 interface at %p\n", This, *obj);
 152         return S_OK;
 153     }
 154
 155     if (IsEqualGUID(riid, &IID_IDirectDrawSurface4))
 156     {
 157         IDirectDrawSurface4_AddRef(&This->IDirectDrawSurface4_iface);
 158         *obj = &This->IDirectDrawSurface4_iface;
 159         TRACE("(%p) returning IDirectDrawSurface4 interface at %p\n", This, *obj);
 160         return S_OK;
 161     }
 162
 163     if (IsEqualGUID(riid, &IID_IDirectDrawSurface3))
 164     {
 165         IDirectDrawSurface3_AddRef(&This->IDirectDrawSurface3_iface);
 166         *obj = &This->IDirectDrawSurface3_iface;
 167         TRACE("(%p) returning IDirectDrawSurface3 interface at %p\n", This, *obj);
 168         return S_OK;
 169     }
 170
 171     if (IsEqualGUID(riid, &IID_IDirectDrawSurface2))
 172     {
 173         IDirectDrawSurface2_AddRef(&This->IDirectDrawSurface2_iface);
 174         *obj = &This->IDirectDrawSurface2_iface;
 175         TRACE("(%p) returning IDirectDrawSurface2 interface at %p\n", This, *obj);
 176         return S_OK;
 177     }
 178
 179     if (IsEqualGUID(riid, &IID_IDirectDrawSurface)
 180             || IsEqualGUID(riid, &IID_IUnknown))
 181     {
 182         IDirectDrawSurface_AddRef(&This->IDirectDrawSurface_iface);
 183         *obj = &This->IDirectDrawSurface_iface;
 184         TRACE("(%p) returning IDirectDrawSurface interface at %p\n", This, *obj);
 185         return S_OK;
 186     }
 187
 188     if (IsEqualGUID(riid, &IID_IDirectDrawGammaControl))
 189     {
 190         IDirectDrawGammaControl_AddRef(&This->IDirectDrawGammaControl_iface);
 191         *obj = &This->IDirectDrawGammaControl_iface;
 192         TRACE("(%p) returning IDirectDrawGammaControl interface at %p\n", This, *obj);
 193         return S_OK;
 194     }
 195
 196     if (IsEqualGUID(riid, &IID_IDirectDrawColorControl))
 197     {
 198         WARN("Color control not implemented.\n");
 199         *obj = NULL;
 200         return E_NOINTERFACE;
 201     }
 202
 203     if (This->version != 7)
 204     {
 205         if (IsEqualGUID(riid, &IID_D3DDEVICE_WineD3D)
 206                 || IsEqualGUID(riid, &IID_IDirect3DHALDevice)
 207                 || IsEqualGUID(riid, &IID_IDirect3DRGBDevice))
 208         {
 209             wined3d_mutex_lock();
 210             if (!This->device1)
 211             {
 212                 HRESULT hr;
 213
 214                 if (FAILED(hr = d3d_device_create(This->ddraw, This, (IUnknown *)&This->IDirectDrawSurface_iface,
 215                         1, &This->device1, (IUnknown *)&This->IDirectDrawSurface_iface)))
 216                 {
 217                     This->device1 = NULL;
 218                     wined3d_mutex_unlock();
 219                     WARN("Failed to create device, hr %#x.\n", hr);
 220                     return hr;
 221                 }
 222             }
 223             wined3d_mutex_unlock();
 224
 225             IDirect3DDevice_AddRef(&This->device1->IDirect3DDevice_iface);
 226             *obj = &This->device1->IDirect3DDevice_iface;
 227             return S_OK;
 228         }
 229
 230         if (IsEqualGUID(&IID_IDirect3DTexture2, riid))
 231         {
 232             IDirect3DTexture2_AddRef(&This->IDirect3DTexture2_iface);
 233             *obj = &This->IDirect3DTexture2_iface;
 234             return S_OK;
 235         }
 236
 237         if (IsEqualGUID( &IID_IDirect3DTexture, riid ))
 238         {
 239             IDirect3DTexture2_AddRef(&This->IDirect3DTexture_iface);
 240             *obj = &This->IDirect3DTexture_iface;
 241             return S_OK;
 242         }
 243     }
 244
 245     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 246
 247     if (This->version != 7)
 248         return E_INVALIDARG;
 249
 250     return E_NOINTERFACE;
 251 }
 252
 253 static HRESULT WINAPI ddraw_surface4_QueryInterface(IDirectDrawSurface4 *iface, REFIID riid, void **object)
 254 {
 255     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
 256
 257     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 258
 259     return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
 260 }
 261
 262 static HRESULT WINAPI ddraw_surface3_QueryInterface(IDirectDrawSurface3 *iface, REFIID riid, void **object)
 263 {
 264     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
 265
 266     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 267
 268     return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
 269 }
 270
 271 static HRESULT WINAPI ddraw_surface2_QueryInterface(IDirectDrawSurface2 *iface, REFIID riid, void **object)
 272 {
 273     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
 274
 275     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 276
 277     return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
 278 }
 279
 280 static HRESULT WINAPI ddraw_surface1_QueryInterface(IDirectDrawSurface *iface, REFIID riid, void **object)
 281 {
 282     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
 283
 284     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 285
 286     return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
 287 }
 288
 289 static HRESULT WINAPI ddraw_gamma_control_QueryInterface(IDirectDrawGammaControl *iface,
 290         REFIID riid, void **object)
 291 {
 292     struct ddraw_surface *surface = impl_from_IDirectDrawGammaControl(iface);
 293
 294     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 295
 296     return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
 297 }
 298
 299 static HRESULT WINAPI d3d_texture2_QueryInterface(IDirect3DTexture2 *iface, REFIID riid, void **object)
 300 {
 301     struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
 302
 303     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 304
 305     return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
 306 }
 307
 308 static HRESULT WINAPI d3d_texture1_QueryInterface(IDirect3DTexture *iface, REFIID riid, void **object)
 309 {
 310     struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
 311
 312     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 313
 314     return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
 315 }
 316
 317 static void ddraw_surface_add_iface(struct ddraw_surface *surface)
 318 {
 319     ULONG iface_count = InterlockedIncrement(&surface->iface_count);
 320     TRACE("%p increasing iface count to %u.\n", surface, iface_count);
 321
 322     if (iface_count == 1)
 323     {
 324         if (surface->ifaceToRelease)
 325             IUnknown_AddRef(surface->ifaceToRelease);
 326         wined3d_mutex_lock();
 327         if (surface->wined3d_rtv)
 328             wined3d_rendertarget_view_incref(surface->wined3d_rtv);
 329         if (surface->wined3d_surface)
 330             wined3d_surface_incref(surface->wined3d_surface);
 331         if (surface->wined3d_texture)
 332             wined3d_texture_incref(surface->wined3d_texture);
 333         wined3d_mutex_unlock();
 334     }
 335 }
 336
 337 /*****************************************************************************
 338  * IDirectDrawSurface7::AddRef
 339  *
 340  * A normal addref implementation
 341  *
 342  * Returns:
 343  *  The new refcount
 344  *
 345  *****************************************************************************/
 346 static ULONG WINAPI ddraw_surface7_AddRef(IDirectDrawSurface7 *iface)
 347 {
 348     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
 349     ULONG refcount = InterlockedIncrement(&This->ref7);
 350
 351     TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
 352
 353     if (refcount == 1)
 354     {
 355         ddraw_surface_add_iface(This);
 356     }
 357
 358     return refcount;
 359 }
 360
 361 static ULONG WINAPI ddraw_surface4_AddRef(IDirectDrawSurface4 *iface)
 362 {
 363     struct ddraw_surface *This = impl_from_IDirectDrawSurface4(iface);
 364     ULONG refcount = InterlockedIncrement(&This->ref4);
 365
 366     TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
 367
 368     if (refcount == 1)
 369     {
 370         ddraw_surface_add_iface(This);
 371     }
 372
 373     return refcount;
 374 }
 375
 376 static ULONG WINAPI ddraw_surface3_AddRef(IDirectDrawSurface3 *iface)
 377 {
 378     struct ddraw_surface *This = impl_from_IDirectDrawSurface3(iface);
 379     ULONG refcount = InterlockedIncrement(&This->ref3);
 380
 381     TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
 382
 383     if (refcount == 1)
 384     {
 385         ddraw_surface_add_iface(This);
 386     }
 387
 388     return refcount;
 389 }
 390
 391 static ULONG WINAPI ddraw_surface2_AddRef(IDirectDrawSurface2 *iface)
 392 {
 393     struct ddraw_surface *This = impl_from_IDirectDrawSurface2(iface);
 394     ULONG refcount = InterlockedIncrement(&This->ref2);
 395
 396     TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
 397
 398     if (refcount == 1)
 399     {
 400         ddraw_surface_add_iface(This);
 401     }
 402
 403     return refcount;
 404 }
 405
 406 static ULONG WINAPI ddraw_surface1_AddRef(IDirectDrawSurface *iface)
 407 {
 408     struct ddraw_surface *This = impl_from_IDirectDrawSurface(iface);
 409     ULONG refcount = InterlockedIncrement(&This->ref1);
 410
 411     TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
 412
 413     if (refcount == 1)
 414     {
 415         ddraw_surface_add_iface(This);
 416     }
 417
 418     return refcount;
 419 }
 420
 421 static ULONG WINAPI ddraw_gamma_control_AddRef(IDirectDrawGammaControl *iface)
 422 {
 423     struct ddraw_surface *This = impl_from_IDirectDrawGammaControl(iface);
 424     ULONG refcount = InterlockedIncrement(&This->gamma_count);
 425
 426     TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
 427
 428     if (refcount == 1)
 429     {
 430         ddraw_surface_add_iface(This);
 431     }
 432
 433     return refcount;
 434 }
 435
 436 static ULONG WINAPI d3d_texture2_AddRef(IDirect3DTexture2 *iface)
 437 {
 438     struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
 439
 440     TRACE("iface %p.\n", iface);
 441
 442     return IUnknown_AddRef(surface->texture_outer);
 443 }
 444
 445 static ULONG WINAPI d3d_texture1_AddRef(IDirect3DTexture *iface)
 446 {
 447     struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
 448
 449     TRACE("iface %p.\n", iface);
 450
 451     return IUnknown_AddRef(surface->texture_outer);
 452 }
 453
 454 static HRESULT ddraw_surface_set_palette(struct ddraw_surface *surface, IDirectDrawPalette *palette)
 455 {
 456     struct ddraw_palette *palette_impl = unsafe_impl_from_IDirectDrawPalette(palette);
 457     struct ddraw_palette *prev;
 458
 459     TRACE("iface %p, palette %p.\n", surface, palette);
 460
 461     if (palette_impl && palette_impl->flags & DDPCAPS_ALPHA
 462             && !(surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE))
 463     {
 464         WARN("Alpha palette set on non-texture surface, returning DDERR_INVALIDSURFACETYPE.\n");
 465         return DDERR_INVALIDSURFACETYPE;
 466     }
 467
 468     if (!format_is_paletteindexed(&surface->surface_desc.u4.ddpfPixelFormat))
 469         return DDERR_INVALIDPIXELFORMAT;
 470
 471     wined3d_mutex_lock();
 472
 473     prev = surface->palette;
 474     if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
 475     {
 476         if (prev)
 477             prev->flags &= ~DDPCAPS_PRIMARYSURFACE;
 478         if (palette_impl)
 479             palette_impl->flags |= DDPCAPS_PRIMARYSURFACE;
 480         wined3d_swapchain_set_palette(surface->ddraw->wined3d_swapchain,
 481                 palette_impl ? palette_impl->wineD3DPalette : NULL);
 482         ddraw_surface_update_frontbuffer(surface, NULL, FALSE);
 483     }
 484     if (palette_impl)
 485         IDirectDrawPalette_AddRef(&palette_impl->IDirectDrawPalette_iface);
 486     if (prev)
 487         IDirectDrawPalette_Release(&prev->IDirectDrawPalette_iface);
 488     surface->palette = palette_impl;
 489
 490     wined3d_mutex_unlock();
 491
 492     return DD_OK;
 493 }
 494
 495 static void ddraw_surface_cleanup(struct ddraw_surface *surface)
 496 {
 497     struct ddraw_surface *surf;
 498     UINT i;
 499
 500     TRACE("surface %p.\n", surface);
 501
 502     /* The refcount test shows that the palette is detached when the surface
 503      * is destroyed. */
 504     ddraw_surface_set_palette(surface, NULL);
 505
 506     /* Loop through all complex attached surfaces and destroy them.
 507      *
 508      * Yet again, only the root can have more than one complexly attached
 509      * surface, all the others have a total of one. */
 510     for (i = 0; i < MAX_COMPLEX_ATTACHED; ++i)
 511     {
 512         if (!surface->complex_array[i])
 513             break;
 514
 515         surf = surface->complex_array[i];
 516         surface->complex_array[i] = NULL;
 517         if (!surf->is_complex_root)
 518             ddraw_surface_cleanup(surf);
 519     }
 520
 521     if (surface->device1)
 522         IUnknown_Release(&surface->device1->IUnknown_inner);
 523
 524     if (surface->iface_count > 1)
 525     {
 526         /* This can happen when a complex surface is destroyed, because the
 527          * 2nd surface was addref()ed when the app called
 528          * GetAttachedSurface(). */
 529         WARN("Destroying surface %p with refcounts 7: %u 4: %u 3: %u 2: %u 1: %u.\n",
 530                 surface, surface->ref7, surface->ref4, surface->ref3, surface->ref2, surface->ref1);
 531     }
 532
 533     if (surface->wined3d_rtv)
 534         wined3d_rendertarget_view_decref(surface->wined3d_rtv);
 535     if (surface->wined3d_texture)
 536         wined3d_texture_decref(surface->wined3d_texture);
 537     if (surface->wined3d_surface)
 538         wined3d_surface_decref(surface->wined3d_surface);
 539 }
 540
 541 ULONG ddraw_surface_release_iface(struct ddraw_surface *This)
 542 {
 543     ULONG iface_count = InterlockedDecrement(&This->iface_count);
 544     TRACE("%p decreasing iface count to %u.\n", This, iface_count);
 545
 546     if (iface_count == 0)
 547     {
 548         IUnknown *release_iface = This->ifaceToRelease;
 549
 550         /* Complex attached surfaces are destroyed implicitly when the root is released */
 551         wined3d_mutex_lock();
 552         if(!This->is_complex_root)
 553         {
 554             WARN("(%p) Attempt to destroy a surface that is not a complex root\n", This);
 555             wined3d_mutex_unlock();
 556             return iface_count;
 557         }
 558         ddraw_surface_cleanup(This);
 559         wined3d_mutex_unlock();
 560
 561         if (release_iface)
 562             IUnknown_Release(release_iface);
 563     }
 564
 565     return iface_count;
 566 }
 567
 568 /*****************************************************************************
 569  * IDirectDrawSurface7::Release
 570  *
 571  * Reduces the surface's refcount by 1. If the refcount falls to 0, the
 572  * surface is destroyed.
 573  *
 574  * Destroying the surface is a bit tricky. For the connection between
 575  * WineD3DSurfaces and DirectDrawSurfaces see IDirectDraw7::CreateSurface
 576  * It has a nice graph explaining the connection.
 577  *
 578  * What happens here is basically this:
 579  * When a surface is destroyed, its WineD3DSurface is released,
 580  * and the refcount of the DirectDraw interface is reduced by 1. If it has
 581  * complex surfaces attached to it, then these surfaces are destroyed too,
 582  * regardless of their refcount. If any surface being destroyed has another
 583  * surface attached to it (with a "soft" attachment, not complex), then
 584  * this surface is detached with DeleteAttachedSurface.
 585  *
 586  * When the surface is a texture, the WineD3DTexture is released.
 587  * If the surface is the Direct3D render target, then the D3D
 588  * capabilities of the WineD3DDevice are uninitialized, which causes the
 589  * swapchain to be released.
 590  *
 591  * When a complex sublevel falls to ref zero, then this is ignored.
 592  *
 593  * Returns:
 594  *  The new refcount
 595  *
 596  *****************************************************************************/
 597 static ULONG WINAPI ddraw_surface7_Release(IDirectDrawSurface7 *iface)
 598 {
 599     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
 600     ULONG refcount = InterlockedDecrement(&This->ref7);
 601
 602     TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
 603
 604     if (refcount == 0)
 605     {
 606         ddraw_surface_release_iface(This);
 607     }
 608
 609     return refcount;
 610 }
 611
 612 static ULONG WINAPI ddraw_surface4_Release(IDirectDrawSurface4 *iface)
 613 {
 614     struct ddraw_surface *This = impl_from_IDirectDrawSurface4(iface);
 615     ULONG refcount = InterlockedDecrement(&This->ref4);
 616
 617     TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
 618
 619     if (refcount == 0)
 620     {
 621         ddraw_surface_release_iface(This);
 622     }
 623
 624     return refcount;
 625 }
 626
 627 static ULONG WINAPI ddraw_surface3_Release(IDirectDrawSurface3 *iface)
 628 {
 629     struct ddraw_surface *This = impl_from_IDirectDrawSurface3(iface);
 630     ULONG refcount = InterlockedDecrement(&This->ref3);
 631
 632     TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
 633
 634     if (refcount == 0)
 635     {
 636         ddraw_surface_release_iface(This);
 637     }
 638
 639     return refcount;
 640 }
 641
 642 static ULONG WINAPI ddraw_surface2_Release(IDirectDrawSurface2 *iface)
 643 {
 644     struct ddraw_surface *This = impl_from_IDirectDrawSurface2(iface);
 645     ULONG refcount = InterlockedDecrement(&This->ref2);
 646
 647     TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
 648
 649     if (refcount == 0)
 650     {
 651         ddraw_surface_release_iface(This);
 652     }
 653
 654     return refcount;
 655 }
 656
 657 static ULONG WINAPI ddraw_surface1_Release(IDirectDrawSurface *iface)
 658 {
 659     struct ddraw_surface *This = impl_from_IDirectDrawSurface(iface);
 660     ULONG refcount = InterlockedDecrement(&This->ref1);
 661
 662     TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
 663
 664     if (refcount == 0)
 665     {
 666         ddraw_surface_release_iface(This);
 667     }
 668
 669     return refcount;
 670 }
 671
 672 static ULONG WINAPI ddraw_gamma_control_Release(IDirectDrawGammaControl *iface)
 673 {
 674     struct ddraw_surface *This = impl_from_IDirectDrawGammaControl(iface);
 675     ULONG refcount = InterlockedDecrement(&This->gamma_count);
 676
 677     TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
 678
 679     if (refcount == 0)
 680     {
 681         ddraw_surface_release_iface(This);
 682     }
 683
 684     return refcount;
 685 }
 686
 687 static ULONG WINAPI d3d_texture2_Release(IDirect3DTexture2 *iface)
 688 {
 689     struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
 690
 691     TRACE("iface %p.\n", iface);
 692
 693     return IUnknown_Release(surface->texture_outer);
 694 }
 695
 696 static ULONG WINAPI d3d_texture1_Release(IDirect3DTexture *iface)
 697 {
 698     struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
 699
 700     TRACE("iface %p.\n", iface);
 701
 702     return IUnknown_Release(surface->texture_outer);
 703 }
 704
 705 /*****************************************************************************
 706  * IDirectDrawSurface7::GetAttachedSurface
 707  *
 708  * Returns an attached surface with the requested caps. Surface attachment
 709  * and complex surfaces are not clearly described by the MSDN or sdk,
 710  * so this method is tricky and likely to contain problems.
 711  * This implementation searches the complex list first, then the
 712  * attachment chain.
 713  *
 714  * The chains are searched from This down to the last surface in the chain,
 715  * not from the first element in the chain. The first surface found is
 716  * returned. The MSDN says that this method fails if more than one surface
 717  * matches the caps, but it is not sure if that is right. The attachment
 718  * structure may not even allow two matching surfaces.
 719  *
 720  * The found surface is AddRef-ed before it is returned.
 721  *
 722  * Params:
 723  *  Caps: Pointer to a DDCAPS2 structure describing the caps asked for
 724  *  Surface: Address to store the found surface
 725  *
 726  * Returns:
 727  *  DD_OK on success
 728  *  DDERR_INVALIDPARAMS if Caps or Surface is NULL
 729  *  DDERR_NOTFOUND if no surface was found
 730  *
 731  *****************************************************************************/
 732 static HRESULT WINAPI ddraw_surface7_GetAttachedSurface(IDirectDrawSurface7 *iface,
 733         DDSCAPS2 *Caps, IDirectDrawSurface7 **Surface)
 734 {
 735     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
 736     struct ddraw_surface *surf;
 737     DDSCAPS2 our_caps;
 738     int i;
 739
 740     TRACE("iface %p, caps %p, attachment %p.\n", iface, Caps, Surface);
 741
 742     wined3d_mutex_lock();
 743
 744     if(This->version < 7)
 745     {
 746         /* Earlier dx apps put garbage into these members, clear them */
 747         our_caps.dwCaps = Caps->dwCaps;
 748         our_caps.dwCaps2 = 0;
 749         our_caps.dwCaps3 = 0;
 750         our_caps.u1.dwCaps4 = 0;
 751     }
 752     else
 753     {
 754         our_caps = *Caps;
 755     }
 756
 757     TRACE("(%p): Looking for caps: %x,%x,%x,%x\n", This, our_caps.dwCaps, our_caps.dwCaps2, our_caps.dwCaps3, our_caps.u1.dwCaps4); /* FIXME: Better debugging */
 758
 759     for(i = 0; i < MAX_COMPLEX_ATTACHED; i++)
 760     {
 761         surf = This->complex_array[i];
 762         if(!surf) break;
 763
 764         TRACE("Surface: (%p) caps: %#x, %#x, %#x, %#x.\n", surf,
 765                 surf->surface_desc.ddsCaps.dwCaps,
 766                 surf->surface_desc.ddsCaps.dwCaps2,
 767                 surf->surface_desc.ddsCaps.dwCaps3,
 768                 surf->surface_desc.ddsCaps.u1.dwCaps4);
 769
 770         if (((surf->surface_desc.ddsCaps.dwCaps & our_caps.dwCaps) == our_caps.dwCaps) &&
 771             ((surf->surface_desc.ddsCaps.dwCaps2 & our_caps.dwCaps2) == our_caps.dwCaps2)) {
 772
 773             /* MSDN: "This method fails if more than one surface is attached
 774              * that matches the capabilities requested."
 775              *
 776              * Not sure how to test this.
 777              */
 778
 779             TRACE("(%p): Returning surface %p\n", This, surf);
 780             TRACE("(%p): mipmapcount=%d\n", This, surf->mipmap_level);
 781             *Surface = &surf->IDirectDrawSurface7_iface;
 782             ddraw_surface7_AddRef(*Surface);
 783             wined3d_mutex_unlock();
 784
 785             return DD_OK;
 786         }
 787     }
 788
 789     /* Next, look at the attachment chain */
 790     surf = This;
 791
 792     while( (surf = surf->next_attached) )
 793     {
 794         TRACE("Surface: (%p) caps: %#x, %#x, %#x, %#x.\n", surf,
 795                 surf->surface_desc.ddsCaps.dwCaps,
 796                 surf->surface_desc.ddsCaps.dwCaps2,
 797                 surf->surface_desc.ddsCaps.dwCaps3,
 798                 surf->surface_desc.ddsCaps.u1.dwCaps4);
 799
 800         if (((surf->surface_desc.ddsCaps.dwCaps & our_caps.dwCaps) == our_caps.dwCaps) &&
 801             ((surf->surface_desc.ddsCaps.dwCaps2 & our_caps.dwCaps2) == our_caps.dwCaps2)) {
 802
 803             TRACE("(%p): Returning surface %p\n", This, surf);
 804             *Surface = &surf->IDirectDrawSurface7_iface;
 805             ddraw_surface7_AddRef(*Surface);
 806             wined3d_mutex_unlock();
 807             return DD_OK;
 808         }
 809     }
 810
 811     TRACE("(%p) Didn't find a valid surface\n", This);
 812
 813     wined3d_mutex_unlock();
 814
 815     *Surface = NULL;
 816     return DDERR_NOTFOUND;
 817 }
 818
 819 static HRESULT WINAPI ddraw_surface4_GetAttachedSurface(IDirectDrawSurface4 *iface,
 820         DDSCAPS2 *caps, IDirectDrawSurface4 **attachment)
 821 {
 822     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
 823     struct ddraw_surface *attachment_impl;
 824     IDirectDrawSurface7 *attachment7;
 825     HRESULT hr;
 826
 827     TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
 828
 829     hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
 830             caps, &attachment7);
 831     if (FAILED(hr))
 832     {
 833         *attachment = NULL;
 834         return hr;
 835     }
 836     attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
 837     *attachment = &attachment_impl->IDirectDrawSurface4_iface;
 838     ddraw_surface4_AddRef(*attachment);
 839     ddraw_surface7_Release(attachment7);
 840
 841     return hr;
 842 }
 843
 844 static HRESULT WINAPI ddraw_surface3_GetAttachedSurface(IDirectDrawSurface3 *iface,
 845         DDSCAPS *caps, IDirectDrawSurface3 **attachment)
 846 {
 847     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
 848     struct ddraw_surface *attachment_impl;
 849     IDirectDrawSurface7 *attachment7;
 850     DDSCAPS2 caps2;
 851     HRESULT hr;
 852
 853     TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
 854
 855     caps2.dwCaps  = caps->dwCaps;
 856     caps2.dwCaps2 = 0;
 857     caps2.dwCaps3 = 0;
 858     caps2.u1.dwCaps4 = 0;
 859
 860     hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
 861             &caps2, &attachment7);
 862     if (FAILED(hr))
 863     {
 864         *attachment = NULL;
 865         return hr;
 866     }
 867     attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
 868     *attachment = &attachment_impl->IDirectDrawSurface3_iface;
 869     ddraw_surface3_AddRef(*attachment);
 870     ddraw_surface7_Release(attachment7);
 871
 872     return hr;
 873 }
 874
 875 static HRESULT WINAPI ddraw_surface2_GetAttachedSurface(IDirectDrawSurface2 *iface,
 876         DDSCAPS *caps, IDirectDrawSurface2 **attachment)
 877 {
 878     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
 879     struct ddraw_surface *attachment_impl;
 880     IDirectDrawSurface7 *attachment7;
 881     DDSCAPS2 caps2;
 882     HRESULT hr;
 883
 884     TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
 885
 886     caps2.dwCaps  = caps->dwCaps;
 887     caps2.dwCaps2 = 0;
 888     caps2.dwCaps3 = 0;
 889     caps2.u1.dwCaps4 = 0;
 890
 891     hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
 892             &caps2, &attachment7);
 893     if (FAILED(hr))
 894     {
 895         *attachment = NULL;
 896         return hr;
 897     }
 898     attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
 899     *attachment = &attachment_impl->IDirectDrawSurface2_iface;
 900     ddraw_surface2_AddRef(*attachment);
 901     ddraw_surface7_Release(attachment7);
 902
 903     return hr;
 904 }
 905
 906 static HRESULT WINAPI ddraw_surface1_GetAttachedSurface(IDirectDrawSurface *iface,
 907         DDSCAPS *caps, IDirectDrawSurface **attachment)
 908 {
 909     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
 910     struct ddraw_surface *attachment_impl;
 911     IDirectDrawSurface7 *attachment7;
 912     DDSCAPS2 caps2;
 913     HRESULT hr;
 914
 915     TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
 916
 917     caps2.dwCaps  = caps->dwCaps;
 918     caps2.dwCaps2 = 0;
 919     caps2.dwCaps3 = 0;
 920     caps2.u1.dwCaps4 = 0;
 921
 922     hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
 923             &caps2, &attachment7);
 924     if (FAILED(hr))
 925     {
 926         *attachment = NULL;
 927         return hr;
 928     }
 929     attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
 930     *attachment = &attachment_impl->IDirectDrawSurface_iface;
 931     ddraw_surface1_AddRef(*attachment);
 932     ddraw_surface7_Release(attachment7);
 933
 934     return hr;
 935 }
 936
 937 /*****************************************************************************
 938  * IDirectDrawSurface7::Lock
 939  *
 940  * Locks the surface and returns a pointer to the surface's memory
 941  *
 942  * Params:
 943  *  Rect: Rectangle to lock. If NULL, the whole surface is locked
 944  *  DDSD: Pointer to a DDSURFACEDESC2 which shall receive the surface's desc.
 945  *  Flags: Locking flags, e.g Read only or write only
 946  *  h: An event handle that's not used and must be NULL
 947  *
 948  * Returns:
 949  *  DD_OK on success
 950  *  DDERR_INVALIDPARAMS if DDSD is NULL
 951  *  For more details, see IWineD3DSurface::LockRect
 952  *
 953  *****************************************************************************/
 954 static HRESULT surface_lock(struct ddraw_surface *This,
 955         RECT *Rect, DDSURFACEDESC2 *DDSD, DWORD Flags, HANDLE h)
 956 {
 957     struct wined3d_map_desc map_desc;
 958     HRESULT hr = DD_OK;
 959
 960     TRACE("This %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
 961             This, wine_dbgstr_rect(Rect), DDSD, Flags, h);
 962
 963     /* This->surface_desc.dwWidth and dwHeight are changeable, thus lock */
 964     wined3d_mutex_lock();
 965
 966     /* Should I check for the handle to be NULL?
 967      *
 968      * The DDLOCK flags and the D3DLOCK flags are equal
 969      * for the supported values. The others are ignored by WineD3D
 970      */
 971
 972     /* Windows zeroes this if the rect is invalid */
 973     DDSD->lpSurface = 0;
 974
 975     if (Rect)
 976     {
 977         if ((Rect->left < 0)
 978                 || (Rect->top < 0)
 979                 || (Rect->left > Rect->right)
 980                 || (Rect->top > Rect->bottom)
 981                 || (Rect->right > This->surface_desc.dwWidth)
 982                 || (Rect->bottom > This->surface_desc.dwHeight))
 983         {
 984             WARN("Trying to lock an invalid rectangle, returning DDERR_INVALIDPARAMS\n");
 985             wined3d_mutex_unlock();
 986             return DDERR_INVALIDPARAMS;
 987         }
 988     }
 989
 990     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
 991         hr = ddraw_surface_update_frontbuffer(This, Rect, TRUE);
 992     if (SUCCEEDED(hr))
 993         hr = wined3d_surface_map(This->wined3d_surface, &map_desc, Rect, Flags);
 994     if (FAILED(hr))
 995     {
 996         wined3d_mutex_unlock();
 997         switch(hr)
 998         {
 999             /* D3D8 and D3D9 return the general D3DERR_INVALIDCALL error, but ddraw has a more
1000              * specific error. But since IWineD3DSurface::LockRect returns that error in this
1001              * only occasion, keep d3d8 and d3d9 free from the return value override. There are
1002              * many different places where d3d8/9 would have to catch the DDERR_SURFACEBUSY, it
1003              * is much easier to do it in one place in ddraw
1004              */
1005             case WINED3DERR_INVALIDCALL:    return DDERR_SURFACEBUSY;
1006             default:                        return hr;
1007         }
1008     }
1009
1010     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1011     {
1012         if (Flags & DDLOCK_READONLY)
1013             memset(&This->ddraw->primary_lock, 0, sizeof(This->ddraw->primary_lock));
1014         else if (Rect)
1015             This->ddraw->primary_lock = *Rect;
1016         else
1017             SetRect(&This->ddraw->primary_lock, 0, 0, This->surface_desc.dwWidth, This->surface_desc.dwHeight);
1018     }
1019
1020     /* Windows does not set DDSD_LPSURFACE on locked surfaces. */
1021     DD_STRUCT_COPY_BYSIZE(DDSD,&(This->surface_desc));
1022     DDSD->lpSurface = map_desc.data;
1023
1024     TRACE("locked surface returning description :\n");
1025     if (TRACE_ON(ddraw)) DDRAW_dump_surface_desc(DDSD);
1026
1027     wined3d_mutex_unlock();
1028
1029     return DD_OK;
1030 }
1031
1032 static HRESULT WINAPI ddraw_surface7_Lock(IDirectDrawSurface7 *iface,
1033         RECT *rect, DDSURFACEDESC2 *surface_desc, DWORD flags, HANDLE h)
1034 {
1035     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
1036
1037     TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1038             iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1039
1040     if (!surface_desc) return DDERR_INVALIDPARAMS;
1041     if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1042             surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1043     {
1044         WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1045         return DDERR_INVALIDPARAMS;
1046     }
1047     return surface_lock(surface, rect, surface_desc, flags, h);
1048 }
1049
1050 static HRESULT WINAPI ddraw_surface4_Lock(IDirectDrawSurface4 *iface, RECT *rect,
1051         DDSURFACEDESC2 *surface_desc, DWORD flags, HANDLE h)
1052 {
1053     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1054
1055     TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1056             iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1057
1058     if (!surface_desc) return DDERR_INVALIDPARAMS;
1059     if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1060             surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1061     {
1062         WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1063         return DDERR_INVALIDPARAMS;
1064     }
1065     return surface_lock(surface, rect, surface_desc, flags, h);
1066 }
1067
1068 static HRESULT WINAPI ddraw_surface3_Lock(IDirectDrawSurface3 *iface, RECT *rect,
1069         DDSURFACEDESC *surface_desc, DWORD flags, HANDLE h)
1070 {
1071     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1072     DDSURFACEDESC2 surface_desc2;
1073     HRESULT hr;
1074
1075     TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1076             iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1077
1078     if (!surface_desc) return DDERR_INVALIDPARAMS;
1079     if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1080             surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1081     {
1082         WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1083         return DDERR_INVALIDPARAMS;
1084     }
1085
1086     surface_desc2.dwSize = surface_desc->dwSize;
1087     surface_desc2.dwFlags = 0;
1088     hr = surface_lock(surface, rect, &surface_desc2, flags, h);
1089     DDSD2_to_DDSD(&surface_desc2, surface_desc);
1090     surface_desc->dwSize = surface_desc2.dwSize;
1091     return hr;
1092 }
1093
1094 static HRESULT WINAPI ddraw_surface2_Lock(IDirectDrawSurface2 *iface, RECT *rect,
1095         DDSURFACEDESC *surface_desc, DWORD flags, HANDLE h)
1096 {
1097     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1098     DDSURFACEDESC2 surface_desc2;
1099     HRESULT hr;
1100
1101     TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1102             iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1103
1104     if (!surface_desc) return DDERR_INVALIDPARAMS;
1105     if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1106             surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1107     {
1108         WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1109         return DDERR_INVALIDPARAMS;
1110     }
1111
1112     surface_desc2.dwSize = surface_desc->dwSize;
1113     surface_desc2.dwFlags = 0;
1114     hr = surface_lock(surface, rect, &surface_desc2, flags, h);
1115     DDSD2_to_DDSD(&surface_desc2, surface_desc);
1116     surface_desc->dwSize = surface_desc2.dwSize;
1117     return hr;
1118 }
1119
1120 static HRESULT WINAPI ddraw_surface1_Lock(IDirectDrawSurface *iface, RECT *rect,
1121         DDSURFACEDESC *surface_desc, DWORD flags, HANDLE h)
1122 {
1123     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1124     DDSURFACEDESC2 surface_desc2;
1125     HRESULT hr;
1126     TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1127             iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1128
1129     if (!surface_desc) return DDERR_INVALIDPARAMS;
1130     if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1131             surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1132     {
1133         WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1134         return DDERR_INVALIDPARAMS;
1135     }
1136
1137     surface_desc2.dwSize = surface_desc->dwSize;
1138     surface_desc2.dwFlags = 0;
1139     hr = surface_lock(surface, rect, &surface_desc2, flags, h);
1140     DDSD2_to_DDSD(&surface_desc2, surface_desc);
1141     surface_desc->dwSize = surface_desc2.dwSize;
1142     return hr;
1143 }
1144
1145 /*****************************************************************************
1146  * IDirectDrawSurface7::Unlock
1147  *
1148  * Unlocks an locked surface
1149  *
1150  * Params:
1151  *  Rect: Not used by this implementation
1152  *
1153  * Returns:
1154  *  D3D_OK on success
1155  *  For more details, see IWineD3DSurface::UnlockRect
1156  *
1157  *****************************************************************************/
1158 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface7_Unlock(IDirectDrawSurface7 *iface, RECT *pRect)
1159 {
1160     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
1161     HRESULT hr;
1162
1163     TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(pRect));
1164
1165     wined3d_mutex_lock();
1166     hr = wined3d_surface_unmap(surface->wined3d_surface);
1167     if (SUCCEEDED(hr) && surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1168         hr = ddraw_surface_update_frontbuffer(surface, &surface->ddraw->primary_lock, FALSE);
1169     wined3d_mutex_unlock();
1170
1171     return hr;
1172 }
1173
1174 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface4_Unlock(IDirectDrawSurface4 *iface, RECT *pRect)
1175 {
1176     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1177
1178     TRACE("iface %p, rect %p.\n", iface, pRect);
1179
1180     return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, pRect);
1181 }
1182
1183 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface3_Unlock(IDirectDrawSurface3 *iface, void *data)
1184 {
1185     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1186
1187     TRACE("iface %p, data %p.\n", iface, data);
1188
1189     /* data might not be the LPRECT of later versions, so drop it. */
1190     return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, NULL);
1191 }
1192
1193 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface2_Unlock(IDirectDrawSurface2 *iface, void *data)
1194 {
1195     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1196
1197     TRACE("iface %p, data %p.\n", iface, data);
1198
1199     /* data might not be the LPRECT of later versions, so drop it. */
1200     return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, NULL);
1201 }
1202
1203 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface1_Unlock(IDirectDrawSurface *iface, void *data)
1204 {
1205     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1206
1207     TRACE("iface %p, data %p.\n", iface, data);
1208
1209     /* data might not be the LPRECT of later versions, so drop it. */
1210     return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, NULL);
1211 }
1212
1213 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface7_Flip(IDirectDrawSurface7 *iface,
1214         IDirectDrawSurface7 *src, DWORD flags)
1215 {
1216     struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface7(iface);
1217     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface7(src);
1218     struct wined3d_rendertarget_view *tmp_rtv, *src_rtv, *rtv;
1219     struct ddraw_texture *ddraw_texture, *prev_ddraw_texture;
1220     DDSCAPS2 caps = {DDSCAPS_FLIP, 0, 0, {0}};
1221     struct wined3d_texture *texture;
1222     IDirectDrawSurface7 *current;
1223     struct wined3d_surface *tmp;
1224     HRESULT hr;
1225
1226     TRACE("iface %p, src %p, flags %#x.\n", iface, src, flags);
1227
1228     if (src == iface || !(dst_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_OVERLAY)))
1229         return DDERR_NOTFLIPPABLE;
1230
1231     if (IDirectDrawSurface7_IsLost(iface) == DDERR_SURFACELOST)
1232         return DDERR_SURFACELOST;
1233
1234     wined3d_mutex_lock();
1235
1236     tmp_rtv = ddraw_surface_get_rendertarget_view(dst_impl);
1237     tmp = dst_impl->wined3d_surface;
1238     texture = dst_impl->wined3d_texture;
1239     rtv = wined3d_device_get_rendertarget_view(dst_impl->ddraw->wined3d_device, 0);
1240     ddraw_texture = wined3d_texture_get_parent(dst_impl->wined3d_texture);
1241
1242     if (src_impl)
1243     {
1244         for (current = iface; current != src;)
1245         {
1246             if (FAILED(hr = ddraw_surface7_GetAttachedSurface(current, &caps, &current)))
1247             {
1248                 WARN("Surface %p is not on the same flip chain as surface %p.\n", src, iface);
1249                 wined3d_mutex_unlock();
1250                 return DDERR_NOTFLIPPABLE;
1251             }
1252             ddraw_surface7_Release(current);
1253             if (current == iface)
1254             {
1255                 WARN("Surface %p is not on the same flip chain as surface %p.\n", src, iface);
1256                 wined3d_mutex_unlock();
1257                 return DDERR_NOTFLIPPABLE;
1258             }
1259         }
1260
1261         src_rtv = ddraw_surface_get_rendertarget_view(src_impl);
1262         if (rtv == dst_impl->wined3d_rtv)
1263             wined3d_device_set_rendertarget_view(dst_impl->ddraw->wined3d_device, 0, src_rtv, FALSE);
1264         wined3d_rendertarget_view_set_parent(src_rtv, dst_impl);
1265         dst_impl->wined3d_rtv = src_rtv;
1266         wined3d_resource_set_parent(wined3d_surface_get_resource(src_impl->wined3d_surface), dst_impl);
1267         dst_impl->wined3d_surface = src_impl->wined3d_surface;
1268         prev_ddraw_texture = wined3d_texture_get_parent(src_impl->wined3d_texture);
1269         wined3d_resource_set_parent(wined3d_texture_get_resource(src_impl->wined3d_texture), ddraw_texture);
1270         dst_impl->wined3d_texture = src_impl->wined3d_texture;
1271         ddraw_texture = prev_ddraw_texture;
1272     }
1273     else
1274     {
1275         for (current = iface;;)
1276         {
1277             if (FAILED(hr = ddraw_surface7_GetAttachedSurface(current, &caps, &current)))
1278             {
1279                 ERR("Can't find a flip target\n");
1280                 wined3d_mutex_unlock();
1281                 return DDERR_NOTFLIPPABLE; /* Unchecked */
1282             }
1283             ddraw_surface7_Release(current);
1284             if (current == iface)
1285             {
1286                 dst_impl = impl_from_IDirectDrawSurface7(iface);
1287                 break;
1288             }
1289
1290             src_impl = impl_from_IDirectDrawSurface7(current);
1291             src_rtv = ddraw_surface_get_rendertarget_view(src_impl);
1292             if (rtv == dst_impl->wined3d_rtv)
1293                 wined3d_device_set_rendertarget_view(dst_impl->ddraw->wined3d_device, 0, src_rtv, FALSE);
1294             wined3d_rendertarget_view_set_parent(src_rtv, dst_impl);
1295             dst_impl->wined3d_rtv = src_rtv;
1296             wined3d_resource_set_parent(wined3d_surface_get_resource(src_impl->wined3d_surface), dst_impl);
1297             dst_impl->wined3d_surface = src_impl->wined3d_surface;
1298             prev_ddraw_texture = wined3d_texture_get_parent(src_impl->wined3d_texture);
1299             wined3d_resource_set_parent(wined3d_texture_get_resource(src_impl->wined3d_texture), ddraw_texture);
1300             ddraw_texture = prev_ddraw_texture;
1301             dst_impl->wined3d_texture = src_impl->wined3d_texture;
1302             dst_impl = src_impl;
1303         }
1304     }
1305
1306     /* We don't have to worry about potential texture bindings, since
1307      * flippable surfaces can never be textures. */
1308     if (rtv == src_impl->wined3d_rtv)
1309         wined3d_device_set_rendertarget_view(dst_impl->ddraw->wined3d_device, 0, tmp_rtv, FALSE);
1310     wined3d_rendertarget_view_set_parent(tmp_rtv, src_impl);
1311     src_impl->wined3d_rtv = tmp_rtv;
1312     wined3d_resource_set_parent(wined3d_surface_get_resource(tmp), src_impl);
1313     src_impl->wined3d_surface = tmp;
1314     wined3d_resource_set_parent(wined3d_texture_get_resource(texture), ddraw_texture);
1315     src_impl->wined3d_texture = texture;
1316
1317     if (flags)
1318     {
1319         static UINT once;
1320         if (!once++)
1321             FIXME("Ignoring flags %#x.\n", flags);
1322         else
1323             WARN("Ignoring flags %#x.\n", flags);
1324     }
1325
1326     if (dst_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1327         hr = ddraw_surface_update_frontbuffer(dst_impl, NULL, FALSE);
1328     else
1329         hr = DD_OK;
1330
1331     wined3d_mutex_unlock();
1332
1333     return hr;
1334 }
1335
1336 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface4_Flip(IDirectDrawSurface4 *iface,
1337         IDirectDrawSurface4 *dst, DWORD flags)
1338 {
1339     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1340     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface4(dst);
1341
1342     TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1343
1344     return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1345             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1346 }
1347
1348 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface3_Flip(IDirectDrawSurface3 *iface,
1349         IDirectDrawSurface3 *dst, DWORD flags)
1350 {
1351     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1352     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface3(dst);
1353
1354     TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1355
1356     return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1357             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1358 }
1359
1360 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface2_Flip(IDirectDrawSurface2 *iface,
1361         IDirectDrawSurface2 *dst, DWORD flags)
1362 {
1363     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1364     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface2(dst);
1365
1366     TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1367
1368     return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1369             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1370 }
1371
1372 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface1_Flip(IDirectDrawSurface *iface,
1373         IDirectDrawSurface *dst, DWORD flags)
1374 {
1375     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1376     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface(dst);
1377
1378     TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1379
1380     return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1381             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1382 }
1383
1384 static HRESULT ddraw_surface_blt_clipped(struct ddraw_surface *dst_surface, const RECT *dst_rect_in,
1385         struct ddraw_surface *src_surface, const RECT *src_rect_in, DWORD flags,
1386         const WINEDDBLTFX *fx, enum wined3d_texture_filter_type filter)
1387 {
1388     struct wined3d_surface *wined3d_src_surface = src_surface ? src_surface->wined3d_surface : NULL;
1389     RECT src_rect, dst_rect;
1390     float scale_x, scale_y;
1391     const RECT *clip_rect;
1392     UINT clip_list_size;
1393     RGNDATA *clip_list;
1394     HRESULT hr = DD_OK;
1395     UINT i;
1396
1397     if (!dst_surface->clipper)
1398     {
1399         if (src_surface && src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1400             hr = ddraw_surface_update_frontbuffer(src_surface, src_rect_in, TRUE);
1401         if (SUCCEEDED(hr))
1402             hr = wined3d_surface_blt(dst_surface->wined3d_surface, dst_rect_in,
1403                     wined3d_src_surface, src_rect_in, flags, fx, filter);
1404         if (SUCCEEDED(hr) && (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
1405             hr = ddraw_surface_update_frontbuffer(dst_surface, dst_rect_in, FALSE);
1406
1407         return hr;
1408     }
1409
1410     if (!dst_rect_in)
1411     {
1412         dst_rect.left = 0;
1413         dst_rect.top = 0;
1414         dst_rect.right = dst_surface->surface_desc.dwWidth;
1415         dst_rect.bottom = dst_surface->surface_desc.dwHeight;
1416     }
1417     else
1418     {
1419         dst_rect = *dst_rect_in;
1420     }
1421
1422     if (IsRectEmpty(&dst_rect))
1423         return DDERR_INVALIDRECT;
1424
1425     if (src_surface)
1426     {
1427         if (!src_rect_in)
1428         {
1429             src_rect.left = 0;
1430             src_rect.top = 0;
1431             src_rect.right = src_surface->surface_desc.dwWidth;
1432             src_rect.bottom = src_surface->surface_desc.dwHeight;
1433         }
1434         else
1435         {
1436             src_rect = *src_rect_in;
1437         }
1438
1439         if (IsRectEmpty(&src_rect))
1440             return DDERR_INVALIDRECT;
1441     }
1442     else
1443     {
1444         SetRect(&src_rect, 0, 0, 0, 0);
1445     }
1446
1447     scale_x = (float)(src_rect.right - src_rect.left) / (float)(dst_rect.right - dst_rect.left);
1448     scale_y = (float)(src_rect.bottom - src_rect.top) / (float)(dst_rect.bottom - dst_rect.top);
1449
1450     if (FAILED(hr = IDirectDrawClipper_GetClipList(&dst_surface->clipper->IDirectDrawClipper_iface,
1451             &dst_rect, NULL, &clip_list_size)))
1452     {
1453         WARN("Failed to get clip list size, hr %#x.\n", hr);
1454         return hr;
1455     }
1456
1457     if (!(clip_list = HeapAlloc(GetProcessHeap(), 0, clip_list_size)))
1458     {
1459         WARN("Failed to allocate clip list.\n");
1460         return E_OUTOFMEMORY;
1461     }
1462
1463     if (FAILED(hr = IDirectDrawClipper_GetClipList(&dst_surface->clipper->IDirectDrawClipper_iface,
1464             &dst_rect, clip_list, &clip_list_size)))
1465     {
1466         WARN("Failed to get clip list, hr %#x.\n", hr);
1467         HeapFree(GetProcessHeap(), 0, clip_list);
1468         return hr;
1469     }
1470
1471     clip_rect = (RECT *)clip_list->Buffer;
1472     for (i = 0; i < clip_list->rdh.nCount; ++i)
1473     {
1474         RECT src_rect_clipped = src_rect;
1475
1476         if (src_surface)
1477         {
1478             src_rect_clipped.left += (LONG)((clip_rect[i].left - dst_rect.left) * scale_x);
1479             src_rect_clipped.top += (LONG)((clip_rect[i].top - dst_rect.top) * scale_y);
1480             src_rect_clipped.right -= (LONG)((dst_rect.right - clip_rect[i].right) * scale_x);
1481             src_rect_clipped.bottom -= (LONG)((dst_rect.bottom - clip_rect[i].bottom) * scale_y);
1482
1483             if (src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1484             {
1485                 if (FAILED(hr = ddraw_surface_update_frontbuffer(src_surface, &src_rect_clipped, TRUE)))
1486                     break;
1487             }
1488         }
1489
1490         if (FAILED(hr = wined3d_surface_blt(dst_surface->wined3d_surface, &clip_rect[i],
1491                 wined3d_src_surface, &src_rect_clipped, flags, fx, filter)))
1492             break;
1493
1494         if (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1495         {
1496             if (FAILED(hr = ddraw_surface_update_frontbuffer(dst_surface, &clip_rect[i], FALSE)))
1497                 break;
1498         }
1499     }
1500
1501     HeapFree(GetProcessHeap(), 0, clip_list);
1502     return hr;
1503 }
1504
1505 /*****************************************************************************
1506  * IDirectDrawSurface7::Blt
1507  *
1508  * Performs a blit on the surface
1509  *
1510  * Params:
1511  *  DestRect: Destination rectangle, can be NULL
1512  *  SrcSurface: Source surface, can be NULL
1513  *  SrcRect: Source rectangle, can be NULL
1514  *  Flags: Blt flags
1515  *  DDBltFx: Some extended blt parameters, connected to the flags
1516  *
1517  * Returns:
1518  *  D3D_OK on success
1519  *  See IWineD3DSurface::Blt for more details
1520  *
1521  *****************************************************************************/
1522 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface7_Blt(IDirectDrawSurface7 *iface, RECT *DestRect,
1523         IDirectDrawSurface7 *SrcSurface, RECT *SrcRect, DWORD Flags, DDBLTFX *DDBltFx)
1524 {
1525     struct ddraw_surface *dst_surface = impl_from_IDirectDrawSurface7(iface);
1526     struct ddraw_surface *src_surface = unsafe_impl_from_IDirectDrawSurface7(SrcSurface);
1527     HRESULT hr = DD_OK;
1528     DDBLTFX rop_fx;
1529
1530     TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1531             iface, wine_dbgstr_rect(DestRect), SrcSurface, wine_dbgstr_rect(SrcRect), Flags, DDBltFx);
1532
1533     /* Check for validity of the flags here. WineD3D Has the software-opengl selection path and would have
1534      * to check at 2 places, and sometimes do double checks. This also saves the call to wined3d :-)
1535      */
1536     if((Flags & DDBLT_KEYSRCOVERRIDE) && (!DDBltFx || Flags & DDBLT_KEYSRC)) {
1537         WARN("Invalid source color key parameters, returning DDERR_INVALIDPARAMS\n");
1538         return DDERR_INVALIDPARAMS;
1539     }
1540
1541     if((Flags & DDBLT_KEYDESTOVERRIDE) && (!DDBltFx || Flags & DDBLT_KEYDEST)) {
1542         WARN("Invalid destination color key parameters, returning DDERR_INVALIDPARAMS\n");
1543         return DDERR_INVALIDPARAMS;
1544     }
1545
1546     wined3d_mutex_lock();
1547
1548     if (Flags & (DDBLT_COLORFILL | DDBLT_DEPTHFILL))
1549     {
1550         if (Flags & DDBLT_ROP)
1551         {
1552             wined3d_mutex_unlock();
1553             WARN("DDBLT_ROP used with DDBLT_COLORFILL or DDBLT_DEPTHFILL, returning DDERR_INVALIDPARAMS.\n");
1554             return DDERR_INVALIDPARAMS;
1555         }
1556         if (src_surface)
1557         {
1558             wined3d_mutex_unlock();
1559             WARN("Depth or colorfill is not compatible with source surfaces, returning DDERR_INVALIDPARAMS\n");
1560             return DDERR_INVALIDPARAMS;
1561         }
1562         if (!DDBltFx)
1563         {
1564             wined3d_mutex_unlock();
1565             WARN("Depth or colorfill used with DDBltFx = NULL, returning DDERR_INVALIDPARAMS.\n");
1566             return DDERR_INVALIDPARAMS;
1567         }
1568
1569         if ((Flags & (DDBLT_COLORFILL | DDBLT_DEPTHFILL)) == (DDBLT_COLORFILL | DDBLT_DEPTHFILL))
1570             Flags &= ~DDBLT_DEPTHFILL;
1571
1572         if ((dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER) && (Flags & DDBLT_COLORFILL))
1573         {
1574             wined3d_mutex_unlock();
1575             WARN("DDBLT_COLORFILL used on a depth buffer, returning DDERR_INVALIDPARAMS.\n");
1576             return DDERR_INVALIDPARAMS;
1577         }
1578         if (!(dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER) && (Flags & DDBLT_DEPTHFILL))
1579         {
1580             wined3d_mutex_unlock();
1581             WARN("DDBLT_DEPTHFILL used on a color buffer, returning DDERR_INVALIDPARAMS.\n");
1582             return DDERR_INVALIDPARAMS;
1583         }
1584     }
1585
1586     if (Flags & DDBLT_ROP)
1587     {
1588         if (!DDBltFx)
1589         {
1590             wined3d_mutex_unlock();
1591             WARN("DDBLT_ROP used with DDBltFx = NULL, returning DDERR_INVALIDPARAMS.\n");
1592             return DDERR_INVALIDPARAMS;
1593         }
1594
1595         Flags &= ~DDBLT_ROP;
1596         switch (DDBltFx->dwROP)
1597         {
1598             case SRCCOPY:
1599                 break;
1600
1601             case WHITENESS:
1602             case BLACKNESS:
1603                 rop_fx = *DDBltFx;
1604
1605                 if (DDBltFx->dwROP == WHITENESS)
1606                     rop_fx.u5.dwFillColor = 0xffffffff;
1607                 else
1608                     rop_fx.u5.dwFillColor = 0;
1609
1610                 if (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
1611                     Flags |= DDBLT_DEPTHFILL;
1612                 else
1613                     Flags |= DDBLT_COLORFILL;
1614
1615                 DDBltFx = &rop_fx;
1616                 break;
1617
1618             default:
1619                 wined3d_mutex_unlock();
1620                 WARN("Unsupported ROP %#x used, returning DDERR_NORASTEROPHW.\n", DDBltFx->dwROP);
1621                 return DDERR_NORASTEROPHW;
1622         }
1623     }
1624
1625     if (Flags & DDBLT_KEYSRC && (!src_surface || !(src_surface->surface_desc.dwFlags & DDSD_CKSRCBLT)))
1626     {
1627         WARN("DDBLT_KEYDEST blit without color key in surface, returning DDERR_INVALIDPARAMS\n");
1628         wined3d_mutex_unlock();
1629         return DDERR_INVALIDPARAMS;
1630     }
1631
1632     /* TODO: Check if the DDBltFx contains any ddraw surface pointers. If it
1633      * does, copy the struct, and replace the ddraw surfaces with the wined3d
1634      * surfaces. So far no blitting operations using surfaces in the bltfx
1635      * struct are supported anyway. */
1636     hr = ddraw_surface_blt_clipped(dst_surface, DestRect, src_surface, SrcRect,
1637             Flags, (WINEDDBLTFX *)DDBltFx, WINED3D_TEXF_LINEAR);
1638
1639     wined3d_mutex_unlock();
1640     switch(hr)
1641     {
1642         case WINED3DERR_NOTAVAILABLE:       return DDERR_UNSUPPORTED;
1643         case WINED3DERR_WRONGTEXTUREFORMAT: return DDERR_INVALIDPIXELFORMAT;
1644         default:                            return hr;
1645     }
1646 }
1647
1648 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface4_Blt(IDirectDrawSurface4 *iface, RECT *dst_rect,
1649         IDirectDrawSurface4 *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1650 {
1651     struct ddraw_surface *dst = impl_from_IDirectDrawSurface4(iface);
1652     struct ddraw_surface *src = unsafe_impl_from_IDirectDrawSurface4(src_surface);
1653
1654     TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1655             iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1656
1657     return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1658             src ? &src->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1659 }
1660
1661 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface3_Blt(IDirectDrawSurface3 *iface, RECT *dst_rect,
1662         IDirectDrawSurface3 *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1663 {
1664     struct ddraw_surface *dst = impl_from_IDirectDrawSurface3(iface);
1665     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface3(src_surface);
1666
1667     TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1668             iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1669
1670     return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1671             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1672 }
1673
1674 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface2_Blt(IDirectDrawSurface2 *iface, RECT *dst_rect,
1675         IDirectDrawSurface2 *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1676 {
1677     struct ddraw_surface *dst = impl_from_IDirectDrawSurface2(iface);
1678     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface2(src_surface);
1679
1680     TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1681             iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1682
1683     return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1684             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1685 }
1686
1687 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface1_Blt(IDirectDrawSurface *iface, RECT *dst_rect,
1688         IDirectDrawSurface *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1689 {
1690     struct ddraw_surface *dst = impl_from_IDirectDrawSurface(iface);
1691     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src_surface);
1692
1693     TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1694             iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1695
1696     return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1697             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1698 }
1699
1700 /*****************************************************************************
1701  * IDirectDrawSurface7::AddAttachedSurface
1702  *
1703  * Attaches a surface to another surface. How the surface attachments work
1704  * is not totally understood yet, and this method is prone to problems.
1705  * The surface that is attached is AddRef-ed.
1706  *
1707  * Tests with complex surfaces suggest that the surface attachments form a
1708  * tree, but no method to test this has been found yet.
1709  *
1710  * The attachment list consists of a first surface (first_attached) and
1711  * for each surface a pointer to the next attached surface (next_attached).
1712  * For the first surface, and a surface that has no attachments
1713  * first_attached points to the surface itself. A surface that has
1714  * no successors in the chain has next_attached set to NULL.
1715  *
1716  * Newly attached surfaces are attached right after the root surface.
1717  * If a surface is attached to a complex surface compound, it's attached to
1718  * the surface that the app requested, not the complex root. See
1719  * GetAttachedSurface for a description how surfaces are found.
1720  *
1721  * This is how the current implementation works, and it was coded by looking
1722  * at the needs of the applications.
1723  *
1724  * So far only Z-Buffer attachments are tested, and they are activated in
1725  * WineD3D. Mipmaps could be tricky to activate in WineD3D.
1726  * Back buffers should work in 2D mode, but they are not tested(They can be
1727  * attached in older iface versions). Rendering to the front buffer and
1728  * switching between that and double buffering is not yet implemented in
1729  * WineD3D, so for 3D it might have unexpected results.
1730  *
1731  * ddraw_surface_attach_surface is the real thing,
1732  * ddraw_surface7_AddAttachedSurface is a wrapper around it that
1733  * performs additional checks. Version 7 of this interface is much more restrictive
1734  * than its predecessors.
1735  *
1736  * Params:
1737  *  Attach: Surface to attach to iface
1738  *
1739  * Returns:
1740  *  DD_OK on success
1741  *  DDERR_CANNOTATTACHSURFACE if the surface can't be attached for some reason
1742  *
1743  *****************************************************************************/
1744 static HRESULT ddraw_surface_attach_surface(struct ddraw_surface *This, struct ddraw_surface *Surf)
1745 {
1746     TRACE("surface %p, attachment %p.\n", This, Surf);
1747
1748     if(Surf == This)
1749         return DDERR_CANNOTATTACHSURFACE; /* unchecked */
1750
1751     wined3d_mutex_lock();
1752
1753     /* Check if the surface is already attached somewhere */
1754     if (Surf->next_attached || Surf->first_attached != Surf)
1755     {
1756         /* TODO: Test for the structure of the manual attachment. Is it a
1757          * chain or a list? What happens if one surface is attached to 2
1758          * different surfaces? */
1759         WARN("Surface %p is already attached somewhere. next_attached %p, first_attached %p.\n",
1760                 Surf, Surf->next_attached, Surf->first_attached);
1761
1762         wined3d_mutex_unlock();
1763         return DDERR_SURFACEALREADYATTACHED;
1764     }
1765
1766     /* This inserts the new surface at the 2nd position in the chain, right after the root surface */
1767     Surf->next_attached = This->next_attached;
1768     Surf->first_attached = This->first_attached;
1769     This->next_attached = Surf;
1770
1771     /* Check if the WineD3D depth stencil needs updating */
1772     if (This->ddraw->d3ddevice)
1773         d3d_device_update_depth_stencil(This->ddraw->d3ddevice);
1774
1775     wined3d_mutex_unlock();
1776
1777     return DD_OK;
1778 }
1779
1780 static HRESULT WINAPI ddraw_surface7_AddAttachedSurface(IDirectDrawSurface7 *iface, IDirectDrawSurface7 *attachment)
1781 {
1782     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
1783     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface7(attachment);
1784     HRESULT hr;
1785
1786     TRACE("iface %p, attachment %p.\n", iface, attachment);
1787
1788     /* Version 7 of this interface seems to refuse everything except z buffers, as per msdn */
1789     if(!(attachment_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
1790     {
1791
1792         WARN("Application tries to attach a non Z buffer surface. caps %08x\n",
1793               attachment_impl->surface_desc.ddsCaps.dwCaps);
1794         return DDERR_CANNOTATTACHSURFACE;
1795     }
1796
1797     hr = ddraw_surface_attach_surface(This, attachment_impl);
1798     if (FAILED(hr))
1799     {
1800         return hr;
1801     }
1802     attachment_impl->attached_iface = (IUnknown *)attachment;
1803     IUnknown_AddRef(attachment_impl->attached_iface);
1804     return hr;
1805 }
1806
1807 static HRESULT WINAPI ddraw_surface4_AddAttachedSurface(IDirectDrawSurface4 *iface, IDirectDrawSurface4 *attachment)
1808 {
1809     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1810     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface4(attachment);
1811     HRESULT hr;
1812
1813     TRACE("iface %p, attachment %p.\n", iface, attachment);
1814
1815     /* Tests suggest that
1816      * -> offscreen plain surfaces can be attached to other offscreen plain surfaces
1817      * -> offscreen plain surfaces can be attached to primaries
1818      * -> primaries can be attached to offscreen plain surfaces
1819      * -> z buffers can be attached to primaries */
1820     if (surface->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_OFFSCREENPLAIN)
1821             && attachment_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_OFFSCREENPLAIN))
1822     {
1823         /* Sizes have to match */
1824         if (attachment_impl->surface_desc.dwWidth != surface->surface_desc.dwWidth
1825                 || attachment_impl->surface_desc.dwHeight != surface->surface_desc.dwHeight)
1826         {
1827             WARN("Surface sizes do not match.\n");
1828             return DDERR_CANNOTATTACHSURFACE;
1829         }
1830     }
1831     else if (!(surface->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE))
1832             || !(attachment_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_ZBUFFER)))
1833     {
1834         WARN("Invalid attachment combination.\n");
1835         return DDERR_CANNOTATTACHSURFACE;
1836     }
1837
1838     if (FAILED(hr = ddraw_surface_attach_surface(surface, attachment_impl)))
1839         return hr;
1840
1841     attachment_impl->attached_iface = (IUnknown *)attachment;
1842     IUnknown_AddRef(attachment_impl->attached_iface);
1843     return hr;
1844 }
1845
1846 static HRESULT WINAPI ddraw_surface3_AddAttachedSurface(IDirectDrawSurface3 *iface, IDirectDrawSurface3 *attachment)
1847 {
1848     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1849     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface3(attachment);
1850     HRESULT hr;
1851
1852     TRACE("iface %p, attachment %p.\n", iface, attachment);
1853
1854     if (FAILED(hr = ddraw_surface4_AddAttachedSurface(&surface->IDirectDrawSurface4_iface,
1855             attachment_impl ? &attachment_impl->IDirectDrawSurface4_iface : NULL)))
1856         return hr;
1857
1858     attachment_impl->attached_iface = (IUnknown *)attachment;
1859     IUnknown_AddRef(attachment_impl->attached_iface);
1860     ddraw_surface4_Release(&attachment_impl->IDirectDrawSurface4_iface);
1861     return hr;
1862 }
1863
1864 static HRESULT WINAPI ddraw_surface2_AddAttachedSurface(IDirectDrawSurface2 *iface, IDirectDrawSurface2 *attachment)
1865 {
1866     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1867     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface2(attachment);
1868     HRESULT hr;
1869
1870     TRACE("iface %p, attachment %p.\n", iface, attachment);
1871
1872     if (FAILED(hr = ddraw_surface4_AddAttachedSurface(&surface->IDirectDrawSurface4_iface,
1873             attachment_impl ? &attachment_impl->IDirectDrawSurface4_iface : NULL)))
1874         return hr;
1875
1876     attachment_impl->attached_iface = (IUnknown *)attachment;
1877     IUnknown_AddRef(attachment_impl->attached_iface);
1878     ddraw_surface4_Release(&attachment_impl->IDirectDrawSurface4_iface);
1879     return hr;
1880 }
1881
1882 static HRESULT WINAPI ddraw_surface1_AddAttachedSurface(IDirectDrawSurface *iface, IDirectDrawSurface *attachment)
1883 {
1884     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1885     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface(attachment);
1886     HRESULT hr;
1887
1888     TRACE("iface %p, attachment %p.\n", iface, attachment);
1889
1890     if (FAILED(hr = ddraw_surface4_AddAttachedSurface(&surface->IDirectDrawSurface4_iface,
1891             attachment_impl ? &attachment_impl->IDirectDrawSurface4_iface : NULL)))
1892         return hr;
1893
1894     attachment_impl->attached_iface = (IUnknown *)attachment;
1895     IUnknown_AddRef(attachment_impl->attached_iface);
1896     ddraw_surface4_Release(&attachment_impl->IDirectDrawSurface4_iface);
1897     return hr;
1898 }
1899
1900 /*****************************************************************************
1901  * IDirectDrawSurface7::DeleteAttachedSurface
1902  *
1903  * Removes a surface from the attachment chain. The surface's refcount
1904  * is decreased by one after it has been removed
1905  *
1906  * Params:
1907  *  Flags: Some flags, not used by this implementation
1908  *  Attach: Surface to detach
1909  *
1910  * Returns:
1911  *  DD_OK on success
1912  *  DDERR_SURFACENOTATTACHED if the surface isn't attached to
1913  *
1914  *****************************************************************************/
1915 static HRESULT ddraw_surface_delete_attached_surface(struct ddraw_surface *surface,
1916         struct ddraw_surface *attachment, IUnknown *detach_iface)
1917 {
1918     struct ddraw_surface *prev = surface;
1919
1920     TRACE("surface %p, attachment %p, detach_iface %p.\n", surface, attachment, detach_iface);
1921
1922     wined3d_mutex_lock();
1923     if (!attachment || (attachment->first_attached != surface) || (attachment == surface) )
1924     {
1925         wined3d_mutex_unlock();
1926         return DDERR_CANNOTDETACHSURFACE;
1927     }
1928
1929     if (attachment->attached_iface != detach_iface)
1930     {
1931         WARN("attachment->attach_iface %p != detach_iface %p.\n", attachment->attached_iface, detach_iface);
1932         wined3d_mutex_unlock();
1933         return DDERR_SURFACENOTATTACHED;
1934     }
1935
1936     /* Remove MIPMAPSUBLEVEL if this seemed to be one */
1937     if (surface->surface_desc.ddsCaps.dwCaps & attachment->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
1938     {
1939         attachment->surface_desc.ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
1940         /* FIXME: we should probably also subtract from dwMipMapCount of this
1941          * and all parent surfaces */
1942     }
1943
1944     /* Find the predecessor of the detached surface */
1945     while (prev)
1946     {
1947         if (prev->next_attached == attachment)
1948             break;
1949         prev = prev->next_attached;
1950     }
1951
1952     /* There must be a surface, otherwise there's a bug */
1953     assert(prev);
1954
1955     /* Unchain the surface */
1956     prev->next_attached = attachment->next_attached;
1957     attachment->next_attached = NULL;
1958     attachment->first_attached = attachment;
1959
1960     /* Check if the wined3d depth stencil needs updating. */
1961     if (surface->ddraw->d3ddevice)
1962         d3d_device_update_depth_stencil(surface->ddraw->d3ddevice);
1963     wined3d_mutex_unlock();
1964
1965     /* Set attached_iface to NULL before releasing it, the surface may go
1966      * away. */
1967     attachment->attached_iface = NULL;
1968     IUnknown_Release(detach_iface);
1969
1970     return DD_OK;
1971 }
1972
1973 static HRESULT WINAPI ddraw_surface7_DeleteAttachedSurface(IDirectDrawSurface7 *iface,
1974         DWORD flags, IDirectDrawSurface7 *attachment)
1975 {
1976     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
1977     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface7(attachment);
1978
1979     TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
1980
1981     return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
1982 }
1983
1984 static HRESULT WINAPI ddraw_surface4_DeleteAttachedSurface(IDirectDrawSurface4 *iface,
1985         DWORD flags, IDirectDrawSurface4 *attachment)
1986 {
1987     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1988     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface4(attachment);
1989
1990     TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
1991
1992     return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
1993 }
1994
1995 static HRESULT WINAPI ddraw_surface3_DeleteAttachedSurface(IDirectDrawSurface3 *iface,
1996         DWORD flags, IDirectDrawSurface3 *attachment)
1997 {
1998     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1999     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface3(attachment);
2000
2001     TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
2002
2003     return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
2004 }
2005
2006 static HRESULT WINAPI ddraw_surface2_DeleteAttachedSurface(IDirectDrawSurface2 *iface,
2007         DWORD flags, IDirectDrawSurface2 *attachment)
2008 {
2009     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2010     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface2(attachment);
2011
2012     TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
2013
2014     return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
2015 }
2016
2017 static HRESULT WINAPI ddraw_surface1_DeleteAttachedSurface(IDirectDrawSurface *iface,
2018         DWORD flags, IDirectDrawSurface *attachment)
2019 {
2020     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2021     struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface(attachment);
2022
2023     TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
2024
2025     return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
2026 }
2027
2028 /*****************************************************************************
2029  * IDirectDrawSurface7::AddOverlayDirtyRect
2030  *
2031  * "This method is not currently implemented"
2032  *
2033  * Params:
2034  *  Rect: ?
2035  *
2036  * Returns:
2037  *  DDERR_UNSUPPORTED
2038  *
2039  *****************************************************************************/
2040 static HRESULT WINAPI ddraw_surface7_AddOverlayDirtyRect(IDirectDrawSurface7 *iface, RECT *Rect)
2041 {
2042     TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(Rect));
2043
2044     return DDERR_UNSUPPORTED; /* unchecked */
2045 }
2046
2047 static HRESULT WINAPI ddraw_surface4_AddOverlayDirtyRect(IDirectDrawSurface4 *iface, RECT *rect)
2048 {
2049     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2050
2051     TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
2052
2053     return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
2054 }
2055
2056 static HRESULT WINAPI ddraw_surface3_AddOverlayDirtyRect(IDirectDrawSurface3 *iface, RECT *rect)
2057 {
2058     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2059
2060     TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
2061
2062     return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
2063 }
2064
2065 static HRESULT WINAPI ddraw_surface2_AddOverlayDirtyRect(IDirectDrawSurface2 *iface, RECT *rect)
2066 {
2067     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2068
2069     TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
2070
2071     return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
2072 }
2073
2074 static HRESULT WINAPI ddraw_surface1_AddOverlayDirtyRect(IDirectDrawSurface *iface, RECT *rect)
2075 {
2076     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2077
2078     TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
2079
2080     return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
2081 }
2082
2083 /*****************************************************************************
2084  * IDirectDrawSurface7::GetDC
2085  *
2086  * Returns a GDI device context for the surface
2087  *
2088  * Params:
2089  *  hdc: Address of a HDC variable to store the dc to
2090  *
2091  * Returns:
2092  *  DD_OK on success
2093  *  DDERR_INVALIDPARAMS if hdc is NULL
2094  *  For details, see IWineD3DSurface::GetDC
2095  *
2096  *****************************************************************************/
2097 static HRESULT WINAPI ddraw_surface7_GetDC(IDirectDrawSurface7 *iface, HDC *hdc)
2098 {
2099     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2100     HRESULT hr = DD_OK;
2101
2102     TRACE("iface %p, dc %p.\n", iface, hdc);
2103
2104     if(!hdc)
2105         return DDERR_INVALIDPARAMS;
2106
2107     wined3d_mutex_lock();
2108     if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
2109         hr = ddraw_surface_update_frontbuffer(surface, NULL, TRUE);
2110     if (SUCCEEDED(hr))
2111         hr = wined3d_surface_getdc(surface->wined3d_surface, hdc);
2112
2113     if (SUCCEEDED(hr) && format_is_paletteindexed(&surface->surface_desc.u4.ddpfPixelFormat))
2114     {
2115         const struct ddraw_palette *palette;
2116
2117         if (surface->palette)
2118             palette = surface->palette;
2119         else if (surface->ddraw->primary)
2120             palette = surface->ddraw->primary->palette;
2121         else
2122             palette = NULL;
2123
2124         if (palette)
2125             wined3d_palette_apply_to_dc(palette->wineD3DPalette, *hdc);
2126     }
2127
2128     wined3d_mutex_unlock();
2129     switch(hr)
2130     {
2131         /* Some, but not all errors set *hdc to NULL. E.g. DCALREADYCREATED does not
2132          * touch *hdc
2133          */
2134         case WINED3DERR_INVALIDCALL:
2135             if(hdc) *hdc = NULL;
2136             return DDERR_INVALIDPARAMS;
2137
2138         default: return hr;
2139     }
2140 }
2141
2142 static HRESULT WINAPI ddraw_surface4_GetDC(IDirectDrawSurface4 *iface, HDC *dc)
2143 {
2144     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2145
2146     TRACE("iface %p, dc %p.\n", iface, dc);
2147
2148     return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
2149 }
2150
2151 static HRESULT WINAPI ddraw_surface3_GetDC(IDirectDrawSurface3 *iface, HDC *dc)
2152 {
2153     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2154
2155     TRACE("iface %p, dc %p.\n", iface, dc);
2156
2157     return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
2158 }
2159
2160 static HRESULT WINAPI ddraw_surface2_GetDC(IDirectDrawSurface2 *iface, HDC *dc)
2161 {
2162     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2163
2164     TRACE("iface %p, dc %p.\n", iface, dc);
2165
2166     return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
2167 }
2168
2169 static HRESULT WINAPI ddraw_surface1_GetDC(IDirectDrawSurface *iface, HDC *dc)
2170 {
2171     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2172
2173     TRACE("iface %p, dc %p.\n", iface, dc);
2174
2175     return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
2176 }
2177
2178 /*****************************************************************************
2179  * IDirectDrawSurface7::ReleaseDC
2180  *
2181  * Releases the DC that was constructed with GetDC
2182  *
2183  * Params:
2184  *  hdc: HDC to release
2185  *
2186  * Returns:
2187  *  DD_OK on success
2188  *  For more details, see IWineD3DSurface::ReleaseDC
2189  *
2190  *****************************************************************************/
2191 static HRESULT WINAPI ddraw_surface7_ReleaseDC(IDirectDrawSurface7 *iface, HDC hdc)
2192 {
2193     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2194     HRESULT hr;
2195
2196     TRACE("iface %p, dc %p.\n", iface, hdc);
2197
2198     wined3d_mutex_lock();
2199     hr = wined3d_surface_releasedc(surface->wined3d_surface, hdc);
2200     if (SUCCEEDED(hr) && (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
2201         hr = ddraw_surface_update_frontbuffer(surface, NULL, FALSE);
2202     wined3d_mutex_unlock();
2203
2204     return hr;
2205 }
2206
2207 static HRESULT WINAPI ddraw_surface4_ReleaseDC(IDirectDrawSurface4 *iface, HDC dc)
2208 {
2209     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2210
2211     TRACE("iface %p, dc %p.\n", iface, dc);
2212
2213     return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2214 }
2215
2216 static HRESULT WINAPI ddraw_surface3_ReleaseDC(IDirectDrawSurface3 *iface, HDC dc)
2217 {
2218     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2219
2220     TRACE("iface %p, dc %p.\n", iface, dc);
2221
2222     return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2223 }
2224
2225 static HRESULT WINAPI ddraw_surface2_ReleaseDC(IDirectDrawSurface2 *iface, HDC dc)
2226 {
2227     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2228
2229     TRACE("iface %p, dc %p.\n", iface, dc);
2230
2231     return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2232 }
2233
2234 static HRESULT WINAPI ddraw_surface1_ReleaseDC(IDirectDrawSurface *iface, HDC dc)
2235 {
2236     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2237
2238     TRACE("iface %p, dc %p.\n", iface, dc);
2239
2240     return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2241 }
2242
2243 /*****************************************************************************
2244  * IDirectDrawSurface7::GetCaps
2245  *
2246  * Returns the surface's caps
2247  *
2248  * Params:
2249  *  Caps: Address to write the caps to
2250  *
2251  * Returns:
2252  *  DD_OK on success
2253  *  DDERR_INVALIDPARAMS if Caps is NULL
2254  *
2255  *****************************************************************************/
2256 static HRESULT WINAPI ddraw_surface7_GetCaps(IDirectDrawSurface7 *iface, DDSCAPS2 *Caps)
2257 {
2258     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2259
2260     TRACE("iface %p, caps %p.\n", iface, Caps);
2261
2262     if(!Caps)
2263         return DDERR_INVALIDPARAMS;
2264
2265     *Caps = surface->surface_desc.ddsCaps;
2266
2267     return DD_OK;
2268 }
2269
2270 static HRESULT WINAPI ddraw_surface4_GetCaps(IDirectDrawSurface4 *iface, DDSCAPS2 *caps)
2271 {
2272     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2273
2274     TRACE("iface %p, caps %p.\n", iface, caps);
2275
2276     return ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, caps);
2277 }
2278
2279 static HRESULT WINAPI ddraw_surface3_GetCaps(IDirectDrawSurface3 *iface, DDSCAPS *caps)
2280 {
2281     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2282     DDSCAPS2 caps2;
2283     HRESULT hr;
2284
2285     TRACE("iface %p, caps %p.\n", iface, caps);
2286
2287     hr = ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, &caps2);
2288     if (FAILED(hr)) return hr;
2289
2290     caps->dwCaps = caps2.dwCaps;
2291     return hr;
2292 }
2293
2294 static HRESULT WINAPI ddraw_surface2_GetCaps(IDirectDrawSurface2 *iface, DDSCAPS *caps)
2295 {
2296     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2297     DDSCAPS2 caps2;
2298     HRESULT hr;
2299
2300     TRACE("iface %p, caps %p.\n", iface, caps);
2301
2302     hr = ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, &caps2);
2303     if (FAILED(hr)) return hr;
2304
2305     caps->dwCaps = caps2.dwCaps;
2306     return hr;
2307 }
2308
2309 static HRESULT WINAPI ddraw_surface1_GetCaps(IDirectDrawSurface *iface, DDSCAPS *caps)
2310 {
2311     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2312     DDSCAPS2 caps2;
2313     HRESULT hr;
2314
2315     TRACE("iface %p, caps %p.\n", iface, caps);
2316
2317     hr = ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, &caps2);
2318     if (FAILED(hr)) return hr;
2319
2320     caps->dwCaps = caps2.dwCaps;
2321     return hr;
2322 }
2323
2324 static HRESULT WINAPI ddraw_surface7_SetPriority(IDirectDrawSurface7 *iface, DWORD priority)
2325 {
2326     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2327     DWORD managed = DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE;
2328     HRESULT hr;
2329     struct wined3d_resource *resource;
2330
2331     TRACE("iface %p, priority %u.\n", iface, priority);
2332
2333     wined3d_mutex_lock();
2334     /* No need to check for offscreen plain surfaces or mipmap sublevels. SetPriority
2335      * calls on such surfaces segfault on Windows. */
2336     if (!(surface->surface_desc.ddsCaps.dwCaps2 & managed))
2337     {
2338         WARN("Called on non-managed texture returning DDERR_INVALIDPARAMS.\n");
2339         hr = DDERR_INVALIDPARAMS;
2340     }
2341     else
2342     {
2343         resource = wined3d_texture_get_resource(surface->wined3d_texture);
2344         wined3d_resource_set_priority(resource, priority);
2345         hr = DD_OK;
2346     }
2347     wined3d_mutex_unlock();
2348
2349     return hr;
2350 }
2351
2352 static HRESULT WINAPI ddraw_surface7_GetPriority(IDirectDrawSurface7 *iface, DWORD *priority)
2353 {
2354     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2355     const struct wined3d_resource *resource;
2356     DWORD managed = DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE;
2357     HRESULT hr;
2358
2359     TRACE("iface %p, priority %p.\n", iface, priority);
2360
2361     wined3d_mutex_lock();
2362     if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN)
2363     {
2364         WARN("Called on offscreenplain surface, returning DDERR_INVALIDOBJECT.\n");
2365         hr = DDERR_INVALIDOBJECT;
2366     }
2367     else if (!(surface->surface_desc.ddsCaps.dwCaps2 & managed) || !surface->wined3d_texture)
2368     {
2369         WARN("Called on non-managed texture or mipmap sublevel, returning DDERR_INVALIDPARAMS.\n");
2370         hr = DDERR_INVALIDPARAMS;
2371     }
2372     else
2373     {
2374         resource = wined3d_texture_get_resource(surface->wined3d_texture);
2375         *priority = wined3d_resource_get_priority(resource);
2376         hr = DD_OK;
2377     }
2378     wined3d_mutex_unlock();
2379
2380     return hr;
2381 }
2382
2383 /*****************************************************************************
2384  * IDirectDrawSurface7::SetPrivateData
2385  *
2386  * Stores some data in the surface that is intended for the application's
2387  * use.
2388  *
2389  * Params:
2390  *  tag: GUID that identifies the data
2391  *  Data: Pointer to the private data
2392  *  Size: Size of the private data
2393  *  Flags: Some flags
2394  *
2395  * Returns:
2396  *  D3D_OK on success
2397  *  For more details, see IWineD3DSurface::SetPrivateData
2398  *
2399  *****************************************************************************/
2400 static HRESULT WINAPI ddraw_surface7_SetPrivateData(IDirectDrawSurface7 *iface,
2401         REFGUID tag, void *data, DWORD size, DWORD flags)
2402 {
2403     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2404     HRESULT hr;
2405
2406     TRACE("iface %p, tag %s, data %p, data_size %u, flags %#x.\n",
2407             iface, debugstr_guid(tag), data, size, flags);
2408
2409     if (!data)
2410     {
2411         WARN("data is NULL, returning DDERR_INVALIDPARAMS.\n");
2412         return DDERR_INVALIDPARAMS;
2413     }
2414
2415     wined3d_mutex_lock();
2416     hr = wined3d_private_store_set_private_data(&surface->private_store, tag, data, size, flags);
2417     wined3d_mutex_unlock();
2418     return hr_ddraw_from_wined3d(hr);
2419 }
2420
2421 static HRESULT WINAPI ddraw_surface4_SetPrivateData(IDirectDrawSurface4 *iface,
2422         REFGUID tag, void *data, DWORD size, DWORD flags)
2423 {
2424     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2425
2426     TRACE("iface %p, tag %s, data %p, data_size %u, flags %#x.\n",
2427                 iface, debugstr_guid(tag), data, size, flags);
2428
2429     return ddraw_surface7_SetPrivateData(&surface->IDirectDrawSurface7_iface, tag, data, size, flags);
2430 }
2431
2432 /*****************************************************************************
2433  * IDirectDrawSurface7::GetPrivateData
2434  *
2435  * Returns the private data set with IDirectDrawSurface7::SetPrivateData
2436  *
2437  * Params:
2438  *  tag: GUID of the data to return
2439  *  Data: Address where to write the data to
2440  *  Size: Size of the buffer at Data
2441  *
2442  * Returns:
2443  *  DD_OK on success
2444  *  DDERR_INVALIDPARAMS if Data is NULL
2445  *  For more details, see IWineD3DSurface::GetPrivateData
2446  *
2447  *****************************************************************************/
2448 static HRESULT WINAPI ddraw_surface7_GetPrivateData(IDirectDrawSurface7 *iface, REFGUID tag, void *data, DWORD *size)
2449 {
2450     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2451     const struct wined3d_private_data *stored_data;
2452     HRESULT hr;
2453
2454     TRACE("iface %p, tag %s, data %p, data_size %p.\n",
2455             iface, debugstr_guid(tag), data, size);
2456
2457     wined3d_mutex_lock();
2458     stored_data = wined3d_private_store_get_private_data(&surface->private_store, tag);
2459     if (!stored_data)
2460     {
2461         hr = DDERR_NOTFOUND;
2462         goto done;
2463     }
2464     if (!size)
2465     {
2466         hr = DDERR_INVALIDPARAMS;
2467         goto done;
2468     }
2469     if (*size < stored_data->size)
2470     {
2471         *size = stored_data->size;
2472         hr = DDERR_MOREDATA;
2473         goto done;
2474     }
2475     if (!data)
2476     {
2477         hr = DDERR_INVALIDPARAMS;
2478         goto done;
2479     }
2480
2481     *size = stored_data->size;
2482     memcpy(data, stored_data->content.data, stored_data->size);
2483     hr = DD_OK;
2484
2485 done:
2486     wined3d_mutex_unlock();
2487     return hr;
2488 }
2489
2490 static HRESULT WINAPI ddraw_surface4_GetPrivateData(IDirectDrawSurface4 *iface, REFGUID tag, void *data, DWORD *size)
2491 {
2492     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2493
2494     TRACE("iface %p, tag %s, data %p, data_size %p.\n",
2495                 iface, debugstr_guid(tag), data, size);
2496
2497     return ddraw_surface7_GetPrivateData(&surface->IDirectDrawSurface7_iface, tag, data, size);
2498 }
2499
2500 /*****************************************************************************
2501  * IDirectDrawSurface7::FreePrivateData
2502  *
2503  * Frees private data stored in the surface
2504  *
2505  * Params:
2506  *  tag: Tag of the data to free
2507  *
2508  * Returns:
2509  *  D3D_OK on success
2510  *  For more details, see IWineD3DSurface::FreePrivateData
2511  *
2512  *****************************************************************************/
2513 static HRESULT WINAPI ddraw_surface7_FreePrivateData(IDirectDrawSurface7 *iface, REFGUID tag)
2514 {
2515     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2516     struct wined3d_private_data *entry;
2517
2518     TRACE("iface %p, tag %s.\n", iface, debugstr_guid(tag));
2519
2520     wined3d_mutex_lock();
2521     entry = wined3d_private_store_get_private_data(&surface->private_store, tag);
2522     if (!entry)
2523     {
2524         wined3d_mutex_unlock();
2525         return DDERR_NOTFOUND;
2526     }
2527
2528     wined3d_private_store_free_private_data(&surface->private_store, entry);
2529     wined3d_mutex_unlock();
2530
2531     return DD_OK;
2532 }
2533
2534 static HRESULT WINAPI ddraw_surface4_FreePrivateData(IDirectDrawSurface4 *iface, REFGUID tag)
2535 {
2536     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2537
2538     TRACE("iface %p, tag %s.\n", iface, debugstr_guid(tag));
2539
2540     return ddraw_surface7_FreePrivateData(&surface->IDirectDrawSurface7_iface, tag);
2541 }
2542
2543 /*****************************************************************************
2544  * IDirectDrawSurface7::PageLock
2545  *
2546  * Prevents a sysmem surface from being paged out
2547  *
2548  * Params:
2549  *  Flags: Not used, must be 0(unchecked)
2550  *
2551  * Returns:
2552  *  DD_OK, because it's a stub
2553  *
2554  *****************************************************************************/
2555 static HRESULT WINAPI ddraw_surface7_PageLock(IDirectDrawSurface7 *iface, DWORD Flags)
2556 {
2557     TRACE("iface %p, flags %#x.\n", iface, Flags);
2558
2559     /* This is Windows memory management related - we don't need this */
2560     return DD_OK;
2561 }
2562
2563 static HRESULT WINAPI ddraw_surface4_PageLock(IDirectDrawSurface4 *iface, DWORD flags)
2564 {
2565     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2566
2567     TRACE("iface %p, flags %#x.\n", iface, flags);
2568
2569     return ddraw_surface7_PageLock(&surface->IDirectDrawSurface7_iface, flags);
2570 }
2571
2572 static HRESULT WINAPI ddraw_surface3_PageLock(IDirectDrawSurface3 *iface, DWORD flags)
2573 {
2574     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2575
2576     TRACE("iface %p, flags %#x.\n", iface, flags);
2577
2578     return ddraw_surface7_PageLock(&surface->IDirectDrawSurface7_iface, flags);
2579 }
2580
2581 static HRESULT WINAPI ddraw_surface2_PageLock(IDirectDrawSurface2 *iface, DWORD flags)
2582 {
2583     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2584
2585     TRACE("iface %p, flags %#x.\n", iface, flags);
2586
2587     return ddraw_surface7_PageLock(&surface->IDirectDrawSurface7_iface, flags);
2588 }
2589
2590 /*****************************************************************************
2591  * IDirectDrawSurface7::PageUnlock
2592  *
2593  * Allows a sysmem surface to be paged out
2594  *
2595  * Params:
2596  *  Flags: Not used, must be 0(unchecked)
2597  *
2598  * Returns:
2599  *  DD_OK, because it's a stub
2600  *
2601  *****************************************************************************/
2602 static HRESULT WINAPI ddraw_surface7_PageUnlock(IDirectDrawSurface7 *iface, DWORD Flags)
2603 {
2604     TRACE("iface %p, flags %#x.\n", iface, Flags);
2605
2606     return DD_OK;
2607 }
2608
2609 static HRESULT WINAPI ddraw_surface4_PageUnlock(IDirectDrawSurface4 *iface, DWORD flags)
2610 {
2611     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2612
2613     TRACE("iface %p, flags %#x.\n", iface, flags);
2614
2615     return ddraw_surface7_PageUnlock(&surface->IDirectDrawSurface7_iface, flags);
2616 }
2617
2618 static HRESULT WINAPI ddraw_surface3_PageUnlock(IDirectDrawSurface3 *iface, DWORD flags)
2619 {
2620     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2621
2622     TRACE("iface %p, flags %#x.\n", iface, flags);
2623
2624     return ddraw_surface7_PageUnlock(&surface->IDirectDrawSurface7_iface, flags);
2625 }
2626
2627 static HRESULT WINAPI ddraw_surface2_PageUnlock(IDirectDrawSurface2 *iface, DWORD flags)
2628 {
2629     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2630
2631     TRACE("iface %p, flags %#x.\n", iface, flags);
2632
2633     return ddraw_surface7_PageUnlock(&surface->IDirectDrawSurface7_iface, flags);
2634 }
2635
2636 /*****************************************************************************
2637  * IDirectDrawSurface7::BltBatch
2638  *
2639  * An unimplemented function
2640  *
2641  * Params:
2642  *  ?
2643  *
2644  * Returns:
2645  *  DDERR_UNSUPPORTED
2646  *
2647  *****************************************************************************/
2648 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface7_BltBatch(IDirectDrawSurface7 *iface, DDBLTBATCH *Batch, DWORD Count, DWORD Flags)
2649 {
2650     TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, Batch, Count, Flags);
2651
2652     /* MSDN: "not currently implemented" */
2653     return DDERR_UNSUPPORTED;
2654 }
2655
2656 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface4_BltBatch(IDirectDrawSurface4 *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2657 {
2658     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2659
2660     TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2661
2662     return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2663 }
2664
2665 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface3_BltBatch(IDirectDrawSurface3 *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2666 {
2667     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2668
2669     TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2670
2671     return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2672 }
2673
2674 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface2_BltBatch(IDirectDrawSurface2 *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2675 {
2676     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2677
2678     TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2679
2680     return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2681 }
2682
2683 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface1_BltBatch(IDirectDrawSurface *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2684 {
2685     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2686
2687     TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2688
2689     return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2690 }
2691
2692 /*****************************************************************************
2693  * IDirectDrawSurface7::EnumAttachedSurfaces
2694  *
2695  * Enumerates all surfaces attached to this surface
2696  *
2697  * Params:
2698  *  context: Pointer to pass unmodified to the callback
2699  *  cb: Callback function to call for each surface
2700  *
2701  * Returns:
2702  *  DD_OK on success
2703  *  DDERR_INVALIDPARAMS if cb is NULL
2704  *
2705  *****************************************************************************/
2706 static HRESULT WINAPI ddraw_surface7_EnumAttachedSurfaces(IDirectDrawSurface7 *iface,
2707         void *context, LPDDENUMSURFACESCALLBACK7 cb)
2708 {
2709     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2710     struct ddraw_surface *surf;
2711     DDSURFACEDESC2 desc;
2712     int i;
2713
2714     /* Attached surfaces aren't handled in WineD3D */
2715     TRACE("iface %p, context %p, callback %p.\n", iface, context, cb);
2716
2717     if(!cb)
2718         return DDERR_INVALIDPARAMS;
2719
2720     wined3d_mutex_lock();
2721
2722     for(i = 0; i < MAX_COMPLEX_ATTACHED; i++)
2723     {
2724         surf = surface->complex_array[i];
2725         if(!surf) break;
2726
2727         ddraw_surface7_AddRef(&surf->IDirectDrawSurface7_iface);
2728         desc = surf->surface_desc;
2729         /* check: != DDENUMRET_OK or == DDENUMRET_CANCEL? */
2730         if (cb(&surf->IDirectDrawSurface7_iface, &desc, context) == DDENUMRET_CANCEL)
2731         {
2732             wined3d_mutex_unlock();
2733             return DD_OK;
2734         }
2735     }
2736
2737     for (surf = surface->next_attached; surf != NULL; surf = surf->next_attached)
2738     {
2739         ddraw_surface7_AddRef(&surf->IDirectDrawSurface7_iface);
2740         desc = surf->surface_desc;
2741         /* check: != DDENUMRET_OK or == DDENUMRET_CANCEL? */
2742         if (cb(&surf->IDirectDrawSurface7_iface, &desc, context) == DDENUMRET_CANCEL)
2743         {
2744             wined3d_mutex_unlock();
2745             return DD_OK;
2746         }
2747     }
2748
2749     TRACE(" end of enumeration.\n");
2750
2751     wined3d_mutex_unlock();
2752
2753     return DD_OK;
2754 }
2755
2756 struct callback_info2
2757 {
2758     LPDDENUMSURFACESCALLBACK2 callback;
2759     void *context;
2760 };
2761
2762 struct callback_info
2763 {
2764     LPDDENUMSURFACESCALLBACK callback;
2765     void *context;
2766 };
2767
2768 static HRESULT CALLBACK EnumCallback2(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *surface_desc, void *context)
2769 {
2770     struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
2771     const struct callback_info2 *info = context;
2772
2773     ddraw_surface4_AddRef(&surface_impl->IDirectDrawSurface4_iface);
2774     ddraw_surface7_Release(surface);
2775
2776     return info->callback(&surface_impl->IDirectDrawSurface4_iface, surface_desc, info->context);
2777 }
2778
2779 static HRESULT CALLBACK EnumCallback(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *surface_desc, void *context)
2780 {
2781     struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
2782     const struct callback_info *info = context;
2783
2784     ddraw_surface1_AddRef(&surface_impl->IDirectDrawSurface_iface);
2785     ddraw_surface7_Release(surface);
2786
2787     /* FIXME: Check surface_test.dwSize */
2788     return info->callback(&surface_impl->IDirectDrawSurface_iface,
2789             (DDSURFACEDESC *)surface_desc, info->context);
2790 }
2791
2792 static HRESULT WINAPI ddraw_surface4_EnumAttachedSurfaces(IDirectDrawSurface4 *iface,
2793         void *context, LPDDENUMSURFACESCALLBACK2 callback)
2794 {
2795     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2796     struct callback_info2 info;
2797
2798     TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2799
2800     info.callback = callback;
2801     info.context  = context;
2802
2803     return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2804             &info, EnumCallback2);
2805 }
2806
2807 static HRESULT WINAPI ddraw_surface3_EnumAttachedSurfaces(IDirectDrawSurface3 *iface,
2808         void *context, LPDDENUMSURFACESCALLBACK callback)
2809 {
2810     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2811     struct callback_info info;
2812
2813     TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2814
2815     info.callback = callback;
2816     info.context  = context;
2817
2818     return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2819             &info, EnumCallback);
2820 }
2821
2822 static HRESULT WINAPI ddraw_surface2_EnumAttachedSurfaces(IDirectDrawSurface2 *iface,
2823         void *context, LPDDENUMSURFACESCALLBACK callback)
2824 {
2825     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2826     struct callback_info info;
2827
2828     TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2829
2830     info.callback = callback;
2831     info.context  = context;
2832
2833     return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2834             &info, EnumCallback);
2835 }
2836
2837 static HRESULT WINAPI ddraw_surface1_EnumAttachedSurfaces(IDirectDrawSurface *iface,
2838         void *context, LPDDENUMSURFACESCALLBACK callback)
2839 {
2840     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2841     struct callback_info info;
2842
2843     TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2844
2845     info.callback = callback;
2846     info.context  = context;
2847
2848     return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2849             &info, EnumCallback);
2850 }
2851
2852 /*****************************************************************************
2853  * IDirectDrawSurface7::EnumOverlayZOrders
2854  *
2855  * "Enumerates the overlay surfaces on the specified destination"
2856  *
2857  * Params:
2858  *  Flags: DDENUMOVERLAYZ_BACKTOFRONT  or DDENUMOVERLAYZ_FRONTTOBACK
2859  *  context: context to pass back to the callback
2860  *  cb: callback function to call for each enumerated surface
2861  *
2862  * Returns:
2863  *  DD_OK, because it's a stub
2864  *
2865  *****************************************************************************/
2866 static HRESULT WINAPI ddraw_surface7_EnumOverlayZOrders(IDirectDrawSurface7 *iface,
2867         DWORD Flags, void *context, LPDDENUMSURFACESCALLBACK7 cb)
2868 {
2869     FIXME("iface %p, flags %#x, context %p, callback %p stub!\n", iface, Flags, context, cb);
2870
2871     return DD_OK;
2872 }
2873
2874 static HRESULT WINAPI ddraw_surface4_EnumOverlayZOrders(IDirectDrawSurface4 *iface,
2875         DWORD flags, void *context, LPDDENUMSURFACESCALLBACK2 callback)
2876 {
2877     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2878     struct callback_info2 info;
2879
2880     TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2881
2882     info.callback = callback;
2883     info.context  = context;
2884
2885     return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2886             flags, &info, EnumCallback2);
2887 }
2888
2889 static HRESULT WINAPI ddraw_surface3_EnumOverlayZOrders(IDirectDrawSurface3 *iface,
2890         DWORD flags, void *context, LPDDENUMSURFACESCALLBACK callback)
2891 {
2892     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2893     struct callback_info info;
2894
2895     TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2896
2897     info.callback = callback;
2898     info.context  = context;
2899
2900     return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2901             flags, &info, EnumCallback);
2902 }
2903
2904 static HRESULT WINAPI ddraw_surface2_EnumOverlayZOrders(IDirectDrawSurface2 *iface,
2905         DWORD flags, void *context, LPDDENUMSURFACESCALLBACK callback)
2906 {
2907     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2908     struct callback_info info;
2909
2910     TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2911
2912     info.callback = callback;
2913     info.context  = context;
2914
2915     return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2916             flags, &info, EnumCallback);
2917 }
2918
2919 static HRESULT WINAPI ddraw_surface1_EnumOverlayZOrders(IDirectDrawSurface *iface,
2920         DWORD flags, void *context, LPDDENUMSURFACESCALLBACK callback)
2921 {
2922     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2923     struct callback_info info;
2924
2925     TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2926
2927     info.callback = callback;
2928     info.context  = context;
2929
2930     return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2931             flags, &info, EnumCallback);
2932 }
2933
2934 /*****************************************************************************
2935  * IDirectDrawSurface7::GetBltStatus
2936  *
2937  * Returns the blitting status
2938  *
2939  * Params:
2940  *  Flags: DDGBS_CANBLT or DDGBS_ISBLTDONE
2941  *
2942  * Returns:
2943  *  See IWineD3DSurface::Blt
2944  *
2945  *****************************************************************************/
2946 static HRESULT WINAPI ddraw_surface7_GetBltStatus(IDirectDrawSurface7 *iface, DWORD Flags)
2947 {
2948     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2949     HRESULT hr;
2950
2951     TRACE("iface %p, flags %#x.\n", iface, Flags);
2952
2953     wined3d_mutex_lock();
2954     hr = wined3d_surface_get_blt_status(surface->wined3d_surface, Flags);
2955     wined3d_mutex_unlock();
2956     switch(hr)
2957     {
2958         case WINED3DERR_INVALIDCALL:        return DDERR_INVALIDPARAMS;
2959         default:                            return hr;
2960     }
2961 }
2962
2963 static HRESULT WINAPI ddraw_surface4_GetBltStatus(IDirectDrawSurface4 *iface, DWORD flags)
2964 {
2965     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2966
2967     TRACE("iface %p, flags %#x.\n", iface, flags);
2968
2969     return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2970 }
2971
2972 static HRESULT WINAPI ddraw_surface3_GetBltStatus(IDirectDrawSurface3 *iface, DWORD flags)
2973 {
2974     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2975
2976     TRACE("iface %p, flags %#x.\n", iface, flags);
2977
2978     return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2979 }
2980
2981 static HRESULT WINAPI ddraw_surface2_GetBltStatus(IDirectDrawSurface2 *iface, DWORD flags)
2982 {
2983     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2984
2985     TRACE("iface %p, flags %#x.\n", iface, flags);
2986
2987     return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2988 }
2989
2990 static HRESULT WINAPI ddraw_surface1_GetBltStatus(IDirectDrawSurface *iface, DWORD flags)
2991 {
2992     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2993
2994     TRACE("iface %p, flags %#x.\n", iface, flags);
2995
2996     return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2997 }
2998
2999 /*****************************************************************************
3000  * IDirectDrawSurface7::GetColorKey
3001  *
3002  * Returns the color key assigned to the surface
3003  *
3004  * Params:
3005  *  Flags: Some flags
3006  *  CKey: Address to store the key to
3007  *
3008  * Returns:
3009  *  DD_OK on success
3010  *  DDERR_INVALIDPARAMS if CKey is NULL
3011  *
3012  *****************************************************************************/
3013 static HRESULT WINAPI ddraw_surface7_GetColorKey(IDirectDrawSurface7 *iface, DWORD Flags, DDCOLORKEY *CKey)
3014 {
3015     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
3016
3017     TRACE("iface %p, flags %#x, color_key %p.\n", iface, Flags, CKey);
3018
3019     if(!CKey)
3020         return DDERR_INVALIDPARAMS;
3021
3022     wined3d_mutex_lock();
3023
3024     switch (Flags)
3025     {
3026     case DDCKEY_DESTBLT:
3027         if (!(This->surface_desc.dwFlags & DDSD_CKDESTBLT))
3028         {
3029             wined3d_mutex_unlock();
3030             return DDERR_NOCOLORKEY;
3031         }
3032         *CKey = This->surface_desc.ddckCKDestBlt;
3033         break;
3034
3035     case DDCKEY_DESTOVERLAY:
3036         if (!(This->surface_desc.dwFlags & DDSD_CKDESTOVERLAY))
3037         {
3038             wined3d_mutex_unlock();
3039             return DDERR_NOCOLORKEY;
3040         }
3041         *CKey = This->surface_desc.u3.ddckCKDestOverlay;
3042         break;
3043
3044     case DDCKEY_SRCBLT:
3045         if (!(This->surface_desc.dwFlags & DDSD_CKSRCBLT))
3046         {
3047             wined3d_mutex_unlock();
3048             return DDERR_NOCOLORKEY;
3049         }
3050         *CKey = This->surface_desc.ddckCKSrcBlt;
3051         break;
3052
3053     case DDCKEY_SRCOVERLAY:
3054         if (!(This->surface_desc.dwFlags & DDSD_CKSRCOVERLAY))
3055         {
3056             wined3d_mutex_unlock();
3057             return DDERR_NOCOLORKEY;
3058         }
3059         *CKey = This->surface_desc.ddckCKSrcOverlay;
3060         break;
3061
3062     default:
3063         wined3d_mutex_unlock();
3064         return DDERR_INVALIDPARAMS;
3065     }
3066
3067     wined3d_mutex_unlock();
3068
3069     return DD_OK;
3070 }
3071
3072 static HRESULT WINAPI ddraw_surface4_GetColorKey(IDirectDrawSurface4 *iface, DWORD flags, DDCOLORKEY *color_key)
3073 {
3074     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3075
3076     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
3077
3078     return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
3079 }
3080
3081 static HRESULT WINAPI ddraw_surface3_GetColorKey(IDirectDrawSurface3 *iface, DWORD flags, DDCOLORKEY *color_key)
3082 {
3083     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3084
3085     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
3086
3087     return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
3088 }
3089
3090 static HRESULT WINAPI ddraw_surface2_GetColorKey(IDirectDrawSurface2 *iface, DWORD flags, DDCOLORKEY *color_key)
3091 {
3092     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3093
3094     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
3095
3096     return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
3097 }
3098
3099 static HRESULT WINAPI ddraw_surface1_GetColorKey(IDirectDrawSurface *iface, DWORD flags, DDCOLORKEY *color_key)
3100 {
3101     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3102
3103     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
3104
3105     return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
3106 }
3107
3108 /*****************************************************************************
3109  * IDirectDrawSurface7::GetFlipStatus
3110  *
3111  * Returns the flipping status of the surface
3112  *
3113  * Params:
3114  *  Flags: DDGFS_CANFLIP of DDGFS_ISFLIPDONE
3115  *
3116  * Returns:
3117  *  See IWineD3DSurface::GetFlipStatus
3118  *
3119  *****************************************************************************/
3120 static HRESULT WINAPI ddraw_surface7_GetFlipStatus(IDirectDrawSurface7 *iface, DWORD Flags)
3121 {
3122     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3123     HRESULT hr;
3124
3125     TRACE("iface %p, flags %#x.\n", iface, Flags);
3126
3127     wined3d_mutex_lock();
3128     hr = wined3d_surface_get_flip_status(surface->wined3d_surface, Flags);
3129     wined3d_mutex_unlock();
3130
3131     switch(hr)
3132     {
3133         case WINED3DERR_INVALIDCALL:        return DDERR_INVALIDPARAMS;
3134         default:                            return hr;
3135     }
3136 }
3137
3138 static HRESULT WINAPI ddraw_surface4_GetFlipStatus(IDirectDrawSurface4 *iface, DWORD flags)
3139 {
3140     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3141
3142     TRACE("iface %p, flags %#x.\n", iface, flags);
3143
3144     return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
3145 }
3146
3147 static HRESULT WINAPI ddraw_surface3_GetFlipStatus(IDirectDrawSurface3 *iface, DWORD flags)
3148 {
3149     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3150
3151     TRACE("iface %p, flags %#x.\n", iface, flags);
3152
3153     return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
3154 }
3155
3156 static HRESULT WINAPI ddraw_surface2_GetFlipStatus(IDirectDrawSurface2 *iface, DWORD flags)
3157 {
3158     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3159
3160     TRACE("iface %p, flags %#x.\n", iface, flags);
3161
3162     return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
3163 }
3164
3165 static HRESULT WINAPI ddraw_surface1_GetFlipStatus(IDirectDrawSurface *iface, DWORD flags)
3166 {
3167     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3168
3169     TRACE("iface %p, flags %#x.\n", iface, flags);
3170
3171     return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
3172 }
3173
3174 /*****************************************************************************
3175  * IDirectDrawSurface7::GetOverlayPosition
3176  *
3177  * Returns the display coordinates of a visible and active overlay surface
3178  *
3179  * Params:
3180  *  X
3181  *  Y
3182  *
3183  * Returns:
3184  *  DDERR_NOTAOVERLAYSURFACE, because it's a stub
3185  *****************************************************************************/
3186 static HRESULT WINAPI ddraw_surface7_GetOverlayPosition(IDirectDrawSurface7 *iface, LONG *X, LONG *Y)
3187 {
3188     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3189     HRESULT hr;
3190
3191     TRACE("iface %p, x %p, y %p.\n", iface, X, Y);
3192
3193     wined3d_mutex_lock();
3194     hr = wined3d_surface_get_overlay_position(surface->wined3d_surface, X, Y);
3195     wined3d_mutex_unlock();
3196
3197     return hr;
3198 }
3199
3200 static HRESULT WINAPI ddraw_surface4_GetOverlayPosition(IDirectDrawSurface4 *iface, LONG *x, LONG *y)
3201 {
3202     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3203
3204     TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3205
3206     return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3207 }
3208
3209 static HRESULT WINAPI ddraw_surface3_GetOverlayPosition(IDirectDrawSurface3 *iface, LONG *x, LONG *y)
3210 {
3211     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3212
3213     TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3214
3215     return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3216 }
3217
3218 static HRESULT WINAPI ddraw_surface2_GetOverlayPosition(IDirectDrawSurface2 *iface, LONG *x, LONG *y)
3219 {
3220     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3221
3222     TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3223
3224     return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3225 }
3226
3227 static HRESULT WINAPI ddraw_surface1_GetOverlayPosition(IDirectDrawSurface *iface, LONG *x, LONG *y)
3228 {
3229     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3230
3231     TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3232
3233     return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3234 }
3235
3236 /*****************************************************************************
3237  * IDirectDrawSurface7::GetPixelFormat
3238  *
3239  * Returns the pixel format of the Surface
3240  *
3241  * Params:
3242  *  PixelFormat: Pointer to a DDPIXELFORMAT structure to which the pixel
3243  *               format should be written
3244  *
3245  * Returns:
3246  *  DD_OK on success
3247  *  DDERR_INVALIDPARAMS if PixelFormat is NULL
3248  *
3249  *****************************************************************************/
3250 static HRESULT WINAPI ddraw_surface7_GetPixelFormat(IDirectDrawSurface7 *iface, DDPIXELFORMAT *PixelFormat)
3251 {
3252     /* What is DDERR_INVALIDSURFACETYPE for here? */
3253     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3254
3255     TRACE("iface %p, pixel_format %p.\n", iface, PixelFormat);
3256
3257     if(!PixelFormat)
3258         return DDERR_INVALIDPARAMS;
3259
3260     wined3d_mutex_lock();
3261     DD_STRUCT_COPY_BYSIZE(PixelFormat, &surface->surface_desc.u4.ddpfPixelFormat);
3262     wined3d_mutex_unlock();
3263
3264     return DD_OK;
3265 }
3266
3267 static HRESULT WINAPI ddraw_surface4_GetPixelFormat(IDirectDrawSurface4 *iface, DDPIXELFORMAT *pixel_format)
3268 {
3269     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3270
3271     TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3272
3273     return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3274 }
3275
3276 static HRESULT WINAPI ddraw_surface3_GetPixelFormat(IDirectDrawSurface3 *iface, DDPIXELFORMAT *pixel_format)
3277 {
3278     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3279
3280     TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3281
3282     return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3283 }
3284
3285 static HRESULT WINAPI ddraw_surface2_GetPixelFormat(IDirectDrawSurface2 *iface, DDPIXELFORMAT *pixel_format)
3286 {
3287     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3288
3289     TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3290
3291     return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3292 }
3293
3294 static HRESULT WINAPI ddraw_surface1_GetPixelFormat(IDirectDrawSurface *iface, DDPIXELFORMAT *pixel_format)
3295 {
3296     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3297
3298     TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3299
3300     return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3301 }
3302
3303 /*****************************************************************************
3304  * IDirectDrawSurface7::GetSurfaceDesc
3305  *
3306  * Returns the description of this surface
3307  *
3308  * Params:
3309  *  DDSD: Address of a DDSURFACEDESC2 structure that is to be filled with the
3310  *        surface desc
3311  *
3312  * Returns:
3313  *  DD_OK on success
3314  *  DDERR_INVALIDPARAMS if DDSD is NULL
3315  *
3316  *****************************************************************************/
3317 static HRESULT WINAPI ddraw_surface7_GetSurfaceDesc(IDirectDrawSurface7 *iface, DDSURFACEDESC2 *DDSD)
3318 {
3319     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3320
3321     TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3322
3323     if(!DDSD)
3324         return DDERR_INVALIDPARAMS;
3325
3326     if (DDSD->dwSize != sizeof(DDSURFACEDESC2))
3327     {
3328         WARN("Incorrect struct size %d, returning DDERR_INVALIDPARAMS\n",DDSD->dwSize);
3329         return DDERR_INVALIDPARAMS;
3330     }
3331
3332     wined3d_mutex_lock();
3333     DD_STRUCT_COPY_BYSIZE(DDSD, &surface->surface_desc);
3334     TRACE("Returning surface desc:\n");
3335     if (TRACE_ON(ddraw)) DDRAW_dump_surface_desc(DDSD);
3336     wined3d_mutex_unlock();
3337
3338     return DD_OK;
3339 }
3340
3341 static HRESULT WINAPI ddraw_surface4_GetSurfaceDesc(IDirectDrawSurface4 *iface, DDSURFACEDESC2 *DDSD)
3342 {
3343     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3344
3345     TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3346
3347     return ddraw_surface7_GetSurfaceDesc(&surface->IDirectDrawSurface7_iface, DDSD);
3348 }
3349
3350 static HRESULT WINAPI ddraw_surface3_GetSurfaceDesc(IDirectDrawSurface3 *iface, DDSURFACEDESC *surface_desc)
3351 {
3352     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3353
3354     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
3355
3356     if (!surface_desc) return DDERR_INVALIDPARAMS;
3357
3358     if (surface_desc->dwSize != sizeof(DDSURFACEDESC))
3359     {
3360         WARN("Incorrect structure size %u, returning DDERR_INVALIDPARAMS.\n", surface_desc->dwSize);
3361         return DDERR_INVALIDPARAMS;
3362     }
3363
3364     wined3d_mutex_lock();
3365     DDSD2_to_DDSD(&surface->surface_desc, surface_desc);
3366     TRACE("Returning surface desc:\n");
3367     if (TRACE_ON(ddraw))
3368     {
3369         /* DDRAW_dump_surface_desc handles the smaller size */
3370         DDRAW_dump_surface_desc((DDSURFACEDESC2 *)surface_desc);
3371     }
3372     wined3d_mutex_unlock();
3373
3374     return DD_OK;
3375 }
3376
3377 static HRESULT WINAPI ddraw_surface2_GetSurfaceDesc(IDirectDrawSurface2 *iface, DDSURFACEDESC *DDSD)
3378 {
3379     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3380
3381     TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3382
3383     return ddraw_surface3_GetSurfaceDesc(&surface->IDirectDrawSurface3_iface, DDSD);
3384 }
3385
3386 static HRESULT WINAPI ddraw_surface1_GetSurfaceDesc(IDirectDrawSurface *iface, DDSURFACEDESC *DDSD)
3387 {
3388     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3389
3390     TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3391
3392     return ddraw_surface3_GetSurfaceDesc(&surface->IDirectDrawSurface3_iface, DDSD);
3393 }
3394
3395 /*****************************************************************************
3396  * IDirectDrawSurface7::Initialize
3397  *
3398  * Initializes the surface. This is a no-op in Wine
3399  *
3400  * Params:
3401  *  DD: Pointer to an DirectDraw interface
3402  *  DDSD: Surface description for initialization
3403  *
3404  * Returns:
3405  *  DDERR_ALREADYINITIALIZED
3406  *
3407  *****************************************************************************/
3408 static HRESULT WINAPI ddraw_surface7_Initialize(IDirectDrawSurface7 *iface,
3409         IDirectDraw *ddraw, DDSURFACEDESC2 *surface_desc)
3410 {
3411     TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3412
3413     return DDERR_ALREADYINITIALIZED;
3414 }
3415
3416 static HRESULT WINAPI ddraw_surface4_Initialize(IDirectDrawSurface4 *iface,
3417         IDirectDraw *ddraw, DDSURFACEDESC2 *surface_desc)
3418 {
3419     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3420
3421     TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3422
3423     return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3424             ddraw, surface_desc);
3425 }
3426
3427 static HRESULT WINAPI ddraw_surface3_Initialize(IDirectDrawSurface3 *iface,
3428         IDirectDraw *ddraw, DDSURFACEDESC *surface_desc)
3429 {
3430     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3431     DDSURFACEDESC2 surface_desc2;
3432
3433     TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3434
3435     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3436     return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3437             ddraw, surface_desc ? &surface_desc2 : NULL);
3438 }
3439
3440 static HRESULT WINAPI ddraw_surface2_Initialize(IDirectDrawSurface2 *iface,
3441         IDirectDraw *ddraw, DDSURFACEDESC *surface_desc)
3442 {
3443     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3444     DDSURFACEDESC2 surface_desc2;
3445
3446     TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3447
3448     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3449     return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3450             ddraw, surface_desc ? &surface_desc2 : NULL);
3451 }
3452
3453 static HRESULT WINAPI ddraw_surface1_Initialize(IDirectDrawSurface *iface,
3454         IDirectDraw *ddraw, DDSURFACEDESC *surface_desc)
3455 {
3456     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3457     DDSURFACEDESC2 surface_desc2;
3458
3459     TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3460
3461     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3462     return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3463             ddraw, surface_desc ? &surface_desc2 : NULL);
3464 }
3465
3466 /*****************************************************************************
3467  * IDirect3DTexture1::Initialize
3468  *
3469  * The sdk says it's not implemented
3470  *
3471  * Params:
3472  *  ?
3473  *
3474  * Returns
3475  *  DDERR_UNSUPPORTED
3476  *
3477  *****************************************************************************/
3478 static HRESULT WINAPI d3d_texture1_Initialize(IDirect3DTexture *iface,
3479         IDirect3DDevice *device, IDirectDrawSurface *surface)
3480 {
3481     TRACE("iface %p, device %p, surface %p.\n", iface, device, surface);
3482
3483     return DDERR_UNSUPPORTED; /* Unchecked */
3484 }
3485
3486 /*****************************************************************************
3487  * IDirectDrawSurface7::IsLost
3488  *
3489  * Checks if the surface is lost
3490  *
3491  * Returns:
3492  *  DD_OK, if the surface is usable
3493  *  DDERR_ISLOST if the surface is lost
3494  *  See IWineD3DSurface::IsLost for more details
3495  *
3496  *****************************************************************************/
3497 static HRESULT WINAPI ddraw_surface7_IsLost(IDirectDrawSurface7 *iface)
3498 {
3499     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3500     HRESULT hr;
3501
3502     TRACE("iface %p.\n", iface);
3503
3504     wined3d_mutex_lock();
3505     hr = wined3d_surface_is_lost(surface->wined3d_surface);
3506     wined3d_mutex_unlock();
3507
3508     switch(hr)
3509     {
3510         /* D3D8 and 9 loose full devices, thus there's only a DEVICELOST error.
3511          * WineD3D uses the same error for surfaces
3512          */
3513         case WINED3DERR_DEVICELOST:         return DDERR_SURFACELOST;
3514         default:                            return hr;
3515     }
3516 }
3517
3518 static HRESULT WINAPI ddraw_surface4_IsLost(IDirectDrawSurface4 *iface)
3519 {
3520     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3521
3522     TRACE("iface %p.\n", iface);
3523
3524     return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3525 }
3526
3527 static HRESULT WINAPI ddraw_surface3_IsLost(IDirectDrawSurface3 *iface)
3528 {
3529     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3530
3531     TRACE("iface %p.\n", iface);
3532
3533     return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3534 }
3535
3536 static HRESULT WINAPI ddraw_surface2_IsLost(IDirectDrawSurface2 *iface)
3537 {
3538     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3539
3540     TRACE("iface %p.\n", iface);
3541
3542     return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3543 }
3544
3545 static HRESULT WINAPI ddraw_surface1_IsLost(IDirectDrawSurface *iface)
3546 {
3547     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3548
3549     TRACE("iface %p.\n", iface);
3550
3551     return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3552 }
3553
3554 /*****************************************************************************
3555  * IDirectDrawSurface7::Restore
3556  *
3557  * Restores a lost surface. This makes the surface usable again, but
3558  * doesn't reload its old contents
3559  *
3560  * Returns:
3561  *  DD_OK on success
3562  *  See IWineD3DSurface::Restore for more details
3563  *
3564  *****************************************************************************/
3565 static HRESULT WINAPI ddraw_surface7_Restore(IDirectDrawSurface7 *iface)
3566 {
3567     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3568     HRESULT hr;
3569
3570     TRACE("iface %p.\n", iface);
3571
3572     wined3d_mutex_lock();
3573     hr = wined3d_surface_restore(surface->wined3d_surface);
3574     wined3d_mutex_unlock();
3575
3576     return hr;
3577 }
3578
3579 static HRESULT WINAPI ddraw_surface4_Restore(IDirectDrawSurface4 *iface)
3580 {
3581     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3582
3583     TRACE("iface %p.\n", iface);
3584
3585     return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3586 }
3587
3588 static HRESULT WINAPI ddraw_surface3_Restore(IDirectDrawSurface3 *iface)
3589 {
3590     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3591
3592     TRACE("iface %p.\n", iface);
3593
3594     return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3595 }
3596
3597 static HRESULT WINAPI ddraw_surface2_Restore(IDirectDrawSurface2 *iface)
3598 {
3599     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3600
3601     TRACE("iface %p.\n", iface);
3602
3603     return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3604 }
3605
3606 static HRESULT WINAPI ddraw_surface1_Restore(IDirectDrawSurface *iface)
3607 {
3608     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3609
3610     TRACE("iface %p.\n", iface);
3611
3612     return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3613 }
3614
3615 /*****************************************************************************
3616  * IDirectDrawSurface7::SetOverlayPosition
3617  *
3618  * Changes the display coordinates of an overlay surface
3619  *
3620  * Params:
3621  *  X:
3622  *  Y:
3623  *
3624  * Returns:
3625  *   DDERR_NOTAOVERLAYSURFACE, because we don't support overlays right now
3626  *****************************************************************************/
3627 static HRESULT WINAPI ddraw_surface7_SetOverlayPosition(IDirectDrawSurface7 *iface, LONG X, LONG Y)
3628 {
3629     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3630     HRESULT hr;
3631
3632     TRACE("iface %p, x %d, y %d.\n", iface, X, Y);
3633
3634     wined3d_mutex_lock();
3635     hr = wined3d_surface_set_overlay_position(surface->wined3d_surface, X, Y);
3636     wined3d_mutex_unlock();
3637
3638     return hr;
3639 }
3640
3641 static HRESULT WINAPI ddraw_surface4_SetOverlayPosition(IDirectDrawSurface4 *iface, LONG x, LONG y)
3642 {
3643     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3644
3645     TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3646
3647     return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3648 }
3649
3650 static HRESULT WINAPI ddraw_surface3_SetOverlayPosition(IDirectDrawSurface3 *iface, LONG x, LONG y)
3651 {
3652     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3653
3654     TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3655
3656     return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3657 }
3658
3659 static HRESULT WINAPI ddraw_surface2_SetOverlayPosition(IDirectDrawSurface2 *iface, LONG x, LONG y)
3660 {
3661     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3662
3663     TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3664
3665     return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3666 }
3667
3668 static HRESULT WINAPI ddraw_surface1_SetOverlayPosition(IDirectDrawSurface *iface, LONG x, LONG y)
3669 {
3670     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3671
3672     TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3673
3674     return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3675 }
3676
3677 /*****************************************************************************
3678  * IDirectDrawSurface7::UpdateOverlay
3679  *
3680  * Modifies the attributes of an overlay surface.
3681  *
3682  * Params:
3683  *  SrcRect: The section of the source being used for the overlay
3684  *  DstSurface: Address of the surface that is overlaid
3685  *  DstRect: Place of the overlay
3686  *  Flags: some DDOVER_* flags
3687  *
3688  * Returns:
3689  *  DDERR_UNSUPPORTED, because we don't support overlays
3690  *
3691  *****************************************************************************/
3692 static HRESULT WINAPI ddraw_surface7_UpdateOverlay(IDirectDrawSurface7 *iface, RECT *SrcRect,
3693         IDirectDrawSurface7 *DstSurface, RECT *DstRect, DWORD Flags, DDOVERLAYFX *FX)
3694 {
3695     struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface7(iface);
3696     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface7(DstSurface);
3697     HRESULT hr;
3698
3699     TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3700             iface, wine_dbgstr_rect(SrcRect), DstSurface, wine_dbgstr_rect(DstRect), Flags, FX);
3701
3702     wined3d_mutex_lock();
3703     hr = wined3d_surface_update_overlay(src_impl->wined3d_surface, SrcRect,
3704             dst_impl ? dst_impl->wined3d_surface : NULL, DstRect, Flags, (WINEDDOVERLAYFX *)FX);
3705     wined3d_mutex_unlock();
3706
3707     switch(hr) {
3708         case WINED3DERR_INVALIDCALL:        return DDERR_INVALIDPARAMS;
3709         case WINEDDERR_NOTAOVERLAYSURFACE:  return DDERR_NOTAOVERLAYSURFACE;
3710         case WINEDDERR_OVERLAYNOTVISIBLE:   return DDERR_OVERLAYNOTVISIBLE;
3711         default:
3712             return hr;
3713     }
3714 }
3715
3716 static HRESULT WINAPI ddraw_surface4_UpdateOverlay(IDirectDrawSurface4 *iface, RECT *src_rect,
3717         IDirectDrawSurface4 *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3718 {
3719     struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface4(iface);
3720     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface4(dst_surface);
3721
3722     TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3723             iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3724
3725     return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3726             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3727 }
3728
3729 static HRESULT WINAPI ddraw_surface3_UpdateOverlay(IDirectDrawSurface3 *iface, RECT *src_rect,
3730         IDirectDrawSurface3 *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3731 {
3732     struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface3(iface);
3733     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface3(dst_surface);
3734
3735     TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3736             iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3737
3738     return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3739             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3740 }
3741
3742 static HRESULT WINAPI ddraw_surface2_UpdateOverlay(IDirectDrawSurface2 *iface, RECT *src_rect,
3743         IDirectDrawSurface2 *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3744 {
3745     struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface2(iface);
3746     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface2(dst_surface);
3747
3748     TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3749             iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3750
3751     return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3752             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3753 }
3754
3755 static HRESULT WINAPI ddraw_surface1_UpdateOverlay(IDirectDrawSurface *iface, RECT *src_rect,
3756         IDirectDrawSurface *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3757 {
3758     struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface(iface);
3759     struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface(dst_surface);
3760
3761     TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3762             iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3763
3764     return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3765             dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3766 }
3767
3768 /*****************************************************************************
3769  * IDirectDrawSurface7::UpdateOverlayDisplay
3770  *
3771  * The DX7 sdk says that it's not implemented
3772  *
3773  * Params:
3774  *  Flags: ?
3775  *
3776  * Returns: DDERR_UNSUPPORTED, because we don't support overlays
3777  *
3778  *****************************************************************************/
3779 static HRESULT WINAPI ddraw_surface7_UpdateOverlayDisplay(IDirectDrawSurface7 *iface, DWORD Flags)
3780 {
3781     TRACE("iface %p, flags %#x.\n", iface, Flags);
3782
3783     return DDERR_UNSUPPORTED;
3784 }
3785
3786 static HRESULT WINAPI ddraw_surface4_UpdateOverlayDisplay(IDirectDrawSurface4 *iface, DWORD flags)
3787 {
3788     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3789
3790     TRACE("iface %p, flags %#x.\n", iface, flags);
3791
3792     return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3793 }
3794
3795 static HRESULT WINAPI ddraw_surface3_UpdateOverlayDisplay(IDirectDrawSurface3 *iface, DWORD flags)
3796 {
3797     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3798
3799     TRACE("iface %p, flags %#x.\n", iface, flags);
3800
3801     return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3802 }
3803
3804 static HRESULT WINAPI ddraw_surface2_UpdateOverlayDisplay(IDirectDrawSurface2 *iface, DWORD flags)
3805 {
3806     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3807
3808     TRACE("iface %p, flags %#x.\n", iface, flags);
3809
3810     return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3811 }
3812
3813 static HRESULT WINAPI ddraw_surface1_UpdateOverlayDisplay(IDirectDrawSurface *iface, DWORD flags)
3814 {
3815     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3816
3817     TRACE("iface %p, flags %#x.\n", iface, flags);
3818
3819     return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3820 }
3821
3822 /*****************************************************************************
3823  * IDirectDrawSurface7::UpdateOverlayZOrder
3824  *
3825  * Sets an overlay's Z order
3826  *
3827  * Params:
3828  *  Flags: DDOVERZ_* flags
3829  *  DDSRef: Defines the relative position in the overlay chain
3830  *
3831  * Returns:
3832  *  DDERR_NOTOVERLAYSURFACE, because we don't support overlays
3833  *
3834  *****************************************************************************/
3835 static HRESULT WINAPI ddraw_surface7_UpdateOverlayZOrder(IDirectDrawSurface7 *iface,
3836         DWORD Flags, IDirectDrawSurface7 *DDSRef)
3837 {
3838     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3839     struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface7(DDSRef);
3840     HRESULT hr;
3841
3842     TRACE("iface %p, flags %#x, reference %p.\n", iface, Flags, DDSRef);
3843
3844     wined3d_mutex_lock();
3845     hr = wined3d_surface_update_overlay_z_order(surface->wined3d_surface,
3846             Flags, reference_impl ? reference_impl->wined3d_surface : NULL);
3847     wined3d_mutex_unlock();
3848
3849     return hr;
3850 }
3851
3852 static HRESULT WINAPI ddraw_surface4_UpdateOverlayZOrder(IDirectDrawSurface4 *iface,
3853         DWORD flags, IDirectDrawSurface4 *reference)
3854 {
3855     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3856     struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface4(reference);
3857
3858     TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3859
3860     return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3861             reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3862 }
3863
3864 static HRESULT WINAPI ddraw_surface3_UpdateOverlayZOrder(IDirectDrawSurface3 *iface,
3865         DWORD flags, IDirectDrawSurface3 *reference)
3866 {
3867     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3868     struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface3(reference);
3869
3870     TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3871
3872     return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3873             reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3874 }
3875
3876 static HRESULT WINAPI ddraw_surface2_UpdateOverlayZOrder(IDirectDrawSurface2 *iface,
3877         DWORD flags, IDirectDrawSurface2 *reference)
3878 {
3879     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3880     struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface2(reference);
3881
3882     TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3883
3884     return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3885             reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3886 }
3887
3888 static HRESULT WINAPI ddraw_surface1_UpdateOverlayZOrder(IDirectDrawSurface *iface,
3889         DWORD flags, IDirectDrawSurface *reference)
3890 {
3891     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3892     struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface(reference);
3893
3894     TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3895
3896     return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3897             reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3898 }
3899
3900 /*****************************************************************************
3901  * IDirectDrawSurface7::GetDDInterface
3902  *
3903  * Returns the IDirectDraw7 interface pointer of the DirectDraw object this
3904  * surface belongs to
3905  *
3906  * Params:
3907  *  DD: Address to write the interface pointer to
3908  *
3909  * Returns:
3910  *  DD_OK on success
3911  *  DDERR_INVALIDPARAMS if DD is NULL
3912  *
3913  *****************************************************************************/
3914 static HRESULT WINAPI ddraw_surface7_GetDDInterface(IDirectDrawSurface7 *iface, void **DD)
3915 {
3916     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
3917
3918     TRACE("iface %p, ddraw %p.\n", iface, DD);
3919
3920     if(!DD)
3921         return DDERR_INVALIDPARAMS;
3922
3923     switch(This->version)
3924     {
3925         case 7:
3926             *DD = &This->ddraw->IDirectDraw7_iface;
3927             break;
3928
3929         case 4:
3930             *DD = &This->ddraw->IDirectDraw4_iface;
3931             break;
3932
3933         case 2:
3934             *DD = &This->ddraw->IDirectDraw2_iface;
3935             break;
3936
3937         case 1:
3938             *DD = &This->ddraw->IDirectDraw_iface;
3939             break;
3940
3941     }
3942     IUnknown_AddRef((IUnknown *)*DD);
3943
3944     return DD_OK;
3945 }
3946
3947 static HRESULT WINAPI ddraw_surface4_GetDDInterface(IDirectDrawSurface4 *iface, void **ddraw)
3948 {
3949     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3950
3951     TRACE("iface %p, ddraw %p.\n", iface, ddraw);
3952
3953     return ddraw_surface7_GetDDInterface(&surface->IDirectDrawSurface7_iface, ddraw);
3954 }
3955
3956 static HRESULT WINAPI ddraw_surface3_GetDDInterface(IDirectDrawSurface3 *iface, void **ddraw)
3957 {
3958     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3959
3960     TRACE("iface %p, ddraw %p.\n", iface, ddraw);
3961
3962     return ddraw_surface7_GetDDInterface(&surface->IDirectDrawSurface7_iface, ddraw);
3963 }
3964
3965 static HRESULT WINAPI ddraw_surface2_GetDDInterface(IDirectDrawSurface2 *iface, void **ddraw)
3966 {
3967     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3968
3969     TRACE("iface %p, ddraw %p.\n", iface, ddraw);
3970
3971     return ddraw_surface7_GetDDInterface(&surface->IDirectDrawSurface7_iface, ddraw);
3972 }
3973
3974 static HRESULT WINAPI ddraw_surface7_ChangeUniquenessValue(IDirectDrawSurface7 *iface)
3975 {
3976     TRACE("iface %p.\n", iface);
3977
3978     return DD_OK;
3979 }
3980
3981 static HRESULT WINAPI ddraw_surface4_ChangeUniquenessValue(IDirectDrawSurface4 *iface)
3982 {
3983     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3984
3985     TRACE("iface %p.\n", iface);
3986
3987     return ddraw_surface7_ChangeUniquenessValue(&surface->IDirectDrawSurface7_iface);
3988 }
3989
3990 static HRESULT WINAPI ddraw_surface7_GetUniquenessValue(IDirectDrawSurface7 *iface, DWORD *pValue)
3991 {
3992     TRACE("iface %p, value %p.\n", iface, pValue);
3993
3994     *pValue = 0;
3995
3996     return DD_OK;
3997 }
3998
3999 static HRESULT WINAPI ddraw_surface4_GetUniquenessValue(IDirectDrawSurface4 *iface, DWORD *pValue)
4000 {
4001     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4002
4003     TRACE("iface %p, value %p.\n", iface, pValue);
4004
4005     return ddraw_surface7_GetUniquenessValue(&surface->IDirectDrawSurface7_iface, pValue);
4006 }
4007
4008 /*****************************************************************************
4009  * IDirectDrawSurface7::SetLOD
4010  *
4011  * Sets the level of detail of a texture
4012  *
4013  * Params:
4014  *  MaxLOD: LOD to set
4015  *
4016  * Returns:
4017  *  DD_OK on success
4018  *  DDERR_INVALIDOBJECT if the surface is invalid for this method
4019  *
4020  *****************************************************************************/
4021 static HRESULT WINAPI ddraw_surface7_SetLOD(IDirectDrawSurface7 *iface, DWORD MaxLOD)
4022 {
4023     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4024     HRESULT hr;
4025
4026     TRACE("iface %p, lod %u.\n", iface, MaxLOD);
4027
4028     wined3d_mutex_lock();
4029     if (!(surface->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_TEXTUREMANAGE))
4030     {
4031         wined3d_mutex_unlock();
4032         return DDERR_INVALIDOBJECT;
4033     }
4034
4035     if (!surface->wined3d_texture)
4036     {
4037         ERR("The ddraw surface has no wined3d texture.\n");
4038         wined3d_mutex_unlock();
4039         return DDERR_INVALIDOBJECT;
4040     }
4041
4042     hr = wined3d_texture_set_lod(surface->wined3d_texture, MaxLOD);
4043     wined3d_mutex_unlock();
4044
4045     return hr;
4046 }
4047
4048 /*****************************************************************************
4049  * IDirectDrawSurface7::GetLOD
4050  *
4051  * Returns the level of detail of a Direct3D texture
4052  *
4053  * Params:
4054  *  MaxLOD: Address to write the LOD to
4055  *
4056  * Returns:
4057  *  DD_OK on success
4058  *  DDERR_INVALIDPARAMS if MaxLOD is NULL
4059  *  DDERR_INVALIDOBJECT if the surface is invalid for this method
4060  *
4061  *****************************************************************************/
4062 static HRESULT WINAPI ddraw_surface7_GetLOD(IDirectDrawSurface7 *iface, DWORD *MaxLOD)
4063 {
4064     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4065
4066     TRACE("iface %p, lod %p.\n", iface, MaxLOD);
4067
4068     if(!MaxLOD)
4069         return DDERR_INVALIDPARAMS;
4070
4071     wined3d_mutex_lock();
4072     if (!(surface->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_TEXTUREMANAGE))
4073     {
4074         wined3d_mutex_unlock();
4075         return DDERR_INVALIDOBJECT;
4076     }
4077
4078     *MaxLOD = wined3d_texture_get_lod(surface->wined3d_texture);
4079     wined3d_mutex_unlock();
4080
4081     return DD_OK;
4082 }
4083
4084 /*****************************************************************************
4085  * IDirectDrawSurface7::BltFast
4086  *
4087  * Performs a fast Blit.
4088  *
4089  * Params:
4090  *  dstx: The x coordinate to blit to on the destination
4091  *  dsty: The y coordinate to blit to on the destination
4092  *  Source: The source surface
4093  *  rsrc: The source rectangle
4094  *  trans: Type of transfer. Some DDBLTFAST_* flags
4095  *
4096  * Returns:
4097  *  DD_OK on success
4098  *  For more details, see IWineD3DSurface::BltFast
4099  *
4100  *****************************************************************************/
4101 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface7_BltFast(IDirectDrawSurface7 *iface, DWORD dstx, DWORD dsty,
4102         IDirectDrawSurface7 *Source, RECT *rsrc, DWORD trans)
4103 {
4104     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
4105     struct ddraw_surface *src = unsafe_impl_from_IDirectDrawSurface7(Source);
4106     DWORD src_w, src_h, dst_w, dst_h;
4107     HRESULT hr = DD_OK;
4108     DWORD flags = 0;
4109     RECT dst_rect;
4110
4111     TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4112             iface, dstx, dsty, Source, wine_dbgstr_rect(rsrc), trans);
4113
4114     dst_w = This->surface_desc.dwWidth;
4115     dst_h = This->surface_desc.dwHeight;
4116
4117     /* Source must be != NULL, This is not checked by windows. Windows happily throws a 0xc0000005
4118      * in that case
4119      */
4120     if(rsrc)
4121     {
4122         src_w = rsrc->right - rsrc->left;
4123         src_h = rsrc->bottom - rsrc->top;
4124     }
4125     else
4126     {
4127         src_w = src->surface_desc.dwWidth;
4128         src_h = src->surface_desc.dwHeight;
4129     }
4130
4131     if (src_w > dst_w || dstx > dst_w - src_w
4132             || src_h > dst_h || dsty > dst_h - src_h)
4133     {
4134         WARN("Destination area out of bounds, returning DDERR_INVALIDRECT.\n");
4135         return DDERR_INVALIDRECT;
4136     }
4137
4138     SetRect(&dst_rect, dstx, dsty, dstx + src_w, dsty + src_h);
4139     if (trans & DDBLTFAST_SRCCOLORKEY)
4140         flags |= WINEDDBLT_KEYSRC;
4141     if (trans & DDBLTFAST_DESTCOLORKEY)
4142         flags |= WINEDDBLT_KEYDEST;
4143     if (trans & DDBLTFAST_WAIT)
4144         flags |= WINEDDBLT_WAIT;
4145     if (trans & DDBLTFAST_DONOTWAIT)
4146         flags |= WINEDDBLT_DONOTWAIT;
4147
4148     wined3d_mutex_lock();
4149     if (This->clipper)
4150     {
4151         wined3d_mutex_unlock();
4152         WARN("Destination surface has a clipper set, returning DDERR_BLTFASTCANTCLIP.\n");
4153         return DDERR_BLTFASTCANTCLIP;
4154     }
4155
4156     if (src->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
4157         hr = ddraw_surface_update_frontbuffer(src, rsrc, TRUE);
4158     if (SUCCEEDED(hr))
4159         hr = wined3d_surface_blt(This->wined3d_surface, &dst_rect,
4160                 src->wined3d_surface, rsrc, flags, NULL, WINED3D_TEXF_POINT);
4161     if (SUCCEEDED(hr) && (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
4162         hr = ddraw_surface_update_frontbuffer(This, &dst_rect, FALSE);
4163     wined3d_mutex_unlock();
4164
4165     switch(hr)
4166     {
4167         case WINED3DERR_NOTAVAILABLE:           return DDERR_UNSUPPORTED;
4168         case WINED3DERR_WRONGTEXTUREFORMAT:     return DDERR_INVALIDPIXELFORMAT;
4169         default:                                return hr;
4170     }
4171 }
4172
4173 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface4_BltFast(IDirectDrawSurface4 *iface, DWORD dst_x, DWORD dst_y,
4174         IDirectDrawSurface4 *src_surface, RECT *src_rect, DWORD flags)
4175 {
4176     struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface4(iface);
4177     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface4(src_surface);
4178
4179     TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4180             iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4181
4182     return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4183             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4184 }
4185
4186 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface3_BltFast(IDirectDrawSurface3 *iface, DWORD dst_x, DWORD dst_y,
4187         IDirectDrawSurface3 *src_surface, RECT *src_rect, DWORD flags)
4188 {
4189     struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface3(iface);
4190     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface3(src_surface);
4191
4192     TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4193             iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4194
4195     return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4196             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4197 }
4198
4199 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface2_BltFast(IDirectDrawSurface2 *iface, DWORD dst_x, DWORD dst_y,
4200         IDirectDrawSurface2 *src_surface, RECT *src_rect, DWORD flags)
4201 {
4202     struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface2(iface);
4203     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface2(src_surface);
4204
4205     TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4206             iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4207
4208     return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4209             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4210 }
4211
4212 static HRESULT WINAPI DECLSPEC_HOTPATCH ddraw_surface1_BltFast(IDirectDrawSurface *iface, DWORD dst_x, DWORD dst_y,
4213         IDirectDrawSurface *src_surface, RECT *src_rect, DWORD flags)
4214 {
4215     struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface(iface);
4216     struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src_surface);
4217
4218     TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4219             iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4220
4221     return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4222             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4223 }
4224
4225 /*****************************************************************************
4226  * IDirectDrawSurface7::GetClipper
4227  *
4228  * Returns the IDirectDrawClipper interface of the clipper assigned to this
4229  * surface
4230  *
4231  * Params:
4232  *  Clipper: Address to store the interface pointer at
4233  *
4234  * Returns:
4235  *  DD_OK on success
4236  *  DDERR_INVALIDPARAMS if Clipper is NULL
4237  *  DDERR_NOCLIPPERATTACHED if there's no clipper attached
4238  *
4239  *****************************************************************************/
4240 static HRESULT WINAPI ddraw_surface7_GetClipper(IDirectDrawSurface7 *iface, IDirectDrawClipper **Clipper)
4241 {
4242     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4243
4244     TRACE("iface %p, clipper %p.\n", iface, Clipper);
4245
4246     if (!Clipper)
4247         return DDERR_INVALIDPARAMS;
4248
4249     wined3d_mutex_lock();
4250     if (!surface->clipper)
4251     {
4252         wined3d_mutex_unlock();
4253         return DDERR_NOCLIPPERATTACHED;
4254     }
4255
4256     *Clipper = (IDirectDrawClipper *)surface->clipper;
4257     IDirectDrawClipper_AddRef(*Clipper);
4258     wined3d_mutex_unlock();
4259
4260     return DD_OK;
4261 }
4262
4263 static HRESULT WINAPI ddraw_surface4_GetClipper(IDirectDrawSurface4 *iface, IDirectDrawClipper **clipper)
4264 {
4265     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4266
4267     TRACE("iface %p, clipper %p.\n", iface, clipper);
4268
4269     return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4270 }
4271
4272 static HRESULT WINAPI ddraw_surface3_GetClipper(IDirectDrawSurface3 *iface, IDirectDrawClipper **clipper)
4273 {
4274     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4275
4276     TRACE("iface %p, clipper %p.\n", iface, clipper);
4277
4278     return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4279 }
4280
4281 static HRESULT WINAPI ddraw_surface2_GetClipper(IDirectDrawSurface2 *iface, IDirectDrawClipper **clipper)
4282 {
4283     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4284
4285     TRACE("iface %p, clipper %p.\n", iface, clipper);
4286
4287     return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4288 }
4289
4290 static HRESULT WINAPI ddraw_surface1_GetClipper(IDirectDrawSurface *iface, IDirectDrawClipper **clipper)
4291 {
4292     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4293
4294     TRACE("iface %p, clipper %p.\n", iface, clipper);
4295
4296     return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4297 }
4298
4299 /*****************************************************************************
4300  * IDirectDrawSurface7::SetClipper
4301  *
4302  * Sets a clipper for the surface
4303  *
4304  * Params:
4305  *  Clipper: IDirectDrawClipper interface of the clipper to set
4306  *
4307  * Returns:
4308  *  DD_OK on success
4309  *
4310  *****************************************************************************/
4311 static HRESULT WINAPI ddraw_surface7_SetClipper(IDirectDrawSurface7 *iface,
4312         IDirectDrawClipper *iclipper)
4313 {
4314     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
4315     struct ddraw_clipper *clipper = unsafe_impl_from_IDirectDrawClipper(iclipper);
4316     struct ddraw_clipper *old_clipper = This->clipper;
4317     HWND clipWindow;
4318
4319     TRACE("iface %p, clipper %p.\n", iface, iclipper);
4320
4321     wined3d_mutex_lock();
4322     if (clipper == This->clipper)
4323     {
4324         wined3d_mutex_unlock();
4325         return DD_OK;
4326     }
4327
4328     This->clipper = clipper;
4329
4330     if (clipper != NULL)
4331         IDirectDrawClipper_AddRef(iclipper);
4332     if (old_clipper)
4333         IDirectDrawClipper_Release(&old_clipper->IDirectDrawClipper_iface);
4334
4335     if ((This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) && This->ddraw->wined3d_swapchain)
4336     {
4337         clipWindow = NULL;
4338         if(clipper) {
4339             IDirectDrawClipper_GetHWnd(iclipper, &clipWindow);
4340         }
4341
4342         if (clipWindow)
4343         {
4344             wined3d_swapchain_set_window(This->ddraw->wined3d_swapchain, clipWindow);
4345             ddraw_set_swapchain_window(This->ddraw, clipWindow);
4346         }
4347         else
4348         {
4349             wined3d_swapchain_set_window(This->ddraw->wined3d_swapchain, This->ddraw->d3d_window);
4350             ddraw_set_swapchain_window(This->ddraw, This->ddraw->dest_window);
4351         }
4352     }
4353
4354     wined3d_mutex_unlock();
4355
4356     return DD_OK;
4357 }
4358
4359 static HRESULT WINAPI ddraw_surface4_SetClipper(IDirectDrawSurface4 *iface, IDirectDrawClipper *clipper)
4360 {
4361     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4362
4363     TRACE("iface %p, clipper %p.\n", iface, clipper);
4364
4365     return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4366 }
4367
4368 static HRESULT WINAPI ddraw_surface3_SetClipper(IDirectDrawSurface3 *iface, IDirectDrawClipper *clipper)
4369 {
4370     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4371
4372     TRACE("iface %p, clipper %p.\n", iface, clipper);
4373
4374     return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4375 }
4376
4377 static HRESULT WINAPI ddraw_surface2_SetClipper(IDirectDrawSurface2 *iface, IDirectDrawClipper *clipper)
4378 {
4379     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4380
4381     TRACE("iface %p, clipper %p.\n", iface, clipper);
4382
4383     return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4384 }
4385
4386 static HRESULT WINAPI ddraw_surface1_SetClipper(IDirectDrawSurface *iface, IDirectDrawClipper *clipper)
4387 {
4388     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4389
4390     TRACE("iface %p, clipper %p.\n", iface, clipper);
4391
4392     return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4393 }
4394
4395 /*****************************************************************************
4396  * IDirectDrawSurface7::SetSurfaceDesc
4397  *
4398  * Sets the surface description. It can override the pixel format, the surface
4399  * memory, ...
4400  * It's not really tested.
4401  *
4402  * Params:
4403  * DDSD: Pointer to the new surface description to set
4404  * Flags: Some flags
4405  *
4406  * Returns:
4407  *  DD_OK on success
4408  *  DDERR_INVALIDPARAMS if DDSD is NULL
4409  *
4410  *****************************************************************************/
4411 static HRESULT WINAPI ddraw_surface7_SetSurfaceDesc(IDirectDrawSurface7 *iface, DDSURFACEDESC2 *DDSD, DWORD Flags)
4412 {
4413     struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
4414     HRESULT hr;
4415     const DWORD allowed_flags = DDSD_LPSURFACE | DDSD_PIXELFORMAT | DDSD_WIDTH
4416             | DDSD_HEIGHT | DDSD_PITCH | DDSD_CAPS;
4417     enum wined3d_format_id format_id;
4418     UINT pitch, width, height;
4419
4420     TRACE("iface %p, surface_desc %p, flags %#x.\n", iface, DDSD, Flags);
4421
4422     if (!DDSD)
4423     {
4424         WARN("DDSD is NULL, returning DDERR_INVALIDPARAMS\n");
4425         return DDERR_INVALIDPARAMS;
4426     }
4427     if (Flags)
4428     {
4429         WARN("Flags is %x, returning DDERR_INVALIDPARAMS\n", Flags);
4430         return DDERR_INVALIDPARAMS;
4431     }
4432     if (!(This->surface_desc.ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
4433             || This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE
4434             || This->surface_desc.ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
4435     {
4436         WARN("Surface is not in system memory, returning DDERR_INVALIDSURFACETYPE.\n");
4437         return DDERR_INVALIDSURFACETYPE;
4438     }
4439
4440     /* Tests show that only LPSURFACE and PIXELFORMAT can be set, and LPSURFACE is required
4441      * for PIXELFORMAT to work */
4442     if (DDSD->dwFlags & ~allowed_flags)
4443     {
4444         WARN("Invalid flags (0x%08x) set, returning DDERR_INVALIDPARAMS\n", DDSD->dwFlags);
4445         return DDERR_INVALIDPARAMS;
4446     }
4447     if (!(DDSD->dwFlags & DDSD_LPSURFACE) || !DDSD->lpSurface)
4448     {
4449         WARN("DDSD_LPSURFACE is not set or lpSurface is NULL, returning DDERR_INVALIDPARAMS\n");
4450         return DDERR_INVALIDPARAMS;
4451     }
4452     if ((DDSD->dwFlags & DDSD_CAPS) && DDSD->ddsCaps.dwCaps)
4453     {
4454         WARN("DDSD_CAPS is set, returning DDERR_INVALIDCAPS.\n");
4455         return DDERR_INVALIDCAPS;
4456     }
4457     if (DDSD->dwFlags & DDSD_WIDTH)
4458     {
4459         if (!(DDSD->dwFlags & DDSD_PITCH))
4460         {
4461             WARN("DDSD_WIDTH is set, but DDSD_PITCH is not, returning DDERR_INVALIDPARAMS.\n");
4462             return DDERR_INVALIDPARAMS;
4463         }
4464         if (!DDSD->dwWidth || DDSD->u1.lPitch <= 0 || DDSD->u1.lPitch & 0x3)
4465         {
4466             WARN("Pitch is %d, width is %u, returning DDERR_INVALIDPARAMS.\n",
4467                     DDSD->u1.lPitch, DDSD->dwWidth);
4468             return DDERR_INVALIDPARAMS;
4469         }
4470         if (DDSD->dwWidth != This->surface_desc.dwWidth)
4471             TRACE("Surface width changed from %u to %u.\n", This->surface_desc.dwWidth, DDSD->dwWidth);
4472         if (DDSD->u1.lPitch != This->surface_desc.u1.lPitch)
4473             TRACE("Surface pitch changed from %u to %u.\n", This->surface_desc.u1.lPitch, DDSD->u1.lPitch);
4474         pitch = DDSD->u1.lPitch;
4475         width = DDSD->dwWidth;
4476     }
4477     else if (DDSD->dwFlags & DDSD_PITCH)
4478     {
4479         WARN("DDSD_PITCH is set, but DDSD_WIDTH is not, returning DDERR_INVALIDPARAMS.\n");
4480         return DDERR_INVALIDPARAMS;
4481     }
4482     else
4483     {
4484         pitch = This->surface_desc.u1.lPitch;
4485         width = This->surface_desc.dwWidth;
4486     }
4487
4488     if (DDSD->dwFlags & DDSD_HEIGHT)
4489     {
4490         if (!DDSD->dwHeight)
4491         {
4492             WARN("Height is 0, returning DDERR_INVALIDPARAMS.\n");
4493             return DDERR_INVALIDPARAMS;
4494         }
4495         if (DDSD->dwHeight != This->surface_desc.dwHeight)
4496             TRACE("Surface height changed from %u to %u.\n", This->surface_desc.dwHeight, DDSD->dwHeight);
4497         height = DDSD->dwHeight;
4498     }
4499     else
4500     {
4501         height = This->surface_desc.dwHeight;
4502     }
4503
4504     wined3d_mutex_lock();
4505     if (DDSD->dwFlags & DDSD_PIXELFORMAT)
4506     {
4507         enum wined3d_format_id current_format_id;
4508         format_id = wined3dformat_from_ddrawformat(&DDSD->u4.ddpfPixelFormat);
4509
4510         if (format_id == WINED3DFMT_UNKNOWN)
4511         {
4512             ERR("Requested to set an unknown pixelformat\n");
4513             wined3d_mutex_unlock();
4514             return DDERR_INVALIDPARAMS;
4515         }
4516         current_format_id = wined3dformat_from_ddrawformat(&This->surface_desc.u4.ddpfPixelFormat);
4517         if (format_id != current_format_id)
4518             TRACE("Surface format changed from %#x to %#x.\n", current_format_id, format_id);
4519     }
4520     else
4521     {
4522         format_id = wined3dformat_from_ddrawformat(&This->surface_desc.u4.ddpfPixelFormat);
4523     }
4524
4525     if (FAILED(hr = wined3d_texture_update_desc(This->wined3d_texture, width, height,
4526             format_id, WINED3D_MULTISAMPLE_NONE, 0, DDSD->lpSurface, pitch)))
4527     {
4528         WARN("Failed to update surface desc, hr %#x.\n", hr);
4529         wined3d_mutex_unlock();
4530         return hr_ddraw_from_wined3d(hr);
4531     }
4532
4533     if (DDSD->dwFlags & DDSD_WIDTH)
4534         This->surface_desc.dwWidth = width;
4535     if (DDSD->dwFlags & DDSD_PITCH)
4536         This->surface_desc.u1.lPitch = DDSD->u1.lPitch;
4537     if (DDSD->dwFlags & DDSD_HEIGHT)
4538         This->surface_desc.dwHeight = height;
4539     if (DDSD->dwFlags & DDSD_PIXELFORMAT)
4540         This->surface_desc.u4.ddpfPixelFormat = DDSD->u4.ddpfPixelFormat;
4541
4542     wined3d_mutex_unlock();
4543
4544     return DD_OK;
4545 }
4546
4547 static HRESULT WINAPI ddraw_surface4_SetSurfaceDesc(IDirectDrawSurface4 *iface,
4548         DDSURFACEDESC2 *surface_desc, DWORD flags)
4549 {
4550     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4551
4552     TRACE("iface %p, surface_desc %p, flags %#x.\n", iface, surface_desc, flags);
4553
4554     return ddraw_surface7_SetSurfaceDesc(&surface->IDirectDrawSurface7_iface,
4555             surface_desc, flags);
4556 }
4557
4558 static HRESULT WINAPI ddraw_surface3_SetSurfaceDesc(IDirectDrawSurface3 *iface,
4559         DDSURFACEDESC *surface_desc, DWORD flags)
4560 {
4561     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4562     DDSURFACEDESC2 surface_desc2;
4563
4564     TRACE("iface %p, surface_desc %p, flags %#x.\n", iface, surface_desc, flags);
4565
4566     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
4567     return ddraw_surface7_SetSurfaceDesc(&surface->IDirectDrawSurface7_iface,
4568             surface_desc ? &surface_desc2 : NULL, flags);
4569 }
4570
4571 static HRESULT WINAPI ddraw_surface7_GetPalette(IDirectDrawSurface7 *iface, IDirectDrawPalette **palette)
4572 {
4573     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4574     struct ddraw_palette *palette_impl;
4575     HRESULT hr = DD_OK;
4576
4577     TRACE("iface %p, palette %p.\n", iface, palette);
4578
4579     if (!palette)
4580         return DDERR_INVALIDPARAMS;
4581     if (IDirectDrawSurface7_IsLost(iface) == DDERR_SURFACELOST)
4582     {
4583         WARN("Surface lost, returning DDERR_SURFACELOST.\n");
4584         return DDERR_SURFACELOST;
4585     }
4586
4587     wined3d_mutex_lock();
4588     if ((palette_impl = surface->palette))
4589     {
4590         *palette = &palette_impl->IDirectDrawPalette_iface;
4591         IDirectDrawPalette_AddRef(*palette);
4592     }
4593     else
4594     {
4595         *palette = NULL;
4596         hr = DDERR_NOPALETTEATTACHED;
4597     }
4598     wined3d_mutex_unlock();
4599
4600     return hr;
4601 }
4602
4603 static HRESULT WINAPI ddraw_surface4_GetPalette(IDirectDrawSurface4 *iface, IDirectDrawPalette **palette)
4604 {
4605     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4606
4607     TRACE("iface %p, palette %p.\n", iface, palette);
4608
4609     return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4610 }
4611
4612 static HRESULT WINAPI ddraw_surface3_GetPalette(IDirectDrawSurface3 *iface, IDirectDrawPalette **palette)
4613 {
4614     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4615
4616     TRACE("iface %p, palette %p.\n", iface, palette);
4617
4618     return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4619 }
4620
4621 static HRESULT WINAPI ddraw_surface2_GetPalette(IDirectDrawSurface2 *iface, IDirectDrawPalette **palette)
4622 {
4623     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4624
4625     TRACE("iface %p, palette %p.\n", iface, palette);
4626
4627     return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4628 }
4629
4630 static HRESULT WINAPI ddraw_surface1_GetPalette(IDirectDrawSurface *iface, IDirectDrawPalette **palette)
4631 {
4632     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4633
4634     TRACE("iface %p, palette %p.\n", iface, palette);
4635
4636     return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4637 }
4638
4639 static HRESULT ddraw_surface_set_color_key(struct ddraw_surface *surface, DWORD flags, DDCOLORKEY *color_key)
4640 {
4641     DDCOLORKEY fixed_color_key;
4642     HRESULT hr = WINED3D_OK;
4643
4644     wined3d_mutex_lock();
4645
4646     if (color_key)
4647     {
4648         fixed_color_key = *color_key;
4649         /* Handle case where dwColorSpaceHighValue < dwColorSpaceLowValue */
4650         if (fixed_color_key.dwColorSpaceHighValue < fixed_color_key.dwColorSpaceLowValue)
4651             fixed_color_key.dwColorSpaceHighValue = fixed_color_key.dwColorSpaceLowValue;
4652
4653         switch (flags & ~DDCKEY_COLORSPACE)
4654         {
4655             case DDCKEY_DESTBLT:
4656                 surface->surface_desc.ddckCKDestBlt = fixed_color_key;
4657                 surface->surface_desc.dwFlags |= DDSD_CKDESTBLT;
4658                 break;
4659
4660             case DDCKEY_DESTOVERLAY:
4661                 surface->surface_desc.u3.ddckCKDestOverlay = fixed_color_key;
4662                 surface->surface_desc.dwFlags |= DDSD_CKDESTOVERLAY;
4663                 break;
4664
4665             case DDCKEY_SRCOVERLAY:
4666                 surface->surface_desc.ddckCKSrcOverlay = fixed_color_key;
4667                 surface->surface_desc.dwFlags |= DDSD_CKSRCOVERLAY;
4668                 break;
4669
4670             case DDCKEY_SRCBLT:
4671                 surface->surface_desc.ddckCKSrcBlt = fixed_color_key;
4672                 surface->surface_desc.dwFlags |= DDSD_CKSRCBLT;
4673                 break;
4674
4675             default:
4676                 wined3d_mutex_unlock();
4677                 return DDERR_INVALIDPARAMS;
4678         }
4679     }
4680     else
4681     {
4682         switch (flags & ~DDCKEY_COLORSPACE)
4683         {
4684             case DDCKEY_DESTBLT:
4685                 surface->surface_desc.dwFlags &= ~DDSD_CKDESTBLT;
4686                 break;
4687
4688             case DDCKEY_DESTOVERLAY:
4689                 surface->surface_desc.dwFlags &= ~DDSD_CKDESTOVERLAY;
4690                 break;
4691
4692             case DDCKEY_SRCOVERLAY:
4693                 surface->surface_desc.dwFlags &= ~DDSD_CKSRCOVERLAY;
4694                 break;
4695
4696             case DDCKEY_SRCBLT:
4697                 surface->surface_desc.dwFlags &= ~DDSD_CKSRCBLT;
4698                 break;
4699
4700             default:
4701                 wined3d_mutex_unlock();
4702                 return DDERR_INVALIDPARAMS;
4703         }
4704     }
4705
4706     if (surface->wined3d_texture)
4707         hr = wined3d_texture_set_color_key(surface->wined3d_texture, flags,
4708                 color_key ? (struct wined3d_color_key *)&fixed_color_key : NULL);
4709
4710     wined3d_mutex_unlock();
4711
4712     return hr_ddraw_from_wined3d(hr);
4713 }
4714
4715 static HRESULT WINAPI ddraw_surface7_SetColorKey(IDirectDrawSurface7 *iface, DWORD flags, DDCOLORKEY *color_key)
4716 {
4717     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4718
4719     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4720
4721     wined3d_mutex_lock();
4722     if (!surface->wined3d_texture)
4723     {
4724         wined3d_mutex_unlock();
4725         return DDERR_NOTONMIPMAPSUBLEVEL;
4726     }
4727     wined3d_mutex_unlock();
4728
4729     return ddraw_surface_set_color_key(surface, flags, color_key);
4730 }
4731
4732 static HRESULT WINAPI ddraw_surface4_SetColorKey(IDirectDrawSurface4 *iface, DWORD flags, DDCOLORKEY *color_key)
4733 {
4734     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4735
4736     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4737
4738     return ddraw_surface_set_color_key(surface, flags, color_key);
4739 }
4740
4741 static HRESULT WINAPI ddraw_surface3_SetColorKey(IDirectDrawSurface3 *iface, DWORD flags, DDCOLORKEY *color_key)
4742 {
4743     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4744
4745     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4746
4747     return ddraw_surface_set_color_key(surface, flags, color_key);
4748 }
4749
4750 static HRESULT WINAPI ddraw_surface2_SetColorKey(IDirectDrawSurface2 *iface, DWORD flags, DDCOLORKEY *color_key)
4751 {
4752     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4753
4754     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4755
4756     return ddraw_surface_set_color_key(surface, flags, color_key);
4757 }
4758
4759 static HRESULT WINAPI ddraw_surface1_SetColorKey(IDirectDrawSurface *iface, DWORD flags, DDCOLORKEY *color_key)
4760 {
4761     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4762
4763     TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4764
4765     return ddraw_surface_set_color_key(surface, flags, color_key);
4766 }
4767
4768 static HRESULT WINAPI ddraw_surface7_SetPalette(IDirectDrawSurface7 *iface, IDirectDrawPalette *palette)
4769 {
4770     struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4771
4772     TRACE("iface %p, palette %p.\n", iface, palette);
4773
4774     if (surface->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_MIPMAPSUBLEVEL)
4775         return DDERR_NOTONMIPMAPSUBLEVEL;
4776     if (IDirectDrawSurface7_IsLost(iface) == DDERR_SURFACELOST)
4777     {
4778         WARN("Surface lost, returning DDERR_SURFACELOST.\n");
4779         return DDERR_SURFACELOST;
4780     }
4781
4782     return ddraw_surface_set_palette(surface, palette);
4783 }
4784
4785 static HRESULT WINAPI ddraw_surface4_SetPalette(IDirectDrawSurface4 *iface, IDirectDrawPalette *palette)
4786 {
4787     struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4788
4789     TRACE("iface %p, palette %p.\n", iface, palette);
4790
4791     if (IDirectDrawSurface4_IsLost(iface) == DDERR_SURFACELOST)
4792     {
4793         WARN("Surface lost, returning DDERR_SURFACELOST.\n");
4794         return DDERR_SURFACELOST;
4795     }
4796
4797     return ddraw_surface_set_palette(surface, palette);
4798 }
4799
4800 static HRESULT WINAPI ddraw_surface3_SetPalette(IDirectDrawSurface3 *iface, IDirectDrawPalette *palette)
4801 {
4802     struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4803
4804     TRACE("iface %p, palette %p.\n", iface, palette);
4805
4806     if (IDirectDrawSurface3_IsLost(iface) == DDERR_SURFACELOST)
4807     {
4808         WARN("Surface lost, returning DDERR_SURFACELOST.\n");
4809         return DDERR_SURFACELOST;
4810     }
4811
4812     return ddraw_surface_set_palette(surface, palette);
4813 }
4814
4815 static HRESULT WINAPI ddraw_surface2_SetPalette(IDirectDrawSurface2 *iface, IDirectDrawPalette *palette)
4816 {
4817     struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4818
4819     TRACE("iface %p, palette %p.\n", iface, palette);
4820
4821     if (IDirectDrawSurface2_IsLost(iface) == DDERR_SURFACELOST)
4822     {
4823         WARN("Surface lost, returning DDERR_SURFACELOST.\n");
4824         return DDERR_SURFACELOST;
4825     }
4826
4827     return ddraw_surface_set_palette(surface, palette);
4828 }
4829
4830 static HRESULT WINAPI ddraw_surface1_SetPalette(IDirectDrawSurface *iface, IDirectDrawPalette *palette)
4831 {
4832     struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4833
4834     TRACE("iface %p, palette %p.\n", iface, palette);
4835
4836     if (IDirectDrawSurface_IsLost(iface) == DDERR_SURFACELOST)
4837     {
4838         WARN("Surface lost, returning DDERR_SURFACELOST.\n");
4839         return DDERR_SURFACELOST;
4840     }
4841
4842     return ddraw_surface_set_palette(surface, palette);
4843 }
4844
4845 /**********************************************************
4846  * IDirectDrawGammaControl::GetGammaRamp
4847  *
4848  * Returns the current gamma ramp for a surface
4849  *
4850  * Params:
4851  *  flags: Ignored
4852  *  gamma_ramp: Address to write the ramp to
4853  *
4854  * Returns:
4855  *  DD_OK on success
4856  *  DDERR_INVALIDPARAMS if gamma_ramp is NULL
4857  *
4858  **********************************************************/
4859 static HRESULT WINAPI ddraw_gamma_control_GetGammaRamp(IDirectDrawGammaControl *iface,
4860         DWORD flags, DDGAMMARAMP *gamma_ramp)
4861 {
4862     struct ddraw_surface *surface = impl_from_IDirectDrawGammaControl(iface);
4863
4864     TRACE("iface %p, flags %#x, gamma_ramp %p.\n", iface, flags, gamma_ramp);
4865
4866     if (!gamma_ramp)
4867     {
4868         WARN("Invalid gamma_ramp passed.\n");
4869         return DDERR_INVALIDPARAMS;
4870     }
4871
4872     wined3d_mutex_lock();
4873     if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
4874     {
4875         /* Note: DDGAMMARAMP is compatible with struct wined3d_gamma_ramp. */
4876         wined3d_device_get_gamma_ramp(surface->ddraw->wined3d_device, 0, (struct wined3d_gamma_ramp *)gamma_ramp);
4877     }
4878     else
4879     {
4880         ERR("Not implemented for non-primary surfaces.\n");
4881     }
4882     wined3d_mutex_unlock();
4883
4884     return DD_OK;
4885 }
4886
4887 /**********************************************************
4888  * IDirectDrawGammaControl::SetGammaRamp
4889  *
4890  * Sets the red, green and blue gamma ramps for
4891  *
4892  * Params:
4893  *  flags: Can be DDSGR_CALIBRATE to request calibration
4894  *  gamma_ramp: Structure containing the new gamma ramp
4895  *
4896  * Returns:
4897  *  DD_OK on success
4898  *  DDERR_INVALIDPARAMS if gamma_ramp is NULL
4899  *
4900  **********************************************************/
4901 static HRESULT WINAPI ddraw_gamma_control_SetGammaRamp(IDirectDrawGammaControl *iface,
4902         DWORD flags, DDGAMMARAMP *gamma_ramp)
4903 {
4904     struct ddraw_surface *surface = impl_from_IDirectDrawGammaControl(iface);
4905
4906     TRACE("iface %p, flags %#x, gamma_ramp %p.\n", iface, flags, gamma_ramp);
4907
4908     if (!gamma_ramp)
4909     {
4910         WARN("Invalid gamma_ramp passed.\n");
4911         return DDERR_INVALIDPARAMS;
4912     }
4913
4914     wined3d_mutex_lock();
4915     if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
4916     {
4917         /* Note: DDGAMMARAMP is compatible with struct wined3d_gamma_ramp. */
4918         wined3d_device_set_gamma_ramp(surface->ddraw->wined3d_device,
4919                 0, flags, (struct wined3d_gamma_ramp *)gamma_ramp);
4920     }
4921     else
4922     {
4923         ERR("Not implemented for non-primary surfaces.\n");
4924     }
4925     wined3d_mutex_unlock();
4926
4927     return DD_OK;
4928 }
4929
4930 /*****************************************************************************
4931  * IDirect3DTexture2::PaletteChanged
4932  *
4933  * Informs the texture about a palette change
4934  *
4935  * Params:
4936  *  start: Start index of the change
4937  *  count: The number of changed entries
4938  *
4939  * Returns
4940  *  D3D_OK, because it's a stub
4941  *
4942  *****************************************************************************/
4943 static HRESULT WINAPI d3d_texture2_PaletteChanged(IDirect3DTexture2 *iface, DWORD start, DWORD count)
4944 {
4945     FIXME("iface %p, start %u, count %u stub!\n", iface, start, count);
4946
4947     return D3D_OK;
4948 }
4949
4950 static HRESULT WINAPI d3d_texture1_PaletteChanged(IDirect3DTexture *iface, DWORD start, DWORD count)
4951 {
4952     struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
4953
4954     TRACE("iface %p, start %u, count %u.\n", iface, start, count);
4955
4956     return d3d_texture2_PaletteChanged(&surface->IDirect3DTexture2_iface, start, count);
4957 }
4958
4959 /*****************************************************************************
4960  * IDirect3DTexture::Unload
4961  *
4962  * DX5 SDK: "The IDirect3DTexture2::Unload method is not implemented
4963  *
4964  *
4965  * Returns:
4966  *  DDERR_UNSUPPORTED
4967  *
4968  *****************************************************************************/
4969 static HRESULT WINAPI d3d_texture1_Unload(IDirect3DTexture *iface)
4970 {
4971     WARN("iface %p. Not implemented.\n", iface);
4972
4973     return DDERR_UNSUPPORTED;
4974 }
4975
4976 /*****************************************************************************
4977  * IDirect3DTexture2::GetHandle
4978  *
4979  * Returns handle for the texture. At the moment, the interface
4980  * to the IWineD3DTexture is used.
4981  *
4982  * Params:
4983  *  device: Device this handle is assigned to
4984  *  handle: Address to store the handle at.
4985  *
4986  * Returns:
4987  *  D3D_OK
4988  *
4989  *****************************************************************************/
4990 static HRESULT WINAPI d3d_texture2_GetHandle(IDirect3DTexture2 *iface,
4991         IDirect3DDevice2 *device, D3DTEXTUREHANDLE *handle)
4992 {
4993     struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
4994     struct d3d_device *device_impl = unsafe_impl_from_IDirect3DDevice2(device);
4995
4996     TRACE("iface %p, device %p, handle %p.\n", iface, device, handle);
4997
4998     wined3d_mutex_lock();
4999
5000     if (!surface->Handle)
5001     {
5002         DWORD h = ddraw_allocate_handle(&device_impl->handle_table, surface, DDRAW_HANDLE_SURFACE);
5003         if (h == DDRAW_INVALID_HANDLE)
5004         {
5005             ERR("Failed to allocate a texture handle.\n");
5006             wined3d_mutex_unlock();
5007             return DDERR_OUTOFMEMORY;
5008         }
5009
5010         surface->Handle = h + 1;
5011     }
5012
5013     TRACE("Returning handle %08x.\n", surface->Handle);
5014     *handle = surface->Handle;
5015
5016     wined3d_mutex_unlock();
5017
5018     return D3D_OK;
5019 }
5020
5021 static HRESULT WINAPI d3d_texture1_GetHandle(IDirect3DTexture *iface,
5022         IDirect3DDevice *device, D3DTEXTUREHANDLE *handle)
5023 {
5024     struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
5025     struct d3d_device *device_impl = unsafe_impl_from_IDirect3DDevice(device);
5026
5027     TRACE("iface %p, device %p, handle %p.\n", iface, device, handle);
5028
5029     return d3d_texture2_GetHandle(&surface->IDirect3DTexture2_iface,
5030             device_impl ? &device_impl->IDirect3DDevice2_iface : NULL, handle);
5031 }
5032
5033 /*****************************************************************************
5034  * get_sub_mimaplevel
5035  *
5036  * Helper function that returns the next mipmap level
5037  *
5038  * tex_ptr: Surface of which to return the next level
5039  *
5040  *****************************************************************************/
5041 static struct ddraw_surface *get_sub_mimaplevel(struct ddraw_surface *surface)
5042 {
5043     /* Now go down the mipmap chain to the next surface */
5044     static DDSCAPS2 mipmap_caps = { DDSCAPS_MIPMAP | DDSCAPS_TEXTURE, 0, 0, {0} };
5045     IDirectDrawSurface7 *next_level;
5046     HRESULT hr;
5047
5048     hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface, &mipmap_caps, &next_level);
5049     if (FAILED(hr)) return NULL;
5050
5051     ddraw_surface7_Release(next_level);
5052
5053     return impl_from_IDirectDrawSurface7(next_level);
5054 }
5055
5056 /*****************************************************************************
5057  * IDirect3DTexture2::Load
5058  *
5059  * Loads a texture created with the DDSCAPS_ALLOCONLOAD
5060  *
5061  * This function isn't relayed to WineD3D because the whole interface is
5062  * implemented in DDraw only. For speed improvements an implementation which
5063  * takes OpenGL more into account could be placed into WineD3D.
5064  *
5065  * Params:
5066  *  src_texture: Address of the texture to load
5067  *
5068  * Returns:
5069  *  D3D_OK on success
5070  *  D3DERR_TEXTURE_LOAD_FAILED.
5071  *
5072  *****************************************************************************/
5073 static HRESULT WINAPI d3d_texture2_Load(IDirect3DTexture2 *iface, IDirect3DTexture2 *src_texture)
5074 {
5075     struct ddraw_surface *dst_surface = impl_from_IDirect3DTexture2(iface);
5076     struct ddraw_surface *src_surface = unsafe_impl_from_IDirect3DTexture2(src_texture);
5077     HRESULT hr;
5078
5079     TRACE("iface %p, src_texture %p.\n", iface, src_texture);
5080
5081     if (src_surface == dst_surface)
5082     {
5083         TRACE("copying surface %p to surface %p, why?\n", src_surface, dst_surface);
5084         return D3D_OK;
5085     }
5086
5087     wined3d_mutex_lock();
5088
5089     if (((src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
5090             != (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP))
5091             || (src_surface->surface_desc.u2.dwMipMapCount != dst_surface->surface_desc.u2.dwMipMapCount))
5092     {
5093         ERR("Trying to load surfaces with different mip-map counts.\n");
5094     }
5095
5096     for (;;)
5097     {
5098         struct ddraw_palette *dst_pal, *src_pal;
5099         DDSURFACEDESC *src_desc, *dst_desc;
5100
5101         TRACE("Copying surface %p to surface %p (mipmap level %d).\n",
5102                 src_surface, dst_surface, src_surface->mipmap_level);
5103
5104         /* Suppress the ALLOCONLOAD flag */
5105         dst_surface->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
5106
5107         /* Get the palettes */
5108         dst_pal = dst_surface->palette;
5109         src_pal = src_surface->palette;
5110
5111         if (src_pal)
5112         {
5113             PALETTEENTRY palent[256];
5114
5115             if (!dst_pal)
5116             {
5117                 wined3d_mutex_unlock();
5118                 return DDERR_NOPALETTEATTACHED;
5119             }
5120             IDirectDrawPalette_GetEntries(&src_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
5121             IDirectDrawPalette_SetEntries(&dst_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
5122         }
5123
5124         /* Copy one surface on the other */
5125         dst_desc = (DDSURFACEDESC *)&(dst_surface->surface_desc);
5126         src_desc = (DDSURFACEDESC *)&(src_surface->surface_desc);
5127
5128         if ((src_desc->dwWidth != dst_desc->dwWidth) || (src_desc->dwHeight != dst_desc->dwHeight))
5129         {
5130             /* Should also check for same pixel format, u1.lPitch, ... */
5131             ERR("Error in surface sizes.\n");
5132             wined3d_mutex_unlock();
5133             return D3DERR_TEXTURE_LOAD_FAILED;
5134         }
5135         else
5136         {
5137             struct wined3d_map_desc src_map_desc, dst_map_desc;
5138
5139             /* Copy the src blit color key if the source has one, don't erase
5140              * the destination's ckey if the source has none */
5141             if (src_desc->dwFlags & DDSD_CKSRCBLT)
5142             {
5143                 IDirectDrawSurface7_SetColorKey(&dst_surface->IDirectDrawSurface7_iface,
5144                         DDCKEY_SRCBLT, &src_desc->ddckCKSrcBlt);
5145             }
5146
5147             /* Copy the main memory texture into the surface that corresponds
5148              * to the OpenGL texture object. */
5149
5150             hr = wined3d_surface_map(src_surface->wined3d_surface, &src_map_desc, NULL, 0);
5151             if (FAILED(hr))
5152             {
5153                 ERR("Failed to lock source surface, hr %#x.\n", hr);
5154                 wined3d_mutex_unlock();
5155                 return D3DERR_TEXTURE_LOAD_FAILED;
5156             }
5157
5158             hr = wined3d_surface_map(dst_surface->wined3d_surface, &dst_map_desc, NULL, 0);
5159             if (FAILED(hr))
5160             {
5161                 ERR("Failed to lock destination surface, hr %#x.\n", hr);
5162                 wined3d_surface_unmap(src_surface->wined3d_surface);
5163                 wined3d_mutex_unlock();
5164                 return D3DERR_TEXTURE_LOAD_FAILED;
5165             }
5166
5167             if (dst_surface->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
5168                 memcpy(dst_map_desc.data, src_map_desc.data, src_surface->surface_desc.u1.dwLinearSize);
5169             else
5170                 memcpy(dst_map_desc.data, src_map_desc.data, src_map_desc.row_pitch * src_desc->dwHeight);
5171
5172             wined3d_surface_unmap(src_surface->wined3d_surface);
5173             wined3d_surface_unmap(dst_surface->wined3d_surface);
5174         }
5175
5176         if (src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
5177             src_surface = get_sub_mimaplevel(src_surface);
5178         else
5179             src_surface = NULL;
5180
5181         if (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
5182             dst_surface = get_sub_mimaplevel(dst_surface);
5183         else
5184             dst_surface = NULL;
5185
5186         if (!src_surface || !dst_surface)
5187         {
5188             if (src_surface != dst_surface)
5189                 ERR("Loading surface with different mipmap structure.\n");
5190             break;
5191         }
5192     }
5193
5194     wined3d_mutex_unlock();
5195
5196     return hr;
5197 }
5198
5199 static HRESULT WINAPI d3d_texture1_Load(IDirect3DTexture *iface, IDirect3DTexture *src_texture)
5200 {
5201     struct ddraw_surface *dst_surface = impl_from_IDirect3DTexture(iface);
5202     struct ddraw_surface *src_surface = unsafe_impl_from_IDirect3DTexture(src_texture);
5203
5204     TRACE("iface %p, src_texture %p.\n", iface, src_texture);
5205
5206     return d3d_texture2_Load(&dst_surface->IDirect3DTexture2_iface,
5207             src_surface ? &src_surface->IDirect3DTexture2_iface : NULL);
5208 }
5209
5210 /*****************************************************************************
5211  * The VTable
5212  *****************************************************************************/
5213
5214 static const struct IDirectDrawSurface7Vtbl ddraw_surface7_vtbl =
5215 {
5216     /* IUnknown */
5217     ddraw_surface7_QueryInterface,
5218     ddraw_surface7_AddRef,
5219     ddraw_surface7_Release,
5220     /* IDirectDrawSurface */
5221     ddraw_surface7_AddAttachedSurface,
5222     ddraw_surface7_AddOverlayDirtyRect,
5223     ddraw_surface7_Blt,
5224     ddraw_surface7_BltBatch,
5225     ddraw_surface7_BltFast,
5226     ddraw_surface7_DeleteAttachedSurface,
5227     ddraw_surface7_EnumAttachedSurfaces,
5228     ddraw_surface7_EnumOverlayZOrders,
5229     ddraw_surface7_Flip,
5230     ddraw_surface7_GetAttachedSurface,
5231     ddraw_surface7_GetBltStatus,
5232     ddraw_surface7_GetCaps,
5233     ddraw_surface7_GetClipper,
5234     ddraw_surface7_GetColorKey,
5235     ddraw_surface7_GetDC,
5236     ddraw_surface7_GetFlipStatus,
5237     ddraw_surface7_GetOverlayPosition,
5238     ddraw_surface7_GetPalette,
5239     ddraw_surface7_GetPixelFormat,
5240     ddraw_surface7_GetSurfaceDesc,
5241     ddraw_surface7_Initialize,
5242     ddraw_surface7_IsLost,
5243     ddraw_surface7_Lock,
5244     ddraw_surface7_ReleaseDC,
5245     ddraw_surface7_Restore,
5246     ddraw_surface7_SetClipper,
5247     ddraw_surface7_SetColorKey,
5248     ddraw_surface7_SetOverlayPosition,
5249     ddraw_surface7_SetPalette,
5250     ddraw_surface7_Unlock,
5251     ddraw_surface7_UpdateOverlay,
5252     ddraw_surface7_UpdateOverlayDisplay,
5253     ddraw_surface7_UpdateOverlayZOrder,
5254     /* IDirectDrawSurface2 */
5255     ddraw_surface7_GetDDInterface,
5256     ddraw_surface7_PageLock,
5257     ddraw_surface7_PageUnlock,
5258     /* IDirectDrawSurface3 */
5259     ddraw_surface7_SetSurfaceDesc,
5260     /* IDirectDrawSurface4 */
5261     ddraw_surface7_SetPrivateData,
5262     ddraw_surface7_GetPrivateData,
5263     ddraw_surface7_FreePrivateData,
5264     ddraw_surface7_GetUniquenessValue,
5265     ddraw_surface7_ChangeUniquenessValue,
5266     /* IDirectDrawSurface7 */
5267     ddraw_surface7_SetPriority,
5268     ddraw_surface7_GetPriority,
5269     ddraw_surface7_SetLOD,
5270     ddraw_surface7_GetLOD,
5271 };
5272
5273 static const struct IDirectDrawSurface4Vtbl ddraw_surface4_vtbl =
5274 {
5275     /* IUnknown */
5276     ddraw_surface4_QueryInterface,
5277     ddraw_surface4_AddRef,
5278     ddraw_surface4_Release,
5279     /* IDirectDrawSurface */
5280     ddraw_surface4_AddAttachedSurface,
5281     ddraw_surface4_AddOverlayDirtyRect,
5282     ddraw_surface4_Blt,
5283     ddraw_surface4_BltBatch,
5284     ddraw_surface4_BltFast,
5285     ddraw_surface4_DeleteAttachedSurface,
5286     ddraw_surface4_EnumAttachedSurfaces,
5287     ddraw_surface4_EnumOverlayZOrders,
5288     ddraw_surface4_Flip,
5289     ddraw_surface4_GetAttachedSurface,
5290     ddraw_surface4_GetBltStatus,
5291     ddraw_surface4_GetCaps,
5292     ddraw_surface4_GetClipper,
5293     ddraw_surface4_GetColorKey,
5294     ddraw_surface4_GetDC,
5295     ddraw_surface4_GetFlipStatus,
5296     ddraw_surface4_GetOverlayPosition,
5297     ddraw_surface4_GetPalette,
5298     ddraw_surface4_GetPixelFormat,
5299     ddraw_surface4_GetSurfaceDesc,
5300     ddraw_surface4_Initialize,
5301     ddraw_surface4_IsLost,
5302     ddraw_surface4_Lock,
5303     ddraw_surface4_ReleaseDC,
5304     ddraw_surface4_Restore,
5305     ddraw_surface4_SetClipper,
5306     ddraw_surface4_SetColorKey,
5307     ddraw_surface4_SetOverlayPosition,
5308     ddraw_surface4_SetPalette,
5309     ddraw_surface4_Unlock,
5310     ddraw_surface4_UpdateOverlay,
5311     ddraw_surface4_UpdateOverlayDisplay,
5312     ddraw_surface4_UpdateOverlayZOrder,
5313     /* IDirectDrawSurface2 */
5314     ddraw_surface4_GetDDInterface,
5315     ddraw_surface4_PageLock,
5316     ddraw_surface4_PageUnlock,
5317     /* IDirectDrawSurface3 */
5318     ddraw_surface4_SetSurfaceDesc,
5319     /* IDirectDrawSurface4 */
5320     ddraw_surface4_SetPrivateData,
5321     ddraw_surface4_GetPrivateData,
5322     ddraw_surface4_FreePrivateData,
5323     ddraw_surface4_GetUniquenessValue,
5324     ddraw_surface4_ChangeUniquenessValue,
5325 };
5326
5327 static const struct IDirectDrawSurface3Vtbl ddraw_surface3_vtbl =
5328 {
5329     /* IUnknown */
5330     ddraw_surface3_QueryInterface,
5331     ddraw_surface3_AddRef,
5332     ddraw_surface3_Release,
5333     /* IDirectDrawSurface */
5334     ddraw_surface3_AddAttachedSurface,
5335     ddraw_surface3_AddOverlayDirtyRect,
5336     ddraw_surface3_Blt,
5337     ddraw_surface3_BltBatch,
5338     ddraw_surface3_BltFast,
5339     ddraw_surface3_DeleteAttachedSurface,
5340     ddraw_surface3_EnumAttachedSurfaces,
5341     ddraw_surface3_EnumOverlayZOrders,
5342     ddraw_surface3_Flip,
5343     ddraw_surface3_GetAttachedSurface,
5344     ddraw_surface3_GetBltStatus,
5345     ddraw_surface3_GetCaps,
5346     ddraw_surface3_GetClipper,
5347     ddraw_surface3_GetColorKey,
5348     ddraw_surface3_GetDC,
5349     ddraw_surface3_GetFlipStatus,
5350     ddraw_surface3_GetOverlayPosition,
5351     ddraw_surface3_GetPalette,
5352     ddraw_surface3_GetPixelFormat,
5353     ddraw_surface3_GetSurfaceDesc,
5354     ddraw_surface3_Initialize,
5355     ddraw_surface3_IsLost,
5356     ddraw_surface3_Lock,
5357     ddraw_surface3_ReleaseDC,
5358     ddraw_surface3_Restore,
5359     ddraw_surface3_SetClipper,
5360     ddraw_surface3_SetColorKey,
5361     ddraw_surface3_SetOverlayPosition,
5362     ddraw_surface3_SetPalette,
5363     ddraw_surface3_Unlock,
5364     ddraw_surface3_UpdateOverlay,
5365     ddraw_surface3_UpdateOverlayDisplay,
5366     ddraw_surface3_UpdateOverlayZOrder,
5367     /* IDirectDrawSurface2 */
5368     ddraw_surface3_GetDDInterface,
5369     ddraw_surface3_PageLock,
5370     ddraw_surface3_PageUnlock,
5371     /* IDirectDrawSurface3 */
5372     ddraw_surface3_SetSurfaceDesc,
5373 };
5374
5375 static const struct IDirectDrawSurface2Vtbl ddraw_surface2_vtbl =
5376 {
5377     /* IUnknown */
5378     ddraw_surface2_QueryInterface,
5379     ddraw_surface2_AddRef,
5380     ddraw_surface2_Release,
5381     /* IDirectDrawSurface */
5382     ddraw_surface2_AddAttachedSurface,
5383     ddraw_surface2_AddOverlayDirtyRect,
5384     ddraw_surface2_Blt,
5385     ddraw_surface2_BltBatch,
5386     ddraw_surface2_BltFast,
5387     ddraw_surface2_DeleteAttachedSurface,
5388     ddraw_surface2_EnumAttachedSurfaces,
5389     ddraw_surface2_EnumOverlayZOrders,
5390     ddraw_surface2_Flip,
5391     ddraw_surface2_GetAttachedSurface,
5392     ddraw_surface2_GetBltStatus,
5393     ddraw_surface2_GetCaps,
5394     ddraw_surface2_GetClipper,
5395     ddraw_surface2_GetColorKey,
5396     ddraw_surface2_GetDC,
5397     ddraw_surface2_GetFlipStatus,
5398     ddraw_surface2_GetOverlayPosition,
5399     ddraw_surface2_GetPalette,
5400     ddraw_surface2_GetPixelFormat,
5401     ddraw_surface2_GetSurfaceDesc,
5402     ddraw_surface2_Initialize,
5403     ddraw_surface2_IsLost,
5404     ddraw_surface2_Lock,
5405     ddraw_surface2_ReleaseDC,
5406     ddraw_surface2_Restore,
5407     ddraw_surface2_SetClipper,
5408     ddraw_surface2_SetColorKey,
5409     ddraw_surface2_SetOverlayPosition,
5410     ddraw_surface2_SetPalette,
5411     ddraw_surface2_Unlock,
5412     ddraw_surface2_UpdateOverlay,
5413     ddraw_surface2_UpdateOverlayDisplay,
5414     ddraw_surface2_UpdateOverlayZOrder,
5415     /* IDirectDrawSurface2 */
5416     ddraw_surface2_GetDDInterface,
5417     ddraw_surface2_PageLock,
5418     ddraw_surface2_PageUnlock,
5419 };
5420
5421 static const struct IDirectDrawSurfaceVtbl ddraw_surface1_vtbl =
5422 {
5423     /* IUnknown */
5424     ddraw_surface1_QueryInterface,
5425     ddraw_surface1_AddRef,
5426     ddraw_surface1_Release,
5427     /* IDirectDrawSurface */
5428     ddraw_surface1_AddAttachedSurface,
5429     ddraw_surface1_AddOverlayDirtyRect,
5430     ddraw_surface1_Blt,
5431     ddraw_surface1_BltBatch,
5432     ddraw_surface1_BltFast,
5433     ddraw_surface1_DeleteAttachedSurface,
5434     ddraw_surface1_EnumAttachedSurfaces,
5435     ddraw_surface1_EnumOverlayZOrders,
5436     ddraw_surface1_Flip,
5437     ddraw_surface1_GetAttachedSurface,
5438     ddraw_surface1_GetBltStatus,
5439     ddraw_surface1_GetCaps,
5440     ddraw_surface1_GetClipper,
5441     ddraw_surface1_GetColorKey,
5442     ddraw_surface1_GetDC,
5443     ddraw_surface1_GetFlipStatus,
5444     ddraw_surface1_GetOverlayPosition,
5445     ddraw_surface1_GetPalette,
5446     ddraw_surface1_GetPixelFormat,
5447     ddraw_surface1_GetSurfaceDesc,
5448     ddraw_surface1_Initialize,
5449     ddraw_surface1_IsLost,
5450     ddraw_surface1_Lock,
5451     ddraw_surface1_ReleaseDC,
5452     ddraw_surface1_Restore,
5453     ddraw_surface1_SetClipper,
5454     ddraw_surface1_SetColorKey,
5455     ddraw_surface1_SetOverlayPosition,
5456     ddraw_surface1_SetPalette,
5457     ddraw_surface1_Unlock,
5458     ddraw_surface1_UpdateOverlay,
5459     ddraw_surface1_UpdateOverlayDisplay,
5460     ddraw_surface1_UpdateOverlayZOrder,
5461 };
5462
5463 static const struct IDirectDrawGammaControlVtbl ddraw_gamma_control_vtbl =
5464 {
5465     ddraw_gamma_control_QueryInterface,
5466     ddraw_gamma_control_AddRef,
5467     ddraw_gamma_control_Release,
5468     ddraw_gamma_control_GetGammaRamp,
5469     ddraw_gamma_control_SetGammaRamp,
5470 };
5471
5472 static const struct IDirect3DTexture2Vtbl d3d_texture2_vtbl =
5473 {
5474     d3d_texture2_QueryInterface,
5475     d3d_texture2_AddRef,
5476     d3d_texture2_Release,
5477     d3d_texture2_GetHandle,
5478     d3d_texture2_PaletteChanged,
5479     d3d_texture2_Load,
5480 };
5481
5482 static const struct IDirect3DTextureVtbl d3d_texture1_vtbl =
5483 {
5484     d3d_texture1_QueryInterface,
5485     d3d_texture1_AddRef,
5486     d3d_texture1_Release,
5487     d3d_texture1_Initialize,
5488     d3d_texture1_GetHandle,
5489     d3d_texture1_PaletteChanged,
5490     d3d_texture1_Load,
5491     d3d_texture1_Unload,
5492 };
5493
5494 /* Some games (e.g. Tomb Raider 3) pass the wrong version of the
5495  * IDirectDrawSurface interface to ddraw methods. */
5496 struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface7(IDirectDrawSurface7 *iface)
5497 {
5498     if (!iface) return NULL;
5499     if (iface->lpVtbl != &ddraw_surface7_vtbl)
5500     {
5501         HRESULT hr = IDirectDrawSurface7_QueryInterface(iface, &IID_IDirectDrawSurface7, (void **)&iface);
5502         if (FAILED(hr))
5503         {
5504             WARN("Object %p doesn't expose interface IDirectDrawSurface7.\n", iface);
5505             return NULL;
5506         }
5507         IDirectDrawSurface7_Release(iface);
5508     }
5509     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface7_iface);
5510 }
5511
5512 struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface4(IDirectDrawSurface4 *iface)
5513 {
5514     if (!iface) return NULL;
5515     if (iface->lpVtbl != &ddraw_surface4_vtbl)
5516     {
5517         HRESULT hr = IDirectDrawSurface4_QueryInterface(iface, &IID_IDirectDrawSurface4, (void **)&iface);
5518         if (FAILED(hr))
5519         {
5520             WARN("Object %p doesn't expose interface IDirectDrawSurface4.\n", iface);
5521             return NULL;
5522         }
5523         IDirectDrawSurface4_Release(iface);
5524     }
5525     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface4_iface);
5526 }
5527
5528 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface3(IDirectDrawSurface3 *iface)
5529 {
5530     if (!iface) return NULL;
5531     if (iface->lpVtbl != &ddraw_surface3_vtbl)
5532     {
5533         HRESULT hr = IDirectDrawSurface3_QueryInterface(iface, &IID_IDirectDrawSurface3, (void **)&iface);
5534         if (FAILED(hr))
5535         {
5536             WARN("Object %p doesn't expose interface IDirectDrawSurface3.\n", iface);
5537             return NULL;
5538         }
5539         IDirectDrawSurface3_Release(iface);
5540     }
5541     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface3_iface);
5542 }
5543
5544 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface2(IDirectDrawSurface2 *iface)
5545 {
5546     if (!iface) return NULL;
5547     if (iface->lpVtbl != &ddraw_surface2_vtbl)
5548     {
5549         HRESULT hr = IDirectDrawSurface2_QueryInterface(iface, &IID_IDirectDrawSurface2, (void **)&iface);
5550         if (FAILED(hr))
5551         {
5552             WARN("Object %p doesn't expose interface IDirectDrawSurface2.\n", iface);
5553             return NULL;
5554         }
5555         IDirectDrawSurface2_Release(iface);
5556     }
5557     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface2_iface);
5558 }
5559
5560 struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface(IDirectDrawSurface *iface)
5561 {
5562     if (!iface) return NULL;
5563     if (iface->lpVtbl != &ddraw_surface1_vtbl)
5564     {
5565         HRESULT hr = IDirectDrawSurface_QueryInterface(iface, &IID_IDirectDrawSurface, (void **)&iface);
5566         if (FAILED(hr))
5567         {
5568             WARN("Object %p doesn't expose interface IDirectDrawSurface.\n", iface);
5569             return NULL;
5570         }
5571         IDirectDrawSurface_Release(iface);
5572     }
5573     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface_iface);
5574 }
5575
5576 struct ddraw_surface *unsafe_impl_from_IDirect3DTexture2(IDirect3DTexture2 *iface)
5577 {
5578     if (!iface) return NULL;
5579     assert(iface->lpVtbl == &d3d_texture2_vtbl);
5580     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture2_iface);
5581 }
5582
5583 struct ddraw_surface *unsafe_impl_from_IDirect3DTexture(IDirect3DTexture *iface)
5584 {
5585     if (!iface) return NULL;
5586     assert(iface->lpVtbl == &d3d_texture1_vtbl);
5587     return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture_iface);
5588 }
5589
5590 static void STDMETHODCALLTYPE ddraw_surface_wined3d_object_destroyed(void *parent)
5591 {
5592     struct ddraw_surface *surface = parent;
5593
5594     TRACE("surface %p.\n", surface);
5595
5596     /* Check for attached surfaces and detach them. */
5597     if (surface->first_attached != surface)
5598     {
5599         /* Well, this shouldn't happen: The surface being attached is
5600          * referenced in AddAttachedSurface(), so it shouldn't be released
5601          * until DeleteAttachedSurface() is called, because the refcount is
5602          * held. It looks like the application released it often enough to
5603          * force this. */
5604         WARN("Surface is still attached to surface %p.\n", surface->first_attached);
5605
5606         /* The refcount will drop to -1 here */
5607         if (FAILED(ddraw_surface_delete_attached_surface(surface->first_attached, surface, surface->attached_iface)))
5608             ERR("DeleteAttachedSurface failed.\n");
5609     }
5610
5611     while (surface->next_attached)
5612         if (FAILED(ddraw_surface_delete_attached_surface(surface,
5613                 surface->next_attached, surface->next_attached->attached_iface)))
5614             ERR("DeleteAttachedSurface failed.\n");
5615
5616     /* Having a texture handle set implies that the device still exists. */
5617     if (surface->Handle)
5618         ddraw_free_handle(&surface->ddraw->d3ddevice->handle_table, surface->Handle - 1, DDRAW_HANDLE_SURFACE);
5619
5620     /* Reduce the ddraw surface count. */
5621     list_remove(&surface->surface_list_entry);
5622
5623     if (surface->clipper)
5624         IDirectDrawClipper_Release(&surface->clipper->IDirectDrawClipper_iface);
5625
5626     if (surface == surface->ddraw->primary)
5627         surface->ddraw->primary = NULL;
5628
5629     wined3d_private_store_cleanup(&surface->private_store);
5630
5631     HeapFree(GetProcessHeap(), 0, surface);
5632 }
5633
5634 static const struct wined3d_parent_ops ddraw_surface_wined3d_parent_ops =
5635 {
5636     ddraw_surface_wined3d_object_destroyed,
5637 };
5638
5639 static void STDMETHODCALLTYPE ddraw_texture_wined3d_object_destroyed(void *parent)
5640 {
5641     TRACE("parent %p.\n", parent);
5642
5643     HeapFree(GetProcessHeap(), 0, parent);
5644 }
5645
5646 static const struct wined3d_parent_ops ddraw_texture_wined3d_parent_ops =
5647 {
5648     ddraw_texture_wined3d_object_destroyed,
5649 };
5650
5651 static HRESULT CDECL ddraw_reset_enum_callback(struct wined3d_resource *resource)
5652 {
5653     return DD_OK;
5654 }
5655
5656 HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_desc,
5657         struct ddraw_surface **surface, IUnknown *outer_unknown, unsigned int version)
5658 {
5659     struct ddraw_surface *root, *mip, **attach;
5660     struct wined3d_resource_desc wined3d_desc;
5661     struct wined3d_texture *wined3d_texture;
5662     struct wined3d_resource *resource;
5663     struct wined3d_display_mode mode;
5664     DDSURFACEDESC2 *desc, *mip_desc;
5665     struct ddraw_texture *texture;
5666     UINT layers, levels, i, j;
5667     unsigned int pitch = 0;
5668     HRESULT hr;
5669
5670     TRACE("ddraw %p, surface_desc %p, surface %p, outer_unknown %p, version %u.\n",
5671             ddraw, surface_desc, surface, outer_unknown, version);
5672     if (TRACE_ON(ddraw))
5673     {
5674         TRACE("Requesting surface desc:\n");
5675         DDRAW_dump_surface_desc(surface_desc);
5676     }
5677
5678     if (outer_unknown)
5679         return CLASS_E_NOAGGREGATION;
5680
5681     if (!surface)
5682         return E_POINTER;
5683
5684     if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
5685         return E_OUTOFMEMORY;
5686
5687     texture->version = version;
5688     texture->surface_desc = *surface_desc;
5689     desc = &texture->surface_desc;
5690
5691     /* Ensure DDSD_CAPS is always set. */
5692     desc->dwFlags |= DDSD_CAPS;
5693
5694     if (desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
5695     {
5696         DWORD flippable = desc->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_COMPLEX);
5697
5698         if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
5699         {
5700             WARN("Tried to create a primary surface with DDSCAPS_TEXTURE.\n");
5701             HeapFree(GetProcessHeap(), 0, texture);
5702             return DDERR_INVALIDCAPS;
5703         }
5704
5705         if (flippable)
5706         {
5707             if (flippable != (DDSCAPS_FLIP | DDSCAPS_COMPLEX))
5708             {
5709                 WARN("Tried to create a flippable primary surface without both DDSCAPS_FLIP and DDSCAPS_COMPLEX.\n");
5710                 HeapFree(GetProcessHeap(), 0, texture);
5711                 return DDERR_INVALIDCAPS;
5712             }
5713
5714             if (!(desc->dwFlags & DDSD_BACKBUFFERCOUNT) || !desc->u5.dwBackBufferCount)
5715             {
5716                 WARN("Tried to create a flippable primary surface without any back buffers.\n");
5717                 HeapFree(GetProcessHeap(), 0, texture);
5718                 return DDERR_INVALIDCAPS;
5719             }
5720
5721             if (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
5722             {
5723                 WARN("Tried to create a flippable primary surface without DDSCL_EXCLUSIVE.\n");
5724                 HeapFree(GetProcessHeap(), 0, texture);
5725                 return DDERR_NOEXCLUSIVEMODE;
5726             }
5727         }
5728     }
5729
5730     /* This is a special case in ddrawex, but not allowed in ddraw. */
5731     if ((desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
5732             == (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
5733     {
5734         WARN("Tried to create a surface in both system and video memory.\n");
5735         HeapFree(GetProcessHeap(), 0, texture);
5736         return DDERR_INVALIDCAPS;
5737     }
5738
5739     if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES)
5740             && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
5741     {
5742         WARN("Cube map faces requested without cube map flag.\n");
5743         HeapFree(GetProcessHeap(), 0, texture);
5744         return DDERR_INVALIDCAPS;
5745     }
5746
5747     if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5748             && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES))
5749     {
5750         WARN("Cube map without faces requested.\n");
5751         HeapFree(GetProcessHeap(), 0, texture);
5752         return DDERR_INVALIDPARAMS;
5753     }
5754
5755     if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5756             && (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
5757         FIXME("Partial cube maps not implemented.\n");
5758
5759     if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
5760     {
5761         if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
5762         {
5763             WARN("DDSCAPS2_TEXTUREMANAGE used without DDSCAPS_TEXTURE, returning DDERR_INVALIDCAPS.\n");
5764             HeapFree(GetProcessHeap(), 0, texture);
5765             return DDERR_INVALIDCAPS;
5766         }
5767         if (desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
5768         {
5769             WARN("DDSCAPS2_TEXTUREMANAGE used width DDSCAPS_VIDEOMEMORY "
5770                     "or DDSCAPS_SYSTEMMEMORY, returning DDERR_INVALIDCAPS.\n");
5771             HeapFree(GetProcessHeap(), 0, texture);
5772             return DDERR_INVALIDCAPS;
5773         }
5774     }
5775
5776     if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
5777     {
5778         ERR("Failed to get display mode, hr %#x.\n", hr);
5779         HeapFree(GetProcessHeap(), 0, texture);
5780         return hr_ddraw_from_wined3d(hr);
5781     }
5782
5783     /* No pixelformat given? Use the current screen format. */
5784     if (!(desc->dwFlags & DDSD_PIXELFORMAT))
5785     {
5786         desc->dwFlags |= DDSD_PIXELFORMAT;
5787         desc->u4.ddpfPixelFormat.dwSize = sizeof(desc->u4.ddpfPixelFormat);
5788         ddrawformat_from_wined3dformat(&desc->u4.ddpfPixelFormat, mode.format_id);
5789     }
5790
5791     wined3d_desc.format = wined3dformat_from_ddrawformat(&desc->u4.ddpfPixelFormat);
5792     if (wined3d_desc.format == WINED3DFMT_UNKNOWN)
5793     {
5794         WARN("Unsupported / unknown pixelformat.\n");
5795         HeapFree(GetProcessHeap(), 0, texture);
5796         return DDERR_INVALIDPIXELFORMAT;
5797     }
5798
5799     /* No width or no height? Use the screen size. */
5800     if (!(desc->dwFlags & DDSD_WIDTH) || !(desc->dwFlags & DDSD_HEIGHT))
5801     {
5802         if (!(desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
5803         {
5804             WARN("No width / height specified.\n");
5805             HeapFree(GetProcessHeap(), 0, texture);
5806             return DDERR_INVALIDPARAMS;
5807         }
5808
5809         desc->dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
5810         desc->dwWidth = mode.width;
5811         desc->dwHeight = mode.height;
5812     }
5813
5814     if (!desc->dwWidth || !desc->dwHeight)
5815     {
5816         HeapFree(GetProcessHeap(), 0, texture);
5817         return DDERR_INVALIDPARAMS;
5818     }
5819
5820     if (desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
5821     {
5822         /* The first surface is a front buffer, the back buffers are created
5823          * afterwards. */
5824         if (desc->ddsCaps.dwCaps & DDSCAPS_FLIP)
5825             desc->ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
5826         desc->ddsCaps.dwCaps |= DDSCAPS_VISIBLE;
5827         if (ddraw->cooperative_level & DDSCL_EXCLUSIVE)
5828         {
5829             struct wined3d_swapchain_desc swapchain_desc;
5830
5831             wined3d_swapchain_get_desc(ddraw->wined3d_swapchain, &swapchain_desc);
5832             swapchain_desc.backbuffer_width = mode.width;
5833             swapchain_desc.backbuffer_height = mode.height;
5834             swapchain_desc.backbuffer_format = mode.format_id;
5835
5836             if (FAILED(hr = wined3d_device_reset(ddraw->wined3d_device,
5837                     &swapchain_desc, NULL, ddraw_reset_enum_callback, TRUE)))
5838             {
5839                 ERR("Failed to reset device.\n");
5840                 HeapFree(GetProcessHeap(), 0, texture);
5841                 return hr_ddraw_from_wined3d(hr);
5842             }
5843         }
5844     }
5845
5846     wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
5847     wined3d_desc.multisample_quality = 0;
5848     wined3d_desc.usage = 0;
5849     wined3d_desc.pool = WINED3D_POOL_DEFAULT;
5850     wined3d_desc.width = desc->dwWidth;
5851     wined3d_desc.height = desc->dwHeight;
5852     wined3d_desc.depth = 1;
5853     wined3d_desc.size = 0;
5854
5855     if ((desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) && (ddraw->flags & DDRAW_NO3D))
5856     {
5857         WARN("The application requests a 3D capable surface, but the ddraw object was created without 3D support.\n");
5858         /* Do not fail surface creation, only fail 3D device creation. */
5859     }
5860
5861     /* Mipmap count fixes */
5862     if (desc->ddsCaps.dwCaps & DDSCAPS_MIPMAP)
5863     {
5864         if (desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX)
5865         {
5866             if (desc->dwFlags & DDSD_MIPMAPCOUNT)
5867             {
5868                 /* Mipmap count is given, should not be 0. */
5869                 if (!desc->u2.dwMipMapCount)
5870                 {
5871                     HeapFree(GetProcessHeap(), 0, texture);
5872                     return DDERR_INVALIDPARAMS;
5873                 }
5874             }
5875             else
5876             {
5877                 /* Undocumented feature: Create sublevels until either the
5878                  * width or the height is 1. */
5879                 desc->u2.dwMipMapCount = wined3d_log2i(min(desc->dwWidth, desc->dwHeight)) + 1;
5880             }
5881         }
5882         else
5883         {
5884             desc->u2.dwMipMapCount = 1;
5885         }
5886
5887         desc->dwFlags |= DDSD_MIPMAPCOUNT;
5888         levels = desc->u2.dwMipMapCount;
5889     }
5890     else
5891     {
5892         levels = 1;
5893     }
5894
5895     if (!(desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY)))
5896     {
5897         if (!(desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE)))
5898         {
5899             enum wined3d_resource_type rtype;
5900             DWORD usage = 0;
5901
5902             if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5903                 rtype = WINED3D_RTYPE_CUBE_TEXTURE;
5904             else if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
5905                 rtype = WINED3D_RTYPE_TEXTURE;
5906             else
5907                 rtype = WINED3D_RTYPE_SURFACE;
5908
5909             if (desc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
5910                 usage = WINED3DUSAGE_DEPTHSTENCIL;
5911             else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
5912                 usage = WINED3DUSAGE_RENDERTARGET;
5913
5914             if (SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
5915                     WINED3D_DEVICE_TYPE_HAL, mode.format_id, usage, rtype, wined3d_desc.format)))
5916                 desc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
5917             else
5918                 desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
5919         }
5920         else if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
5921         {
5922             /* Tests show surfaces without memory flags get these flags added
5923              * right after creation. */
5924             desc->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
5925         }
5926     }
5927
5928     if ((desc->ddsCaps.dwCaps & (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
5929             == (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
5930     {
5931         WARN("System memory overlays are not allowed.\n");
5932         HeapFree(GetProcessHeap(), 0, texture);
5933         return DDERR_NOOVERLAYHW;
5934     }
5935
5936     if (desc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
5937     {
5938         wined3d_desc.pool = WINED3D_POOL_SYSTEM_MEM;
5939     }
5940     else
5941     {
5942         if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
5943             wined3d_desc.usage |= WINED3DUSAGE_TEXTURE;
5944         if (desc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
5945             wined3d_desc.usage |= WINED3DUSAGE_DEPTHSTENCIL;
5946         else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
5947             wined3d_desc.usage |= WINED3DUSAGE_RENDERTARGET;
5948
5949         if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
5950         {
5951             wined3d_desc.pool = WINED3D_POOL_MANAGED;
5952             /* Managed textures have the system memory flag set. */
5953             desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
5954         }
5955         else if (desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
5956         {
5957             /* Videomemory adds localvidmem. This is mutually exclusive with
5958              * systemmemory and texturemanage. */
5959             desc->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM;
5960             wined3d_desc.usage |= WINED3DUSAGE_DYNAMIC;
5961         }
5962     }
5963
5964     /* If the surface is of the 'ALLOCONLOAD' type, ignore the LPSURFACE
5965      * field. Frank Herbert's Dune specifies a NULL pointer for lpSurface. */
5966     if ((desc->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD) || !desc->lpSurface)
5967         desc->dwFlags &= ~DDSD_LPSURFACE;
5968     if (desc->dwFlags & DDSD_LPSURFACE)
5969     {
5970         if (wined3d_desc.pool != WINED3D_POOL_SYSTEM_MEM)
5971         {
5972             WARN("User memory surfaces should be in the system memory pool.\n");
5973             HeapFree(GetProcessHeap(), 0, texture);
5974             return DDERR_INVALIDCAPS;
5975         }
5976
5977         if (version < 4)
5978         {
5979             WARN("User memory surfaces not supported before version 4.\n");
5980             HeapFree(GetProcessHeap(), 0, texture);
5981             return DDERR_INVALIDPARAMS;
5982         }
5983
5984         if (format_is_compressed(&desc->u4.ddpfPixelFormat))
5985         {
5986             if (version != 4 && (desc->dwFlags & DDSD_PITCH))
5987             {
5988                 WARN("Pitch specified on a compressed user memory surface.\n");
5989                 HeapFree(GetProcessHeap(), 0, texture);
5990                 return DDERR_INVALIDPARAMS;
5991             }
5992
5993             if (!(desc->dwFlags & (DDSD_LINEARSIZE | DDSD_PITCH)))
5994             {
5995                 WARN("Compressed user memory surfaces should explicitly specify the linear size.\n");
5996                 HeapFree(GetProcessHeap(), 0, texture);
5997                 return DDERR_INVALIDPARAMS;
5998             }
5999
6000             if ((desc->dwFlags & DDSD_LINEARSIZE)
6001                     && desc->u1.dwLinearSize < wined3d_calculate_format_pitch(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
6002                             wined3d_desc.format, wined3d_desc.width) * ((desc->dwHeight + 3) / 4))
6003             {
6004                 WARN("Invalid linear size %u specified.\n", desc->u1.dwLinearSize);
6005                 HeapFree(GetProcessHeap(), 0, texture);
6006                 return DDERR_INVALIDPARAMS;
6007             }
6008         }
6009         else
6010         {
6011             if (!(desc->dwFlags & DDSD_PITCH))
6012             {
6013                 WARN("User memory surfaces should explicitly specify the pitch.\n");
6014                 HeapFree(GetProcessHeap(), 0, texture);
6015                 return DDERR_INVALIDPARAMS;
6016             }
6017
6018             if (desc->u1.lPitch < wined3d_calculate_format_pitch(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
6019                     wined3d_desc.format, wined3d_desc.width) || desc->u1.lPitch & 3)
6020             {
6021                 WARN("Invalid pitch %u specified.\n", desc->u1.lPitch);
6022                 HeapFree(GetProcessHeap(), 0, texture);
6023                 return DDERR_INVALIDPARAMS;
6024             }
6025
6026             pitch = desc->u1.lPitch;
6027         }
6028     }
6029
6030     if (desc->ddsCaps.dwCaps & (DDSCAPS_OVERLAY))
6031         wined3d_desc.usage |= WINED3DUSAGE_OVERLAY;
6032
6033     if (desc->ddsCaps.dwCaps & DDSCAPS_OWNDC)
6034         wined3d_desc.usage |= WINED3DUSAGE_OWNDC;
6035
6036     if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
6037     {
6038         wined3d_desc.resource_type = WINED3D_RTYPE_CUBE_TEXTURE;
6039         layers = 6;
6040     }
6041     else
6042     {
6043         wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE;
6044         layers = 1;
6045     }
6046
6047     /* Some applications assume surfaces will always be mapped at the same
6048      * address. Some of those also assume that this address is valid even when
6049      * the surface isn't mapped, and that updates done this way will be
6050      * visible on the screen. The game Nox is such an application,
6051      * Commandos: Behind Enemy Lines is another. We set
6052      * WINED3D_SURFACE_PIN_SYSMEM because of this. */
6053     if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, &wined3d_desc, levels,
6054             WINED3D_SURFACE_PIN_SYSMEM, NULL, texture, &ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
6055     {
6056         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
6057         HeapFree(GetProcessHeap(), 0, texture);
6058         return hr_ddraw_from_wined3d(hr);
6059     }
6060
6061     resource = wined3d_texture_get_sub_resource(wined3d_texture, 0);
6062     root = wined3d_resource_get_parent(resource);
6063     root->wined3d_texture = wined3d_texture;
6064     root->is_complex_root = TRUE;
6065     texture->root = root;
6066
6067     if (desc->dwFlags & DDSD_CKDESTOVERLAY)
6068         wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTOVERLAY,
6069                 (struct wined3d_color_key *)&desc->u3.ddckCKDestOverlay);
6070     if (desc->dwFlags & DDSD_CKDESTBLT)
6071         wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTBLT,
6072                 (struct wined3d_color_key *)&desc->ddckCKDestBlt);
6073     if (desc->dwFlags & DDSD_CKSRCOVERLAY)
6074         wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCOVERLAY,
6075                 (struct wined3d_color_key *)&desc->ddckCKSrcOverlay);
6076     if (desc->dwFlags & DDSD_CKSRCBLT)
6077         wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCBLT,
6078                 (struct wined3d_color_key *)&desc->ddckCKSrcBlt);
6079
6080     for (i = 0; i < layers; ++i)
6081     {
6082         attach = &root->complex_array[layers - 1 - i];
6083
6084         for (j = 0; j < levels; ++j)
6085         {
6086             resource = wined3d_texture_get_sub_resource(wined3d_texture, i * levels + j);
6087             mip = wined3d_resource_get_parent(resource);
6088             mip_desc = &mip->surface_desc;
6089
6090             if (j)
6091                 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
6092             else
6093                 mip_desc->ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
6094
6095             if (mip_desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
6096             {
6097                 mip_desc->ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
6098
6099                 switch (i)
6100                 {
6101                     case WINED3D_CUBEMAP_FACE_POSITIVE_X:
6102                         mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
6103                         break;
6104                     case WINED3D_CUBEMAP_FACE_NEGATIVE_X:
6105                         mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX;
6106                         break;
6107                     case WINED3D_CUBEMAP_FACE_POSITIVE_Y:
6108                         mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY;
6109                         break;
6110                     case WINED3D_CUBEMAP_FACE_NEGATIVE_Y:
6111                         mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY;
6112                         break;
6113                     case WINED3D_CUBEMAP_FACE_POSITIVE_Z:
6114                         mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ;
6115                         break;
6116                     case WINED3D_CUBEMAP_FACE_NEGATIVE_Z:
6117                         mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ;
6118                         break;
6119                 }
6120
6121             }
6122
6123             if (mip == root)
6124                 continue;
6125
6126             *attach = mip;
6127             attach = &mip->complex_array[0];
6128         }
6129     }
6130
6131     if ((desc->dwFlags & DDSD_LPSURFACE) && FAILED(hr = wined3d_texture_update_desc(wined3d_texture,
6132             wined3d_desc.width, wined3d_desc.height, wined3d_desc.format,
6133             WINED3D_MULTISAMPLE_NONE, 0, desc->lpSurface, pitch)))
6134     {
6135         ERR("Failed to set surface memory, hr %#x.\n", hr);
6136         goto fail;
6137     }
6138
6139     if (desc->dwFlags & DDSD_BACKBUFFERCOUNT)
6140     {
6141         unsigned int count = desc->u5.dwBackBufferCount;
6142         struct ddraw_surface *last = root;
6143
6144         attach = &last->complex_array[0];
6145         for (i = 0; i < count; ++i)
6146         {
6147             if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
6148             {
6149                 hr = E_OUTOFMEMORY;
6150                 goto fail;
6151             }
6152
6153             texture->version = version;
6154             texture->surface_desc = root->surface_desc;
6155             desc = &texture->surface_desc;
6156
6157             /* Only one surface in the flipping chain is a back buffer, one is
6158              * a front buffer, the others are just flippable surfaces. */
6159             desc->ddsCaps.dwCaps &= ~(DDSCAPS_VISIBLE | DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER
6160                     | DDSCAPS_BACKBUFFER);
6161             if (!i)
6162                 desc->ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
6163             desc->u5.dwBackBufferCount = 0;
6164
6165             if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, &wined3d_desc, 1,
6166                     WINED3D_SURFACE_PIN_SYSMEM, NULL, texture, &ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
6167             {
6168                 HeapFree(GetProcessHeap(), 0, texture);
6169                 hr = hr_ddraw_from_wined3d(hr);
6170                 goto fail;
6171             }
6172
6173             resource = wined3d_texture_get_sub_resource(wined3d_texture, 0);
6174             last = wined3d_resource_get_parent(resource);
6175             last->wined3d_texture = wined3d_texture;
6176             texture->root = last;
6177
6178             if (desc->dwFlags & DDSD_CKDESTOVERLAY)
6179                 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTOVERLAY,
6180                         (struct wined3d_color_key *)&desc->u3.ddckCKDestOverlay);
6181             if (desc->dwFlags & DDSD_CKDESTBLT)
6182                 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTBLT,
6183                         (struct wined3d_color_key *)&desc->ddckCKDestBlt);
6184             if (desc->dwFlags & DDSD_CKSRCOVERLAY)
6185                 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCOVERLAY,
6186                         (struct wined3d_color_key *)&desc->ddckCKSrcOverlay);
6187             if (desc->dwFlags & DDSD_CKSRCBLT)
6188                 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCBLT,
6189                         (struct wined3d_color_key *)&desc->ddckCKSrcBlt);
6190
6191             *attach = last;
6192             attach = &last->complex_array[0];
6193         }
6194         *attach = root;
6195     }
6196
6197     if (surface_desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
6198         ddraw->primary = root;
6199     *surface = root;
6200
6201     return DD_OK;
6202
6203 fail:
6204     if (version == 7)
6205         IDirectDrawSurface7_Release(&root->IDirectDrawSurface7_iface);
6206     else if (version == 4)
6207         IDirectDrawSurface4_Release(&root->IDirectDrawSurface4_iface);
6208     else
6209         IDirectDrawSurface_Release(&root->IDirectDrawSurface_iface);
6210
6211     return hr;
6212 }
6213
6214 void ddraw_surface_init(struct ddraw_surface *surface, struct ddraw *ddraw, struct ddraw_texture *texture,
6215         struct wined3d_surface *wined3d_surface, const struct wined3d_parent_ops **parent_ops)
6216 {
6217     DDSURFACEDESC2 *desc = &surface->surface_desc;
6218     struct wined3d_resource_desc wined3d_desc;
6219     unsigned int version = texture->version;
6220
6221     surface->IDirectDrawSurface7_iface.lpVtbl = &ddraw_surface7_vtbl;
6222     surface->IDirectDrawSurface4_iface.lpVtbl = &ddraw_surface4_vtbl;
6223     surface->IDirectDrawSurface3_iface.lpVtbl = &ddraw_surface3_vtbl;
6224     surface->IDirectDrawSurface2_iface.lpVtbl = &ddraw_surface2_vtbl;
6225     surface->IDirectDrawSurface_iface.lpVtbl = &ddraw_surface1_vtbl;
6226     surface->IDirectDrawGammaControl_iface.lpVtbl = &ddraw_gamma_control_vtbl;
6227     surface->IDirect3DTexture2_iface.lpVtbl = &d3d_texture2_vtbl;
6228     surface->IDirect3DTexture_iface.lpVtbl = &d3d_texture1_vtbl;
6229     surface->iface_count = 1;
6230     surface->version = version;
6231     surface->ddraw = ddraw;
6232
6233     if (version == 7)
6234     {
6235         surface->ref7 = 1;
6236         surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface7_iface;
6237     }
6238     else if (version == 4)
6239     {
6240         surface->ref4 = 1;
6241         surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface4_iface;
6242     }
6243     else
6244     {
6245         surface->ref1 = 1;
6246         surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface_iface;
6247     }
6248
6249     *desc = texture->surface_desc;
6250     wined3d_resource_get_desc(wined3d_surface_get_resource(wined3d_surface), &wined3d_desc);
6251     desc->dwWidth = wined3d_desc.width;
6252     desc->dwHeight = wined3d_desc.height;
6253     surface->first_attached = surface;
6254
6255     if (format_is_compressed(&desc->u4.ddpfPixelFormat))
6256     {
6257         if (desc->dwFlags & DDSD_LPSURFACE)
6258             desc->u1.dwLinearSize = ~0u;
6259         else
6260             desc->u1.dwLinearSize = wined3d_surface_get_pitch(wined3d_surface) * ((desc->dwHeight + 3) / 4);
6261         desc->dwFlags |= DDSD_LINEARSIZE;
6262         desc->dwFlags &= ~(DDSD_LPSURFACE | DDSD_PITCH);
6263     }
6264     else
6265     {
6266         if (!(desc->dwFlags & DDSD_LPSURFACE))
6267             desc->u1.lPitch = wined3d_surface_get_pitch(wined3d_surface);
6268         desc->dwFlags |= DDSD_PITCH;
6269         desc->dwFlags &= ~(DDSD_LPSURFACE | DDSD_LINEARSIZE);
6270     }
6271     desc->lpSurface = NULL;
6272
6273     wined3d_surface_incref(wined3d_surface);
6274     surface->wined3d_surface = wined3d_surface;
6275     *parent_ops = &ddraw_surface_wined3d_parent_ops;
6276
6277     wined3d_private_store_init(&surface->private_store);
6278 }
6279
6280 static void STDMETHODCALLTYPE view_wined3d_object_destroyed(void *parent)
6281 {
6282     struct ddraw_surface *surface = parent;
6283
6284     /* If the surface reference count drops to zero, we release our reference
6285      * to the view, but don't clear the pointer yet, in case e.g. a
6286      * GetRenderTarget() call brings the surface back before the view is
6287      * actually destroyed. When the view is destroyed, we need to clear the
6288      * pointer, or a subsequent surface AddRef() would reference it again.
6289      *
6290      * This is safe because as long as the view still has a reference to the
6291      * texture, the surface is also still alive, and we're called before the
6292      * view releases that reference. */
6293     surface->wined3d_rtv = NULL;
6294 }
6295
6296 static const struct wined3d_parent_ops ddraw_view_wined3d_parent_ops =
6297 {
6298     view_wined3d_object_destroyed,
6299 };
6300
6301 struct wined3d_rendertarget_view *ddraw_surface_get_rendertarget_view(struct ddraw_surface *surface)
6302 {
6303     HRESULT hr;
6304
6305     if (surface->wined3d_rtv)
6306         return surface->wined3d_rtv;
6307
6308     if (FAILED(hr = wined3d_rendertarget_view_create_from_surface(surface->wined3d_surface,
6309             surface, &ddraw_view_wined3d_parent_ops, &surface->wined3d_rtv)))
6310     {
6311         ERR("Failed to create rendertarget view, hr %#x.\n", hr);
6312         return NULL;
6313     }
6314
6315     return surface->wined3d_rtv;
6316 }