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