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