git.oblomov.eu Git - wine/blob - dlls/ddraw/ddraw.c

   1 /*
   2  * Copyright 1997-2000 Marcus Meissner
   3  * Copyright 1998-2000 Lionel Ulmer
   4  * Copyright 2000-2001 TransGaming Technologies Inc.
   5  * Copyright 2006 Stefan Dösinger
   6  * Copyright 2008 Denver Gingerich
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <assert.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30
  31 #define COBJMACROS
  32 #define NONAMELESSUNION
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winerror.h"
  37 #include "wingdi.h"
  38 #include "wine/exception.h"
  39
  40 #include "ddraw.h"
  41 #include "d3d.h"
  42
  43 #include "ddraw_private.h"
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  47
  48 static BOOL IDirectDrawImpl_DDSD_Match(const DDSURFACEDESC2* requested, const DDSURFACEDESC2* provided);
  49 static HRESULT WINAPI IDirectDrawImpl_AttachD3DDevice(IDirectDrawImpl *This, IDirectDrawSurfaceImpl *primary);
  50 static HRESULT WINAPI IDirectDrawImpl_CreateNewSurface(IDirectDrawImpl *This, DDSURFACEDESC2 *pDDSD, IDirectDrawSurfaceImpl **ppSurf, UINT level);
  51
  52 /* Device identifier. Don't relay it to WineD3D */
  53 static const DDDEVICEIDENTIFIER2 deviceidentifier =
  54 {
  55     "display",
  56     "DirectDraw HAL",
  57     { { 0x00010001, 0x00010001 } },
  58     0, 0, 0, 0,
  59     /* a8373c10-7ac4-4deb-849a-009844d08b2d */
  60     {0xa8373c10,0x7ac4,0x4deb, {0x84,0x9a,0x00,0x98,0x44,0xd0,0x8b,0x2d}},
  61     0
  62 };
  63
  64 /*****************************************************************************
  65  * IUnknown Methods
  66  *****************************************************************************/
  67
  68 /*****************************************************************************
  69  * IDirectDraw7::QueryInterface
  70  *
  71  * Queries different interfaces of the DirectDraw object. It can return
  72  * IDirectDraw interfaces in version 1, 2, 4 and 7, and IDirect3D interfaces
  73  * in version 1, 2, 3 and 7. An IDirect3DDevice can be created with this
  74  * method.
  75  * The returned interface is AddRef()-ed before it's returned
  76  *
  77  * Used for version 1, 2, 4 and 7
  78  *
  79  * Params:
  80  *  refiid: Interface ID asked for
  81  *  obj: Used to return the interface pointer
  82  *
  83  * Returns:
  84  *  S_OK if an interface was found
  85  *  E_NOINTERFACE if the requested interface wasn't found
  86  *
  87  *****************************************************************************/
  88 static HRESULT WINAPI
  89 IDirectDrawImpl_QueryInterface(IDirectDraw7 *iface,
  90                                REFIID refiid,
  91                                void **obj)
  92 {
  93     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
  94
  95     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(refiid), obj);
  96
  97     /* Can change surface impl type */
  98     EnterCriticalSection(&ddraw_cs);
  99
 100     /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
 101     *obj = NULL;
 102
 103     if(!refiid)
 104     {
 105         LeaveCriticalSection(&ddraw_cs);
 106         return DDERR_INVALIDPARAMS;
 107     }
 108
 109     /* Check DirectDraw Interfaces */
 110     if ( IsEqualGUID( &IID_IUnknown, refiid ) ||
 111          IsEqualGUID( &IID_IDirectDraw7, refiid ) )
 112     {
 113         *obj = ICOM_INTERFACE(This, IDirectDraw7);
 114         TRACE("(%p) Returning IDirectDraw7 interface at %p\n", This, *obj);
 115     }
 116     else if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) )
 117     {
 118         *obj = ICOM_INTERFACE(This, IDirectDraw4);
 119         TRACE("(%p) Returning IDirectDraw4 interface at %p\n", This, *obj);
 120     }
 121     else if ( IsEqualGUID( &IID_IDirectDraw3, refiid ) )
 122     {
 123         *obj = ICOM_INTERFACE(This, IDirectDraw3);
 124         TRACE("(%p) Returning IDirectDraw3 interface at %p\n", This, *obj);
 125     }
 126     else if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) )
 127     {
 128         *obj = ICOM_INTERFACE(This, IDirectDraw2);
 129         TRACE("(%p) Returning IDirectDraw2 interface at %p\n", This, *obj);
 130     }
 131     else if ( IsEqualGUID( &IID_IDirectDraw, refiid ) )
 132     {
 133         *obj = ICOM_INTERFACE(This, IDirectDraw);
 134         TRACE("(%p) Returning IDirectDraw interface at %p\n", This, *obj);
 135     }
 136
 137     /* Direct3D
 138      * The refcount unit test revealed that an IDirect3D7 interface can only be queried
 139      * from a DirectDraw object that was created as an IDirectDraw7 interface. No idea
 140      * who had this idea and why. The older interfaces can query and IDirect3D version
 141      * because they are all created as IDirectDraw(1). This isn't really crucial behavior,
 142      * and messy to implement with the common creation function, so it has been left out here.
 143      */
 144     else if ( IsEqualGUID( &IID_IDirect3D  , refiid ) ||
 145               IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
 146               IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
 147               IsEqualGUID( &IID_IDirect3D7 , refiid ) )
 148     {
 149         /* Check the surface implementation */
 150         if(This->ImplType == SURFACE_UNKNOWN)
 151         {
 152             /* Apps may create the IDirect3D Interface before the primary surface.
 153              * set the surface implementation */
 154             This->ImplType = SURFACE_OPENGL;
 155             TRACE("(%p) Choosing OpenGL surfaces because a Direct3D interface was requested\n", This);
 156         }
 157         else if(This->ImplType != SURFACE_OPENGL && DefaultSurfaceType == SURFACE_UNKNOWN)
 158         {
 159             ERR("(%p) The App is requesting a D3D device, but a non-OpenGL surface type was choosen. Prepare for trouble!\n", This);
 160             ERR(" (%p) You may want to contact wine-devel for help\n", This);
 161             /* Should I assert(0) here??? */
 162         }
 163         else if(This->ImplType != SURFACE_OPENGL)
 164         {
 165             WARN("The app requests a Direct3D interface, but non-opengl surfaces where set in winecfg\n");
 166             /* Do not abort here, only reject 3D Device creation */
 167         }
 168
 169         if ( IsEqualGUID( &IID_IDirect3D  , refiid ) )
 170         {
 171             This->d3dversion = 1;
 172             *obj = ICOM_INTERFACE(This, IDirect3D);
 173             TRACE(" returning Direct3D interface at %p.\n", *obj);
 174         }
 175         else if ( IsEqualGUID( &IID_IDirect3D2  , refiid ) )
 176         {
 177             This->d3dversion = 2;
 178             *obj = ICOM_INTERFACE(This, IDirect3D2);
 179             TRACE(" returning Direct3D2 interface at %p.\n", *obj);
 180         }
 181         else if ( IsEqualGUID( &IID_IDirect3D3  , refiid ) )
 182         {
 183             This->d3dversion = 3;
 184             *obj = ICOM_INTERFACE(This, IDirect3D3);
 185             TRACE(" returning Direct3D3 interface at %p.\n", *obj);
 186         }
 187         else if(IsEqualGUID( &IID_IDirect3D7  , refiid ))
 188         {
 189             This->d3dversion = 7;
 190             *obj = ICOM_INTERFACE(This, IDirect3D7);
 191             TRACE(" returning Direct3D7 interface at %p.\n", *obj);
 192         }
 193     }
 194
 195     /* Unknown interface */
 196     else
 197     {
 198         ERR("(%p)->(%s, %p): No interface found\n", This, debugstr_guid(refiid), obj);
 199         LeaveCriticalSection(&ddraw_cs);
 200         return E_NOINTERFACE;
 201     }
 202
 203     IUnknown_AddRef( (IUnknown *) *obj );
 204     LeaveCriticalSection(&ddraw_cs);
 205     return S_OK;
 206 }
 207
 208 /*****************************************************************************
 209  * IDirectDraw7::AddRef
 210  *
 211  * Increases the interfaces refcount, basically
 212  *
 213  * DDraw refcounting is a bit tricky. The different DirectDraw interface
 214  * versions have individual refcounts, but the IDirect3D interfaces do not.
 215  * All interfaces are from one object, that means calling QueryInterface on an
 216  * IDirectDraw7 interface for an IDirectDraw4 interface does not create a new
 217  * IDirectDrawImpl object.
 218  *
 219  * That means all AddRef and Release implementations of IDirectDrawX work
 220  * with their own counter, and IDirect3DX::AddRef thunk to IDirectDraw (1),
 221  * except of IDirect3D7 which thunks to IDirectDraw7
 222  *
 223  * Returns: The new refcount
 224  *
 225  *****************************************************************************/
 226 static ULONG WINAPI
 227 IDirectDrawImpl_AddRef(IDirectDraw7 *iface)
 228 {
 229     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 230     ULONG ref = InterlockedIncrement(&This->ref7);
 231
 232     TRACE("(%p) : incrementing IDirectDraw7 refcount from %u.\n", This, ref -1);
 233
 234     if(ref == 1) InterlockedIncrement(&This->numIfaces);
 235
 236     return ref;
 237 }
 238
 239 /*****************************************************************************
 240  * IDirectDrawImpl_Destroy
 241  *
 242  * Destroys a ddraw object if all refcounts are 0. This is to share code
 243  * between the IDirectDrawX::Release functions
 244  *
 245  * Params:
 246  *  This: DirectDraw object to destroy
 247  *
 248  *****************************************************************************/
 249 void
 250 IDirectDrawImpl_Destroy(IDirectDrawImpl *This)
 251 {
 252     /* Clear the cooplevel to restore window and display mode */
 253     IDirectDraw7_SetCooperativeLevel(ICOM_INTERFACE(This, IDirectDraw7),
 254                                         NULL,
 255                                         DDSCL_NORMAL);
 256
 257     /* Destroy the device window if we created one */
 258     if(This->devicewindow != 0)
 259     {
 260         TRACE(" (%p) Destroying the device window %p\n", This, This->devicewindow);
 261         DestroyWindow(This->devicewindow);
 262         This->devicewindow = 0;
 263     }
 264
 265     /* Unregister the window class */
 266     UnregisterClassA(This->classname, 0);
 267
 268     EnterCriticalSection(&ddraw_cs);
 269     list_remove(&This->ddraw_list_entry);
 270     LeaveCriticalSection(&ddraw_cs);
 271
 272     /* Release the attached WineD3D stuff */
 273     IWineD3DDevice_Release(This->wineD3DDevice);
 274     IWineD3D_Release(This->wineD3D);
 275
 276     /* Now free the object */
 277     HeapFree(GetProcessHeap(), 0, This);
 278 }
 279
 280 /*****************************************************************************
 281  * IDirectDraw7::Release
 282  *
 283  * Decreases the refcount. If the refcount falls to 0, the object is destroyed
 284  *
 285  * Returns: The new refcount
 286  *****************************************************************************/
 287 static ULONG WINAPI
 288 IDirectDrawImpl_Release(IDirectDraw7 *iface)
 289 {
 290     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 291     ULONG ref = InterlockedDecrement(&This->ref7);
 292
 293     TRACE("(%p)->() decrementing IDirectDraw7 refcount from %u.\n", This, ref +1);
 294
 295     if(ref == 0)
 296     {
 297         ULONG ifacecount = InterlockedDecrement(&This->numIfaces);
 298         if(ifacecount == 0) IDirectDrawImpl_Destroy(This);
 299     }
 300
 301     return ref;
 302 }
 303
 304 /*****************************************************************************
 305  * IDirectDraw methods
 306  *****************************************************************************/
 307
 308 /*****************************************************************************
 309  * IDirectDraw7::SetCooperativeLevel
 310  *
 311  * Sets the cooperative level for the DirectDraw object, and the window
 312  * assigned to it. The cooperative level determines the general behavior
 313  * of the DirectDraw application
 314  *
 315  * Warning: This is quite tricky, as it's not really documented which
 316  * cooperative levels can be combined with each other. If a game fails
 317  * after this function, try to check the cooperative levels passed on
 318  * Windows, and if it returns something different.
 319  *
 320  * If you think that this function caused the failure because it writes a
 321  * fixme, be sure to run again with a +ddraw trace.
 322  *
 323  * What is known about cooperative levels (See the ddraw modes test):
 324  * DDSCL_EXCLUSIVE and DDSCL_FULLSCREEN must be used with each other
 325  * DDSCL_NORMAL is not compatible with DDSCL_EXCLUSIVE or DDSCL_FULLSCREEN
 326  * DDSCL_SETFOCUSWINDOW can be passed only in DDSCL_NORMAL mode, but after that
 327  * DDSCL_FULLSCREEN can be activated
 328  * DDSCL_SETFOCUSWINDOW may only be used with DDSCL_NOWINDOWCHANGES
 329  *
 330  * Handled flags: DDSCL_NORMAL, DDSCL_FULLSCREEN, DDSCL_EXCLUSIVE,
 331  *                DDSCL_SETFOCUSWINDOW (partially),
 332  *                DDSCL_MULTITHREADED (work in progress)
 333  *
 334  * Unhandled flags, which should be implemented
 335  *  DDSCL_SETDEVICEWINDOW: Sets a window specially used for rendering (I don't
 336  *  expect any difference to a normal window for wine)
 337  *  DDSCL_CREATEDEVICEWINDOW: Tells ddraw to create its own window for
 338  *  rendering (Possible test case: Half-life)
 339  *
 340  * Unsure about these: DDSCL_FPUSETUP DDSCL_FPURESERVE
 341  *
 342  * These don't seem very important for wine:
 343  *  DDSCL_ALLOWREBOOT, DDSCL_NOWINDOWCHANGES, DDSCL_ALLOWMODEX
 344  *
 345  * Returns:
 346  *  DD_OK if the cooperative level was set successfully
 347  *  DDERR_INVALIDPARAMS if the passed cooperative level combination is invalid
 348  *  DDERR_HWNDALREADYSET if DDSCL_SETFOCUSWINDOW is passed in exclusive mode
 349  *   (Probably others too, have to investigate)
 350  *
 351  *****************************************************************************/
 352 static HRESULT WINAPI
 353 IDirectDrawImpl_SetCooperativeLevel(IDirectDraw7 *iface,
 354                                     HWND hwnd,
 355                                     DWORD cooplevel)
 356 {
 357     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 358     HWND window;
 359     HRESULT hr;
 360
 361     TRACE("(%p)->(%p,%08x)\n",This,hwnd,cooplevel);
 362     DDRAW_dump_cooperativelevel(cooplevel);
 363
 364     EnterCriticalSection(&ddraw_cs);
 365
 366     /* Get the old window */
 367     hr = IWineD3DDevice_GetHWND(This->wineD3DDevice, &window);
 368     if(hr != D3D_OK)
 369     {
 370         ERR("IWineD3DDevice::GetHWND failed, hr = %08x\n", hr);
 371         LeaveCriticalSection(&ddraw_cs);
 372         return hr;
 373     }
 374
 375     /* Tests suggest that we need one of them: */
 376     if(!(cooplevel & (DDSCL_SETFOCUSWINDOW |
 377                       DDSCL_NORMAL         |
 378                       DDSCL_EXCLUSIVE      )))
 379     {
 380         TRACE("Incorrect cooplevel flags, returning DDERR_INVALIDPARAMS\n");
 381         LeaveCriticalSection(&ddraw_cs);
 382         return DDERR_INVALIDPARAMS;
 383     }
 384
 385     /* Handle those levels first which set various hwnds */
 386     if(cooplevel & DDSCL_SETFOCUSWINDOW)
 387     {
 388         /* This isn't compatible with a lot of flags */
 389         if(cooplevel & ( DDSCL_MULTITHREADED   |
 390                          DDSCL_FPUSETUP        |
 391                          DDSCL_FPUPRESERVE     |
 392                          DDSCL_ALLOWREBOOT     |
 393                          DDSCL_ALLOWMODEX      |
 394                          DDSCL_SETDEVICEWINDOW |
 395                          DDSCL_NORMAL          |
 396                          DDSCL_EXCLUSIVE       |
 397                          DDSCL_FULLSCREEN      ) )
 398         {
 399             TRACE("Called with incompatible flags, returning DDERR_INVALIDPARAMS\n");
 400             LeaveCriticalSection(&ddraw_cs);
 401             return DDERR_INVALIDPARAMS;
 402         }
 403         else if( (This->cooperative_level & DDSCL_FULLSCREEN) && window)
 404         {
 405             TRACE("Setting DDSCL_SETFOCUSWINDOW with an already set window, returning DDERR_HWNDALREADYSET\n");
 406             LeaveCriticalSection(&ddraw_cs);
 407             return DDERR_HWNDALREADYSET;
 408         }
 409
 410         This->focuswindow = hwnd;
 411         /* Won't use the hwnd param for anything else */
 412         hwnd = NULL;
 413
 414         /* Use the focus window for drawing too */
 415         IWineD3DDevice_SetHWND(This->wineD3DDevice, This->focuswindow);
 416
 417         /* Destroy the device window, if we have one */
 418         if(This->devicewindow)
 419         {
 420             DestroyWindow(This->devicewindow);
 421             This->devicewindow = NULL;
 422         }
 423     }
 424     /* DDSCL_NORMAL or DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE */
 425     if(cooplevel & DDSCL_NORMAL)
 426     {
 427         /* Can't coexist with fullscreen or exclusive */
 428         if(cooplevel & (DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE) )
 429         {
 430             TRACE("(%p) DDSCL_NORMAL is not compative with DDSCL_FULLSCREEN or DDSCL_EXCLUSIVE\n", This);
 431             LeaveCriticalSection(&ddraw_cs);
 432             return DDERR_INVALIDPARAMS;
 433         }
 434
 435         /* Switching from fullscreen? */
 436         if(This->cooperative_level & DDSCL_FULLSCREEN)
 437         {
 438             /* Restore the display mode */
 439             IDirectDraw7_RestoreDisplayMode(iface);
 440
 441             This->cooperative_level &= ~DDSCL_FULLSCREEN;
 442             This->cooperative_level &= ~DDSCL_EXCLUSIVE;
 443             This->cooperative_level &= ~DDSCL_ALLOWMODEX;
 444         }
 445
 446         /* Don't override focus windows or private device windows */
 447         if( hwnd &&
 448             !(This->focuswindow) &&
 449             !(This->devicewindow) &&
 450             (hwnd != window) )
 451         {
 452             IWineD3DDevice_SetHWND(This->wineD3DDevice, hwnd);
 453         }
 454
 455         IWineD3DDevice_SetFullscreen(This->wineD3DDevice,
 456                                      FALSE);
 457     }
 458     else if(cooplevel & DDSCL_FULLSCREEN)
 459     {
 460         /* Needs DDSCL_EXCLUSIVE */
 461         if(!(cooplevel & DDSCL_EXCLUSIVE) )
 462         {
 463             TRACE("(%p) DDSCL_FULLSCREEN needs DDSCL_EXCLUSIVE\n", This);
 464             LeaveCriticalSection(&ddraw_cs);
 465             return DDERR_INVALIDPARAMS;
 466         }
 467         /* Need a HWND
 468         if(hwnd == 0)
 469         {
 470             TRACE("(%p) DDSCL_FULLSCREEN needs a HWND\n", This);
 471             return DDERR_INVALIDPARAMS;
 472         }
 473         */
 474
 475         This->cooperative_level &= ~DDSCL_NORMAL;
 476         IWineD3DDevice_SetFullscreen(This->wineD3DDevice,
 477                                      TRUE);
 478
 479         /* Don't override focus windows or private device windows */
 480         if( hwnd &&
 481             !(This->focuswindow) &&
 482             !(This->devicewindow) &&
 483             (hwnd != window) )
 484         {
 485             IWineD3DDevice_SetHWND(This->wineD3DDevice, hwnd);
 486         }
 487     }
 488     else if(cooplevel & DDSCL_EXCLUSIVE)
 489     {
 490         TRACE("(%p) DDSCL_EXCLUSIVE needs DDSCL_FULLSCREEN\n", This);
 491         LeaveCriticalSection(&ddraw_cs);
 492         return DDERR_INVALIDPARAMS;
 493     }
 494
 495     if(cooplevel & DDSCL_CREATEDEVICEWINDOW)
 496     {
 497         /* Don't create a device window if a focus window is set */
 498         if( !(This->focuswindow) )
 499         {
 500             HWND devicewindow = CreateWindowExA(0, This->classname, "DDraw device window",
 501                                                 WS_POPUP, 0, 0,
 502                                                 GetSystemMetrics(SM_CXSCREEN),
 503                                                 GetSystemMetrics(SM_CYSCREEN),
 504                                                 NULL, NULL, GetModuleHandleA(0), NULL);
 505
 506             ShowWindow(devicewindow, SW_SHOW);   /* Just to be sure */
 507             TRACE("(%p) Created a DDraw device window. HWND=%p\n", This, devicewindow);
 508
 509             IWineD3DDevice_SetHWND(This->wineD3DDevice, devicewindow);
 510             This->devicewindow = devicewindow;
 511         }
 512     }
 513
 514     if(cooplevel & DDSCL_MULTITHREADED && !(This->cooperative_level & DDSCL_MULTITHREADED))
 515     {
 516         /* Enable thread safety in wined3d */
 517         IWineD3DDevice_SetMultithreaded(This->wineD3DDevice);
 518     }
 519
 520     /* Unhandled flags */
 521     if(cooplevel & DDSCL_ALLOWREBOOT)
 522         WARN("(%p) Unhandled flag DDSCL_ALLOWREBOOT, harmless\n", This);
 523     if(cooplevel & DDSCL_ALLOWMODEX)
 524         WARN("(%p) Unhandled flag DDSCL_ALLOWMODEX, harmless\n", This);
 525     if(cooplevel & DDSCL_FPUSETUP)
 526         WARN("(%p) Unhandled flag DDSCL_FPUSETUP, harmless\n", This);
 527     if(cooplevel & DDSCL_FPUPRESERVE)
 528         WARN("(%p) Unhandled flag DDSCL_FPUPRESERVE, harmless\n", This);
 529
 530     /* Store the cooperative_level */
 531     This->cooperative_level |= cooplevel;
 532     TRACE("SetCooperativeLevel retuning DD_OK\n");
 533     LeaveCriticalSection(&ddraw_cs);
 534     return DD_OK;
 535 }
 536
 537 /*****************************************************************************
 538  *
 539  * Helper function for SetDisplayMode and RestoreDisplayMode
 540  *
 541  * Implements DirectDraw's SetDisplayMode, but ignores the value of
 542  * ForceRefreshRate, since it is already handled by
 543  * IDirectDrawImpl_SetDisplayMode.  RestoreDisplayMode can use this function
 544  * without worrying that ForceRefreshRate will override the refresh rate.  For
 545  * argument and return value documentation, see
 546  * IDirectDrawImpl_SetDisplayMode.
 547  *
 548  *****************************************************************************/
 549 static HRESULT
 550 IDirectDrawImpl_SetDisplayModeNoOverride(IDirectDraw7 *iface,
 551                                          DWORD Width,
 552                                          DWORD Height,
 553                                          DWORD BPP,
 554                                          DWORD RefreshRate,
 555                                          DWORD Flags)
 556 {
 557     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 558     WINED3DDISPLAYMODE Mode;
 559     HRESULT hr;
 560     TRACE("(%p)->(%d,%d,%d,%d,%x: Relay!\n", This, Width, Height, BPP, RefreshRate, Flags);
 561
 562     EnterCriticalSection(&ddraw_cs);
 563     if( !Width || !Height )
 564     {
 565         ERR("Width=%d, Height=%d, what to do?\n", Width, Height);
 566         /* It looks like Need for Speed Porsche Unleashed expects DD_OK here */
 567         LeaveCriticalSection(&ddraw_cs);
 568         return DD_OK;
 569     }
 570
 571     /* Check the exclusive mode
 572     if(!(This->cooperative_level & DDSCL_EXCLUSIVE))
 573         return DDERR_NOEXCLUSIVEMODE;
 574      * This is WRONG. Don't know if the SDK is completely
 575      * wrong and if there are any conditions when DDERR_NOEXCLUSIVE
 576      * is returned, but Half-Life 1.1.1.1 (Steam version)
 577      * depends on this
 578      */
 579
 580     Mode.Width = Width;
 581     Mode.Height = Height;
 582     Mode.RefreshRate = RefreshRate;
 583     switch(BPP)
 584     {
 585         case 8:  Mode.Format = WINED3DFMT_P8;       break;
 586         case 15: Mode.Format = WINED3DFMT_X1R5G5B5; break;
 587         case 16: Mode.Format = WINED3DFMT_R5G6B5;   break;
 588         case 24: Mode.Format = WINED3DFMT_R8G8B8;   break;
 589         case 32: Mode.Format = WINED3DFMT_X8R8G8B8; break;
 590     }
 591
 592     /* TODO: The possible return values from msdn suggest that
 593      * the screen mode can't be changed if a surface is locked
 594      * or some drawing is in progress
 595      */
 596
 597     /* TODO: Lose the primary surface */
 598     hr = IWineD3DDevice_SetDisplayMode(This->wineD3DDevice,
 599                                        0, /* First swapchain */
 600                                        &Mode);
 601     LeaveCriticalSection(&ddraw_cs);
 602     switch(hr)
 603     {
 604         case WINED3DERR_NOTAVAILABLE:       return DDERR_UNSUPPORTED;
 605         default:                            return hr;
 606     };
 607 }
 608
 609 /*****************************************************************************
 610  * IDirectDraw7::SetDisplayMode
 611  *
 612  * Sets the display screen resolution, color depth and refresh frequency
 613  * when in fullscreen mode (in theory).
 614  * Possible return values listed in the SDK suggest that this method fails
 615  * when not in fullscreen mode, but this is wrong. Windows 2000 happily sets
 616  * the display mode in DDSCL_NORMAL mode without an hwnd specified.
 617  * It seems to be valid to pass 0 for With and Height, this has to be tested
 618  * It could mean that the current video mode should be left as-is. (But why
 619  * call it then?)
 620  *
 621  * Params:
 622  *  Height, Width: Screen dimension
 623  *  BPP: Color depth in Bits per pixel
 624  *  Refreshrate: Screen refresh rate
 625  *  Flags: Other stuff
 626  *
 627  * Returns
 628  *  DD_OK on success
 629  *
 630  *****************************************************************************/
 631 static HRESULT WINAPI
 632 IDirectDrawImpl_SetDisplayMode(IDirectDraw7 *iface,
 633                                DWORD Width,
 634                                DWORD Height,
 635                                DWORD BPP,
 636                                DWORD RefreshRate,
 637                                DWORD Flags)
 638 {
 639     if (force_refresh_rate != 0)
 640     {
 641         TRACE("ForceRefreshRate overriding passed-in refresh rate (%d Hz) to %d Hz\n", RefreshRate, force_refresh_rate);
 642         RefreshRate = force_refresh_rate;
 643     }
 644
 645     return IDirectDrawImpl_SetDisplayModeNoOverride(iface, Width, Height, BPP,
 646                                                     RefreshRate, Flags);
 647 }
 648
 649 /*****************************************************************************
 650  * IDirectDraw7::RestoreDisplayMode
 651  *
 652  * Restores the display mode to what it was at creation time. Basically.
 653  *
 654  * A problem arises when there are 2 DirectDraw objects using the same hwnd:
 655  *  -> DD_1 finds the screen at 1400x1050x32 when created, sets it to 640x480x16
 656  *  -> DD_2 is created, finds the screen at 640x480x16, sets it to 1024x768x32
 657  *  -> DD_1 is released. The screen should be left at 1024x768x32.
 658  *  -> DD_2 is released. The screen should be set to 1400x1050x32
 659  * This case is unhandled right now, but Empire Earth does it this way.
 660  * (But perhaps there is something in SetCooperativeLevel to prevent this)
 661  *
 662  * The msdn says that this method resets the display mode to what it was before
 663  * SetDisplayMode was called. What if SetDisplayModes is called 2 times??
 664  *
 665  * Returns
 666  *  DD_OK on success
 667  *  DDERR_NOEXCLUSIVE mode if the device isn't in fullscreen mode
 668  *
 669  *****************************************************************************/
 670 static HRESULT WINAPI
 671 IDirectDrawImpl_RestoreDisplayMode(IDirectDraw7 *iface)
 672 {
 673     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 674     TRACE("(%p)\n", This);
 675
 676     return IDirectDrawImpl_SetDisplayModeNoOverride(ICOM_INTERFACE(This, IDirectDraw7),
 677                                                     This->orig_width,
 678                                                     This->orig_height,
 679                                                     This->orig_bpp,
 680                                                     0,
 681                                                     0);
 682 }
 683
 684 /*****************************************************************************
 685  * IDirectDraw7::GetCaps
 686  *
 687  * Returns the drives capabilities
 688  *
 689  * Used for version 1, 2, 4 and 7
 690  *
 691  * Params:
 692  *  DriverCaps: Structure to write the Hardware accelerated caps to
 693  *  HelCaps: Structure to write the emulation caps to
 694  *
 695  * Returns
 696  *  This implementation returns DD_OK only
 697  *
 698  *****************************************************************************/
 699 static HRESULT WINAPI
 700 IDirectDrawImpl_GetCaps(IDirectDraw7 *iface,
 701                         DDCAPS *DriverCaps,
 702                         DDCAPS *HELCaps)
 703 {
 704     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 705     TRACE("(%p)->(%p,%p)\n", This, DriverCaps, HELCaps);
 706
 707     /* One structure must be != NULL */
 708     if( (!DriverCaps) && (!HELCaps) )
 709     {
 710         ERR("(%p) Invalid params to IDirectDrawImpl_GetCaps\n", This);
 711         return DDERR_INVALIDPARAMS;
 712     }
 713
 714     if(DriverCaps)
 715     {
 716         DD_STRUCT_COPY_BYSIZE(DriverCaps, &This->caps);
 717         if (TRACE_ON(ddraw))
 718         {
 719             TRACE("Driver Caps :\n");
 720             DDRAW_dump_DDCAPS(DriverCaps);
 721         }
 722
 723     }
 724     if(HELCaps)
 725     {
 726         DD_STRUCT_COPY_BYSIZE(HELCaps, &This->caps);
 727         if (TRACE_ON(ddraw))
 728         {
 729             TRACE("HEL Caps :\n");
 730             DDRAW_dump_DDCAPS(HELCaps);
 731         }
 732     }
 733
 734     return DD_OK;
 735 }
 736
 737 /*****************************************************************************
 738  * IDirectDraw7::Compact
 739  *
 740  * No idea what it does, MSDN says it's not implemented.
 741  *
 742  * Returns
 743  *  DD_OK, but this is unchecked
 744  *
 745  *****************************************************************************/
 746 static HRESULT WINAPI
 747 IDirectDrawImpl_Compact(IDirectDraw7 *iface)
 748 {
 749     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 750     TRACE("(%p)\n", This);
 751
 752     return DD_OK;
 753 }
 754
 755 /*****************************************************************************
 756  * IDirectDraw7::GetDisplayMode
 757  *
 758  * Returns information about the current display mode
 759  *
 760  * Exists in Version 1, 2, 4 and 7
 761  *
 762  * Params:
 763  *  DDSD: Address of a surface description structure to write the info to
 764  *
 765  * Returns
 766  *  DD_OK
 767  *
 768  *****************************************************************************/
 769 static HRESULT WINAPI
 770 IDirectDrawImpl_GetDisplayMode(IDirectDraw7 *iface,
 771                                DDSURFACEDESC2 *DDSD)
 772 {
 773     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 774     HRESULT hr;
 775     WINED3DDISPLAYMODE Mode;
 776     DWORD Size;
 777     TRACE("(%p)->(%p): Relay\n", This, DDSD);
 778
 779     EnterCriticalSection(&ddraw_cs);
 780     /* This seems sane */
 781     if(!DDSD)
 782     {
 783         LeaveCriticalSection(&ddraw_cs);
 784         return DDERR_INVALIDPARAMS;
 785     }
 786
 787     /* The necessary members of LPDDSURFACEDESC and LPDDSURFACEDESC2 are equal,
 788      * so one method can be used for all versions (Hopefully)
 789      */
 790     hr = IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
 791                                       0 /* swapchain 0 */,
 792                                       &Mode);
 793     if( hr != D3D_OK )
 794     {
 795         ERR(" (%p) IWineD3DDevice::GetDisplayMode returned %08x\n", This, hr);
 796         LeaveCriticalSection(&ddraw_cs);
 797         return hr;
 798     }
 799
 800     Size = DDSD->dwSize;
 801     memset(DDSD, 0, Size);
 802
 803     DDSD->dwSize = Size;
 804     DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
 805     DDSD->dwWidth = Mode.Width;
 806     DDSD->dwHeight = Mode.Height;
 807     DDSD->u2.dwRefreshRate = 60;
 808     DDSD->ddsCaps.dwCaps = 0;
 809     DDSD->u4.ddpfPixelFormat.dwSize = sizeof(DDSD->u4.ddpfPixelFormat);
 810     PixelFormat_WineD3DtoDD(&DDSD->u4.ddpfPixelFormat, Mode.Format);
 811     DDSD->u1.lPitch = Mode.Width * DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount / 8;
 812
 813     if(TRACE_ON(ddraw))
 814     {
 815         TRACE("Returning surface desc :\n");
 816         DDRAW_dump_surface_desc(DDSD);
 817     }
 818
 819     LeaveCriticalSection(&ddraw_cs);
 820     return DD_OK;
 821 }
 822
 823 /*****************************************************************************
 824  * IDirectDraw7::GetFourCCCodes
 825  *
 826  * Returns an array of supported FourCC codes.
 827  *
 828  * Exists in Version 1, 2, 4 and 7
 829  *
 830  * Params:
 831  *  NumCodes: Contains the number of Codes that Codes can carry. Returns the number
 832  *            of enumerated codes
 833  *  Codes: Pointer to an array of DWORDs where the supported codes are written
 834  *         to
 835  *
 836  * Returns
 837  *  Always returns DD_OK, as it's a stub for now
 838  *
 839  *****************************************************************************/
 840 static HRESULT WINAPI
 841 IDirectDrawImpl_GetFourCCCodes(IDirectDraw7 *iface,
 842                                DWORD *NumCodes, DWORD *Codes)
 843 {
 844     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 845     FIXME("(%p)->(%p, %p): Stub!\n", This, NumCodes, Codes);
 846
 847     if(NumCodes) *NumCodes = 0;
 848
 849     return DD_OK;
 850 }
 851
 852 /*****************************************************************************
 853  * IDirectDraw7::GetMonitorFrequency
 854  *
 855  * Returns the monitor's frequency
 856  *
 857  * Exists in Version 1, 2, 4 and 7
 858  *
 859  * Params:
 860  *  Freq: Pointer to a DWORD to write the frequency to
 861  *
 862  * Returns
 863  *  Always returns DD_OK
 864  *
 865  *****************************************************************************/
 866 static HRESULT WINAPI
 867 IDirectDrawImpl_GetMonitorFrequency(IDirectDraw7 *iface,
 868                                     DWORD *Freq)
 869 {
 870     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 871     TRACE("(%p)->(%p)\n", This, Freq);
 872
 873     /* Ideally this should be in WineD3D, as it concerns the screen setup,
 874      * but for now this should make the games happy
 875      */
 876     *Freq = 60;
 877     return DD_OK;
 878 }
 879
 880 /*****************************************************************************
 881  * IDirectDraw7::GetVerticalBlankStatus
 882  *
 883  * Returns the Vertical blank status of the monitor. This should be in WineD3D
 884  * too basically, but as it's a semi stub, I didn't create a function there
 885  *
 886  * Params:
 887  *  status: Pointer to a BOOL to be filled with the vertical blank status
 888  *
 889  * Returns
 890  *  DD_OK on success
 891  *  DDERR_INVALIDPARAMS if status is NULL
 892  *
 893  *****************************************************************************/
 894 static HRESULT WINAPI
 895 IDirectDrawImpl_GetVerticalBlankStatus(IDirectDraw7 *iface,
 896                                        BOOL *status)
 897 {
 898     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 899     TRACE("(%p)->(%p)\n", This, status);
 900
 901     /* This looks sane, the MSDN suggests it too */
 902     EnterCriticalSection(&ddraw_cs);
 903     if(!status)
 904     {
 905         LeaveCriticalSection(&ddraw_cs);
 906         return DDERR_INVALIDPARAMS;
 907     }
 908
 909     *status = This->fake_vblank;
 910     This->fake_vblank = !This->fake_vblank;
 911     LeaveCriticalSection(&ddraw_cs);
 912     return DD_OK;
 913 }
 914
 915 /*****************************************************************************
 916  * IDirectDraw7::GetAvailableVidMem
 917  *
 918  * Returns the total and free video memory
 919  *
 920  * Params:
 921  *  Caps: Specifies the memory type asked for
 922  *  total: Pointer to a DWORD to be filled with the total memory
 923  *  free: Pointer to a DWORD to be filled with the free memory
 924  *
 925  * Returns
 926  *  DD_OK on success
 927  *  DDERR_INVALIDPARAMS of free and total are NULL
 928  *
 929  *****************************************************************************/
 930 static HRESULT WINAPI
 931 IDirectDrawImpl_GetAvailableVidMem(IDirectDraw7 *iface, DDSCAPS2 *Caps, DWORD *total, DWORD *free)
 932 {
 933     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 934     TRACE("(%p)->(%p, %p, %p)\n", This, Caps, total, free);
 935
 936     if(TRACE_ON(ddraw))
 937     {
 938         TRACE("(%p) Asked for memory with description: ", This);
 939         DDRAW_dump_DDSCAPS2(Caps);
 940     }
 941     EnterCriticalSection(&ddraw_cs);
 942
 943     /* Todo: System memory vs local video memory vs non-local video memory
 944      * The MSDN also mentions differences between texture memory and other
 945      * resources, but that's not important
 946      */
 947
 948     if( (!total) && (!free) )
 949     {
 950         LeaveCriticalSection(&ddraw_cs);
 951         return DDERR_INVALIDPARAMS;
 952     }
 953
 954     if(total) *total = This->total_vidmem;
 955     if(free) *free = IWineD3DDevice_GetAvailableTextureMem(This->wineD3DDevice);
 956
 957     LeaveCriticalSection(&ddraw_cs);
 958     return DD_OK;
 959 }
 960
 961 /*****************************************************************************
 962  * IDirectDraw7::Initialize
 963  *
 964  * Initializes a DirectDraw interface.
 965  *
 966  * Params:
 967  *  GUID: Interface identifier. Well, don't know what this is really good
 968  *   for
 969  *
 970  * Returns
 971  *  Returns DD_OK on the first call,
 972  *  DDERR_ALREADYINITIALIZED on repeated calls
 973  *
 974  *****************************************************************************/
 975 static HRESULT WINAPI
 976 IDirectDrawImpl_Initialize(IDirectDraw7 *iface,
 977                            GUID *Guid)
 978 {
 979     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
 980     TRACE("(%p)->(%s): No-op\n", This, debugstr_guid(Guid));
 981
 982     if(This->initialized)
 983     {
 984         return DDERR_ALREADYINITIALIZED;
 985     }
 986     else
 987     {
 988         return DD_OK;
 989     }
 990 }
 991
 992 /*****************************************************************************
 993  * IDirectDraw7::FlipToGDISurface
 994  *
 995  * "Makes the surface that the GDI writes to the primary surface"
 996  * Looks like some windows specific thing we don't have to care about.
 997  * According to MSDN it permits GDI dialog boxes in FULLSCREEN mode. Good to
 998  * show error boxes ;)
 999  * Well, just return DD_OK.
1000  *
1001  * Returns:
1002  *  Always returns DD_OK
1003  *
1004  *****************************************************************************/
1005 static HRESULT WINAPI
1006 IDirectDrawImpl_FlipToGDISurface(IDirectDraw7 *iface)
1007 {
1008     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1009     TRACE("(%p)\n", This);
1010
1011     return DD_OK;
1012 }
1013
1014 /*****************************************************************************
1015  * IDirectDraw7::WaitForVerticalBlank
1016  *
1017  * This method allows applications to get in sync with the vertical blank
1018  * interval.
1019  * The wormhole demo in the DirectX 7 sdk uses this call, and it doesn't
1020  * redraw the screen, most likely because of this stub
1021  *
1022  * Parameters:
1023  *  Flags: one of DDWAITVB_BLOCKBEGIN, DDWAITVB_BLOCKBEGINEVENT
1024  *         or DDWAITVB_BLOCKEND
1025  *  h: Not used, according to MSDN
1026  *
1027  * Returns:
1028  *  Always returns DD_OK
1029  *
1030  *****************************************************************************/
1031 static HRESULT WINAPI
1032 IDirectDrawImpl_WaitForVerticalBlank(IDirectDraw7 *iface,
1033                                      DWORD Flags,
1034                                      HANDLE h)
1035 {
1036     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1037     FIXME("(%p)->(%x,%p): Stub\n", This, Flags, h);
1038
1039     /* MSDN says DDWAITVB_BLOCKBEGINEVENT is not supported */
1040     if(Flags & DDWAITVB_BLOCKBEGINEVENT)
1041         return DDERR_UNSUPPORTED; /* unchecked */
1042
1043     return DD_OK;
1044 }
1045
1046 /*****************************************************************************
1047  * IDirectDraw7::GetScanLine
1048  *
1049  * Returns the scan line that is being drawn on the monitor
1050  *
1051  * Parameters:
1052  *  Scanline: Address to write the scan line value to
1053  *
1054  * Returns:
1055  *  Always returns DD_OK
1056  *
1057  *****************************************************************************/
1058 static HRESULT WINAPI IDirectDrawImpl_GetScanLine(IDirectDraw7 *iface, DWORD *Scanline)
1059 {
1060     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1061     static BOOL hide = FALSE;
1062     WINED3DDISPLAYMODE Mode;
1063
1064     /* This function is called often, so print the fixme only once */
1065     EnterCriticalSection(&ddraw_cs);
1066     if(!hide)
1067     {
1068         FIXME("(%p)->(%p): Semi-Stub\n", This, Scanline);
1069         hide = TRUE;
1070     }
1071
1072     IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
1073                                   0,
1074                                   &Mode);
1075
1076     /* Fake the line sweeping of the monitor */
1077     /* FIXME: We should synchronize with a source to keep the refresh rate */
1078     *Scanline = This->cur_scanline++;
1079     /* Assume 20 scan lines in the vertical blank */
1080     if (This->cur_scanline >= Mode.Height + 20)
1081         This->cur_scanline = 0;
1082
1083     LeaveCriticalSection(&ddraw_cs);
1084     return DD_OK;
1085 }
1086
1087 /*****************************************************************************
1088  * IDirectDraw7::TestCooperativeLevel
1089  *
1090  * Informs the application about the state of the video adapter, depending
1091  * on the cooperative level
1092  *
1093  * Returns:
1094  *  DD_OK if the device is in a sane state
1095  *  DDERR_NOEXCLUSIVEMODE or DDERR_EXCLUSIVEMODEALREADYSET
1096  *  if the state is not correct(See below)
1097  *
1098  *****************************************************************************/
1099 static HRESULT WINAPI
1100 IDirectDrawImpl_TestCooperativeLevel(IDirectDraw7 *iface)
1101 {
1102     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1103     HRESULT hr;
1104     TRACE("(%p)\n", This);
1105
1106     EnterCriticalSection(&ddraw_cs);
1107     /* Description from MSDN:
1108      * For fullscreen apps return DDERR_NOEXCLUSIVEMODE if the user switched
1109      * away from the app with e.g. alt-tab. Windowed apps receive
1110      * DDERR_EXCLUSIVEMODEALREADYSET if another application created a
1111      * DirectDraw object in exclusive mode. DDERR_WRONGMODE is returned,
1112      * when the video mode has changed
1113      */
1114
1115     hr =  IWineD3DDevice_TestCooperativeLevel(This->wineD3DDevice);
1116
1117     /* Fix the result value. These values are mapped from their
1118      * d3d9 counterpart.
1119      */
1120     switch(hr)
1121     {
1122         case WINED3DERR_DEVICELOST:
1123             if(This->cooperative_level & DDSCL_EXCLUSIVE)
1124             {
1125                 LeaveCriticalSection(&ddraw_cs);
1126                 return DDERR_NOEXCLUSIVEMODE;
1127             }
1128             else
1129             {
1130                 LeaveCriticalSection(&ddraw_cs);
1131                 return DDERR_EXCLUSIVEMODEALREADYSET;
1132             }
1133
1134         case WINED3DERR_DEVICENOTRESET:
1135             LeaveCriticalSection(&ddraw_cs);
1136             return DD_OK;
1137
1138         case WINED3D_OK:
1139             LeaveCriticalSection(&ddraw_cs);
1140             return DD_OK;
1141
1142         case WINED3DERR_DRIVERINTERNALERROR:
1143         default:
1144             ERR("(%p) Unexpected return value %08x from wineD3D, "
1145                 " returning DD_OK\n", This, hr);
1146     }
1147
1148     LeaveCriticalSection(&ddraw_cs);
1149     return DD_OK;
1150 }
1151
1152 /*****************************************************************************
1153  * IDirectDraw7::GetGDISurface
1154  *
1155  * Returns the surface that GDI is treating as the primary surface.
1156  * For Wine this is the front buffer
1157  *
1158  * Params:
1159  *  GDISurface: Address to write the surface pointer to
1160  *
1161  * Returns:
1162  *  DD_OK if the surface was found
1163  *  DDERR_NOTFOUND if the GDI surface wasn't found
1164  *
1165  *****************************************************************************/
1166 static HRESULT WINAPI
1167 IDirectDrawImpl_GetGDISurface(IDirectDraw7 *iface,
1168                               IDirectDrawSurface7 **GDISurface)
1169 {
1170     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1171     IWineD3DSurface *Surf;
1172     IDirectDrawSurface7 *ddsurf;
1173     HRESULT hr;
1174     DDSCAPS2 ddsCaps;
1175     TRACE("(%p)->(%p)\n", This, GDISurface);
1176
1177     /* Get the back buffer from the wineD3DDevice and search its
1178      * attached surfaces for the front buffer
1179      */
1180     EnterCriticalSection(&ddraw_cs);
1181     hr = IWineD3DDevice_GetBackBuffer(This->wineD3DDevice,
1182                                       0, /* SwapChain */
1183                                       0, /* first back buffer*/
1184                                       WINED3DBACKBUFFER_TYPE_MONO,
1185                                       &Surf);
1186
1187     if( (hr != D3D_OK) ||
1188         (!Surf) )
1189     {
1190         ERR("IWineD3DDevice::GetBackBuffer failed\n");
1191         LeaveCriticalSection(&ddraw_cs);
1192         return DDERR_NOTFOUND;
1193     }
1194
1195     /* GetBackBuffer AddRef()ed the surface, release it */
1196     IWineD3DSurface_Release(Surf);
1197
1198     IWineD3DSurface_GetParent(Surf,
1199                               (IUnknown **) &ddsurf);
1200     IDirectDrawSurface7_Release(ddsurf);  /* For the GetParent */
1201
1202     /* Find the front buffer */
1203     ddsCaps.dwCaps = DDSCAPS_FRONTBUFFER;
1204     hr = IDirectDrawSurface7_GetAttachedSurface(ddsurf,
1205                                                 &ddsCaps,
1206                                                 GDISurface);
1207     if(hr != DD_OK)
1208     {
1209         ERR("IDirectDrawSurface7::GetAttachedSurface failed, hr = %x\n", hr);
1210     }
1211
1212     /* The AddRef is OK this time */
1213     LeaveCriticalSection(&ddraw_cs);
1214     return hr;
1215 }
1216
1217 /*****************************************************************************
1218  * IDirectDraw7::EnumDisplayModes
1219  *
1220  * Enumerates the supported Display modes. The modes can be filtered with
1221  * the DDSD parameter.
1222  *
1223  * Params:
1224  *  Flags: can be DDEDM_REFRESHRATES and DDEDM_STANDARDVGAMODES
1225  *  DDSD: Surface description to filter the modes
1226  *  Context: Pointer passed back to the callback function
1227  *  cb: Application-provided callback function
1228  *
1229  * Returns:
1230  *  DD_OK on success
1231  *  DDERR_INVALIDPARAMS if the callback wasn't set
1232  *
1233  *****************************************************************************/
1234 static HRESULT WINAPI
1235 IDirectDrawImpl_EnumDisplayModes(IDirectDraw7 *iface,
1236                                  DWORD Flags,
1237                                  DDSURFACEDESC2 *DDSD,
1238                                  void *Context,
1239                                  LPDDENUMMODESCALLBACK2 cb)
1240 {
1241     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1242     unsigned int modenum, fmt;
1243     WINED3DFORMAT pixelformat = WINED3DFMT_UNKNOWN;
1244     WINED3DDISPLAYMODE mode;
1245     DDSURFACEDESC2 callback_sd;
1246
1247     WINED3DFORMAT checkFormatList[] =
1248     {
1249         WINED3DFMT_R8G8B8,
1250         WINED3DFMT_A8R8G8B8,
1251         WINED3DFMT_X8R8G8B8,
1252         WINED3DFMT_R5G6B5,
1253         WINED3DFMT_X1R5G5B5,
1254         WINED3DFMT_A1R5G5B5,
1255         WINED3DFMT_A4R4G4B4,
1256         WINED3DFMT_R3G3B2,
1257         WINED3DFMT_A8R3G3B2,
1258         WINED3DFMT_X4R4G4B4,
1259         WINED3DFMT_A2B10G10R10,
1260         WINED3DFMT_A8B8G8R8,
1261         WINED3DFMT_X8B8G8R8,
1262         WINED3DFMT_A2R10G10B10,
1263         WINED3DFMT_A8P8,
1264         WINED3DFMT_P8
1265     };
1266
1267     TRACE("(%p)->(%p,%p,%p): Relay\n", This, DDSD, Context, cb);
1268
1269     EnterCriticalSection(&ddraw_cs);
1270     /* This looks sane */
1271     if(!cb)
1272     {
1273         LeaveCriticalSection(&ddraw_cs);
1274         return DDERR_INVALIDPARAMS;
1275     }
1276
1277     if(DDSD)
1278     {
1279         if ((DDSD->dwFlags & DDSD_PIXELFORMAT) && (DDSD->u4.ddpfPixelFormat.dwFlags & DDPF_RGB) )
1280             pixelformat = PixelFormat_DD2WineD3D(&DDSD->u4.ddpfPixelFormat);
1281     }
1282
1283     for(fmt = 0; fmt < (sizeof(checkFormatList) / sizeof(checkFormatList[0])); fmt++)
1284     {
1285         if(pixelformat != WINED3DFMT_UNKNOWN && checkFormatList[fmt] != pixelformat)
1286         {
1287             continue;
1288         }
1289
1290         modenum = 0;
1291         while(IWineD3D_EnumAdapterModes(This->wineD3D,
1292                                         WINED3DADAPTER_DEFAULT,
1293                                         checkFormatList[fmt],
1294                                         modenum++,
1295                                         &mode) == WINED3D_OK)
1296         {
1297             if(DDSD)
1298             {
1299                 if(DDSD->dwFlags & DDSD_WIDTH && mode.Width != DDSD->dwWidth) continue;
1300                 if(DDSD->dwFlags & DDSD_HEIGHT && mode.Height != DDSD->dwHeight) continue;
1301             }
1302
1303             memset(&callback_sd, 0, sizeof(callback_sd));
1304             callback_sd.dwSize = sizeof(callback_sd);
1305             callback_sd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1306
1307             callback_sd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH;
1308             if(Flags & DDEDM_REFRESHRATES)
1309             {
1310                 callback_sd.dwFlags |= DDSD_REFRESHRATE;
1311                 callback_sd.u2.dwRefreshRate = mode.RefreshRate;
1312             }
1313
1314             callback_sd.dwWidth = mode.Width;
1315             callback_sd.dwHeight = mode.Height;
1316
1317             PixelFormat_WineD3DtoDD(&callback_sd.u4.ddpfPixelFormat, mode.Format);
1318
1319             /* Calc pitch and DWORD align like MSDN says */
1320             callback_sd.u1.lPitch = (callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8) * mode.Width;
1321             callback_sd.u1.lPitch = (callback_sd.u1.lPitch + 3) & ~3;
1322
1323             TRACE("Enumerating %dx%dx%d @%d\n", callback_sd.dwWidth, callback_sd.dwHeight, callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount,
1324               callback_sd.u2.dwRefreshRate);
1325
1326             if(cb(&callback_sd, Context) == DDENUMRET_CANCEL)
1327             {
1328                 TRACE("Application asked to terminate the enumeration\n");
1329                 LeaveCriticalSection(&ddraw_cs);
1330                 return DD_OK;
1331             }
1332         }
1333     }
1334
1335     TRACE("End of enumeration\n");
1336     LeaveCriticalSection(&ddraw_cs);
1337     return DD_OK;
1338 }
1339
1340 /*****************************************************************************
1341  * IDirectDraw7::EvaluateMode
1342  *
1343  * Used with IDirectDraw7::StartModeTest to test video modes.
1344  * EvaluateMode is used to pass or fail a mode, and continue with the next
1345  * mode
1346  *
1347  * Params:
1348  *  Flags: DDEM_MODEPASSED or DDEM_MODEFAILED
1349  *  Timeout: Returns the amount of seconds left before the mode would have
1350  *           been failed automatically
1351  *
1352  * Returns:
1353  *  This implementation always DD_OK, because it's a stub
1354  *
1355  *****************************************************************************/
1356 static HRESULT WINAPI
1357 IDirectDrawImpl_EvaluateMode(IDirectDraw7 *iface,
1358                              DWORD Flags,
1359                              DWORD *Timeout)
1360 {
1361     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1362     FIXME("(%p)->(%d,%p): Stub!\n", This, Flags, Timeout);
1363
1364     /* When implementing this, implement it in WineD3D */
1365
1366     return DD_OK;
1367 }
1368
1369 /*****************************************************************************
1370  * IDirectDraw7::GetDeviceIdentifier
1371  *
1372  * Returns the device identifier, which gives information about the driver
1373  * Our device identifier is defined at the beginning of this file.
1374  *
1375  * Params:
1376  *  DDDI: Address for the returned structure
1377  *  Flags: Can be DDGDI_GETHOSTIDENTIFIER
1378  *
1379  * Returns:
1380  *  On success it returns DD_OK
1381  *  DDERR_INVALIDPARAMS if DDDI is NULL
1382  *
1383  *****************************************************************************/
1384 static HRESULT WINAPI
1385 IDirectDrawImpl_GetDeviceIdentifier(IDirectDraw7 *iface,
1386                                     DDDEVICEIDENTIFIER2 *DDDI,
1387                                     DWORD Flags)
1388 {
1389     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1390     TRACE("(%p)->(%p,%08x)\n", This, DDDI, Flags);
1391
1392     if(!DDDI)
1393         return DDERR_INVALIDPARAMS;
1394
1395     /* The DDGDI_GETHOSTIDENTIFIER returns the information about the 2D
1396      * host adapter, if there's a secondary 3D adapter. This doesn't apply
1397      * to any modern hardware, nor is it interesting for Wine, so ignore it
1398      */
1399
1400     *DDDI = deviceidentifier;
1401     return DD_OK;
1402 }
1403
1404 /*****************************************************************************
1405  * IDirectDraw7::GetSurfaceFromDC
1406  *
1407  * Returns the Surface for a GDI device context handle.
1408  * Is this related to IDirectDrawSurface::GetDC ???
1409  *
1410  * Params:
1411  *  hdc: hdc to return the surface for
1412  *  Surface: Address to write the surface pointer to
1413  *
1414  * Returns:
1415  *  Always returns DD_OK because it's a stub
1416  *
1417  *****************************************************************************/
1418 static HRESULT WINAPI
1419 IDirectDrawImpl_GetSurfaceFromDC(IDirectDraw7 *iface,
1420                                  HDC hdc,
1421                                  IDirectDrawSurface7 **Surface)
1422 {
1423     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1424     FIXME("(%p)->(%p,%p): Stub!\n", This, hdc, Surface);
1425
1426     /* Implementation idea if needed: Loop through all surfaces and compare
1427      * their hdc with hdc. Implement it in WineD3D! */
1428     return DDERR_NOTFOUND;
1429 }
1430
1431 /*****************************************************************************
1432  * IDirectDraw7::RestoreAllSurfaces
1433  *
1434  * Calls the restore method of all surfaces
1435  *
1436  * Params:
1437  *
1438  * Returns:
1439  *  Always returns DD_OK because it's a stub
1440  *
1441  *****************************************************************************/
1442 static HRESULT WINAPI
1443 IDirectDrawImpl_RestoreAllSurfaces(IDirectDraw7 *iface)
1444 {
1445     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1446     FIXME("(%p): Stub\n", This);
1447
1448     /* This isn't hard to implement: Enumerate all WineD3D surfaces,
1449      * get their parent and call their restore method. Do not implement
1450      * it in WineD3D, as restoring a surface means re-creating the
1451      * WineD3DDSurface
1452      */
1453     return DD_OK;
1454 }
1455
1456 /*****************************************************************************
1457  * IDirectDraw7::StartModeTest
1458  *
1459  * Tests the specified video modes to update the system registry with
1460  * refresh rate information. StartModeTest starts the mode test,
1461  * EvaluateMode is used to fail or pass a mode. If EvaluateMode
1462  * isn't called within 15 seconds, the mode is failed automatically
1463  *
1464  * As refresh rates are handled by the X server, I don't think this
1465  * Method is important
1466  *
1467  * Params:
1468  *  Modes: An array of mode specifications
1469  *  NumModes: The number of modes in Modes
1470  *  Flags: Some flags...
1471  *
1472  * Returns:
1473  *  Returns DDERR_TESTFINISHED if flags contains DDSMT_ISTESTREQUIRED,
1474  *  if no modes are passed, DDERR_INVALIDPARAMS is returned,
1475  *  otherwise DD_OK
1476  *
1477  *****************************************************************************/
1478 static HRESULT WINAPI
1479 IDirectDrawImpl_StartModeTest(IDirectDraw7 *iface,
1480                               SIZE *Modes,
1481                               DWORD NumModes,
1482                               DWORD Flags)
1483 {
1484     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
1485     WARN("(%p)->(%p, %d, %x): Semi-Stub, most likely harmless\n", This, Modes, NumModes, Flags);
1486
1487     /* This looks sane */
1488     if( (!Modes) || (NumModes == 0) ) return DDERR_INVALIDPARAMS;
1489
1490     /* DDSMT_ISTESTREQUIRED asks if a mode test is necessary.
1491      * As it is not, DDERR_TESTFINISHED is returned
1492      * (hopefully that's correct
1493      *
1494     if(Flags & DDSMT_ISTESTREQUIRED) return DDERR_TESTFINISHED;
1495      * well, that value doesn't (yet) exist in the wine headers, so ignore it
1496      */
1497
1498     return DD_OK;
1499 }
1500
1501 /*****************************************************************************
1502  * IDirectDrawImpl_RecreateSurfacesCallback
1503  *
1504  * Enumeration callback for IDirectDrawImpl_RecreateAllSurfaces.
1505  * It re-recreates the WineD3DSurface. It's pretty straightforward
1506  *
1507  *****************************************************************************/
1508 HRESULT WINAPI
1509 IDirectDrawImpl_RecreateSurfacesCallback(IDirectDrawSurface7 *surf,
1510                                          DDSURFACEDESC2 *desc,
1511                                          void *Context)
1512 {
1513     IDirectDrawSurfaceImpl *surfImpl = ICOM_OBJECT(IDirectDrawSurfaceImpl,
1514                                                    IDirectDrawSurface7,
1515                                                    surf);
1516     IDirectDrawImpl *This = surfImpl->ddraw;
1517     IUnknown *Parent;
1518     IParentImpl *parImpl = NULL;
1519     IWineD3DSurface *wineD3DSurface;
1520     HRESULT hr;
1521     void *tmp;
1522     IWineD3DClipper *clipper = NULL;
1523
1524     WINED3DSURFACE_DESC     Desc;
1525     WINED3DFORMAT           Format;
1526     WINED3DRESOURCETYPE     Type;
1527     DWORD                   Usage;
1528     WINED3DPOOL             Pool;
1529     UINT                    Size;
1530
1531     WINED3DMULTISAMPLE_TYPE MultiSampleType;
1532     DWORD                   MultiSampleQuality;
1533     UINT                    Width;
1534     UINT                    Height;
1535
1536     TRACE("(%p): Enumerated Surface %p\n", This, surfImpl);
1537
1538     /* For the enumeration */
1539     IDirectDrawSurface7_Release(surf);
1540
1541     if(surfImpl->ImplType == This->ImplType) return DDENUMRET_OK; /* Continue */
1542
1543     /* Get the objects */
1544     wineD3DSurface = surfImpl->WineD3DSurface;
1545     IWineD3DSurface_GetParent(wineD3DSurface, &Parent);
1546     IUnknown_Release(Parent); /* For the getParent */
1547
1548     /* Is the parent an IParent interface? */
1549     if(IUnknown_QueryInterface(Parent, &IID_IParent, &tmp) == S_OK)
1550     {
1551         /* It is a IParent interface! */
1552         IUnknown_Release(Parent); /* For the QueryInterface */
1553         parImpl = ICOM_OBJECT(IParentImpl, IParent, Parent);
1554         /* Release the reference the parent interface is holding */
1555         IWineD3DSurface_Release(wineD3DSurface);
1556     }
1557
1558     /* get the clipper */
1559     IWineD3DSurface_GetClipper(wineD3DSurface, &clipper);
1560
1561     /* Get the surface properties */
1562     Desc.Format = &Format;
1563     Desc.Type = &Type;
1564     Desc.Usage = &Usage;
1565     Desc.Pool = &Pool;
1566     Desc.Size = &Size;
1567     Desc.MultiSampleType = &MultiSampleType;
1568     Desc.MultiSampleQuality = &MultiSampleQuality;
1569     Desc.Width = &Width;
1570     Desc.Height = &Height;
1571
1572     hr = IWineD3DSurface_GetDesc(wineD3DSurface, &Desc);
1573     if(hr != D3D_OK) return hr;
1574
1575     /* Create the new surface */
1576     hr = IWineD3DDevice_CreateSurface(This->wineD3DDevice,
1577                                       Width, Height, Format,
1578                                       TRUE /* Lockable */,
1579                                       FALSE /* Discard */,
1580                                       surfImpl->mipmap_level,
1581                                       &surfImpl->WineD3DSurface,
1582                                       Type,
1583                                       Usage,
1584                                       Pool,
1585                                       MultiSampleType,
1586                                       MultiSampleQuality,
1587                                       0 /* SharedHandle */,
1588                                       This->ImplType,
1589                                       Parent);
1590
1591     if(hr != D3D_OK)
1592         return hr;
1593
1594     IWineD3DSurface_SetClipper(surfImpl->WineD3DSurface, clipper);
1595
1596     /* Update the IParent if it exists */
1597     if(parImpl)
1598     {
1599         parImpl->child = (IUnknown *) surfImpl->WineD3DSurface;
1600         /* Add a reference for the IParent */
1601         IWineD3DSurface_AddRef(surfImpl->WineD3DSurface);
1602     }
1603     /* TODO: Copy the surface content, except for render targets */
1604
1605     if(IWineD3DSurface_Release(wineD3DSurface) == 0)
1606         TRACE("Surface released successful, next surface\n");
1607     else
1608         ERR("Something's still holding the old WineD3DSurface\n");
1609
1610     surfImpl->ImplType = This->ImplType;
1611
1612     if(clipper)
1613     {
1614         IWineD3DClipper_Release(clipper);
1615     }
1616     return DDENUMRET_OK;
1617 }
1618
1619 /*****************************************************************************
1620  * IDirectDrawImpl_RecreateAllSurfaces
1621  *
1622  * A function, that converts all wineD3DSurfaces to the new implementation type
1623  * It enumerates all surfaces with IWineD3DDevice::EnumSurfaces, creates a
1624  * new WineD3DSurface, copies the content and releases the old surface
1625  *
1626  *****************************************************************************/
1627 static HRESULT
1628 IDirectDrawImpl_RecreateAllSurfaces(IDirectDrawImpl *This)
1629 {
1630     DDSURFACEDESC2 desc;
1631     TRACE("(%p): Switch to implementation %d\n", This, This->ImplType);
1632
1633     if(This->ImplType != SURFACE_OPENGL && This->d3d_initialized)
1634     {
1635         /* Should happen almost never */
1636         FIXME("(%p) Switching to non-opengl surfaces with d3d started. Is this a bug?\n", This);
1637         /* Shutdown d3d */
1638         IWineD3DDevice_Uninit3D(This->wineD3DDevice, D3D7CB_DestroyDepthStencilSurface, D3D7CB_DestroySwapChain);
1639     }
1640     /* Contrary: D3D starting is handled by the caller, because it knows the render target */
1641
1642     memset(&desc, 0, sizeof(desc));
1643     desc.dwSize = sizeof(desc);
1644
1645     return IDirectDraw7_EnumSurfaces(ICOM_INTERFACE(This, IDirectDraw7),
1646                                      0,
1647                                      &desc,
1648                                      This,
1649                                      IDirectDrawImpl_RecreateSurfacesCallback);
1650 }
1651
1652 /*****************************************************************************
1653  * D3D7CB_CreateSurface
1654  *
1655  * Callback function for IDirect3DDevice_CreateTexture. It searches for the
1656  * correct mipmap sublevel, and returns it to WineD3D.
1657  * The surfaces are created already by IDirectDraw7::CreateSurface
1658  *
1659  * Params:
1660  *  With, Height: With and height of the surface
1661  *  Format: The requested format
1662  *  Usage, Pool: D3DUSAGE and D3DPOOL of the surface
1663  *  level: The mipmap level
1664  *  Face: The cube map face type
1665  *  Surface: Pointer to pass the created surface back at
1666  *  SharedHandle: NULL
1667  *
1668  * Returns:
1669  *  D3D_OK
1670  *
1671  *****************************************************************************/
1672 static HRESULT WINAPI
1673 D3D7CB_CreateSurface(IUnknown *device,
1674                      IUnknown *pSuperior,
1675                      UINT Width, UINT Height,
1676                      WINED3DFORMAT Format,
1677                      DWORD Usage, WINED3DPOOL Pool, UINT level,
1678                      WINED3DCUBEMAP_FACES Face,
1679                      IWineD3DSurface **Surface,
1680                      HANDLE *SharedHandle)
1681 {
1682     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, device);
1683     IDirectDrawSurfaceImpl *surf = NULL;
1684     int i = 0;
1685     DDSCAPS2 searchcaps = This->tex_root->surface_desc.ddsCaps;
1686     TRACE("(%p) call back. surf=%p. Face %d level %d\n", device, This->tex_root, Face, level);
1687
1688     searchcaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
1689     switch(Face)
1690     {
1691         case WINED3DCUBEMAP_FACE_POSITIVE_X:
1692             TRACE("Asked for positive x\n");
1693             if(searchcaps.dwCaps2 & DDSCAPS2_CUBEMAP) {
1694                 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
1695             }
1696             surf = This->tex_root; break;
1697         case WINED3DCUBEMAP_FACE_NEGATIVE_X:
1698             TRACE("Asked for negative x\n");
1699             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX; break;
1700         case WINED3DCUBEMAP_FACE_POSITIVE_Y:
1701             TRACE("Asked for positive y\n");
1702             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY; break;
1703         case WINED3DCUBEMAP_FACE_NEGATIVE_Y:
1704             TRACE("Asked for negative y\n");
1705             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY; break;
1706         case WINED3DCUBEMAP_FACE_POSITIVE_Z:
1707             TRACE("Asked for positive z\n");
1708             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ; break;
1709         case WINED3DCUBEMAP_FACE_NEGATIVE_Z:
1710             TRACE("Asked for negative z\n");
1711             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ; break;
1712         default: {ERR("Unexpected cube face\n");} /* Stupid compiler */
1713     }
1714
1715     if(!surf)
1716     {
1717         IDirectDrawSurface7 *attached;
1718         IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(This->tex_root, IDirectDrawSurface7),
1719                                                &searchcaps,
1720                                                &attached);
1721         surf = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, attached);
1722         IDirectDrawSurface7_Release(attached);
1723     }
1724     if(!surf) ERR("root search surface not found\n");
1725
1726     /* Find the wanted mipmap. There are enough mipmaps in the chain */
1727     while(i < level)
1728     {
1729         IDirectDrawSurface7 *attached;
1730         IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(surf, IDirectDrawSurface7),
1731                                                &searchcaps,
1732                                                &attached);
1733         if(!attached) ERR("Surface not found\n");
1734         surf = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, attached);
1735         IDirectDrawSurface7_Release(attached);
1736         i++;
1737     }
1738
1739     /* Return the surface */
1740     *Surface = surf->WineD3DSurface;
1741
1742     TRACE("Returning wineD3DSurface %p, it belongs to surface %p\n", *Surface, surf);
1743     return D3D_OK;
1744 }
1745
1746 ULONG WINAPI D3D7CB_DestroySwapChain(IWineD3DSwapChain *pSwapChain) {
1747     IUnknown* swapChainParent;
1748     TRACE("(%p) call back\n", pSwapChain);
1749
1750     IWineD3DSwapChain_GetParent(pSwapChain, &swapChainParent);
1751     IUnknown_Release(swapChainParent);
1752     return IUnknown_Release(swapChainParent);
1753 }
1754
1755 ULONG WINAPI D3D7CB_DestroyDepthStencilSurface(IWineD3DSurface *pSurface) {
1756     IUnknown* surfaceParent;
1757     TRACE("(%p) call back\n", pSurface);
1758
1759     IWineD3DSurface_GetParent(pSurface, &surfaceParent);
1760     IUnknown_Release(surfaceParent);
1761     return IUnknown_Release(surfaceParent);
1762 }
1763
1764 /*****************************************************************************
1765  * IDirectDrawImpl_CreateNewSurface
1766  *
1767  * A helper function for IDirectDraw7::CreateSurface. It creates a new surface
1768  * with the passed parameters.
1769  *
1770  * Params:
1771  *  DDSD: Description of the surface to create
1772  *  Surf: Address to store the interface pointer at
1773  *
1774  * Returns:
1775  *  DD_OK on success
1776  *
1777  *****************************************************************************/
1778 static HRESULT WINAPI
1779 IDirectDrawImpl_CreateNewSurface(IDirectDrawImpl *This,
1780                                  DDSURFACEDESC2 *pDDSD,
1781                                  IDirectDrawSurfaceImpl **ppSurf,
1782                                  UINT level)
1783 {
1784     HRESULT hr;
1785     UINT Width = 0, Height = 0;
1786     WINED3DFORMAT Format = WINED3DFMT_UNKNOWN;
1787     WINED3DRESOURCETYPE ResType = WINED3DRTYPE_SURFACE;
1788     DWORD Usage = 0;
1789     WINED3DSURFTYPE ImplType = This->ImplType;
1790     WINED3DSURFACE_DESC Desc;
1791     IUnknown *Parent;
1792     IParentImpl *parImpl = NULL;
1793     WINED3DPOOL Pool = WINED3DPOOL_DEFAULT;
1794
1795     /* Dummies for GetDesc */
1796     WINED3DPOOL dummy_d3dpool;
1797     WINED3DMULTISAMPLE_TYPE dummy_mst;
1798     UINT dummy_uint;
1799     DWORD dummy_dword;
1800
1801     if (TRACE_ON(ddraw))
1802     {
1803         TRACE(" (%p) Requesting surface desc :\n", This);
1804         DDRAW_dump_surface_desc(pDDSD);
1805     }
1806
1807     /* Select the surface type, if it wasn't choosen yet */
1808     if(ImplType == SURFACE_UNKNOWN)
1809     {
1810         /* Use GL Surfaces if a D3DDEVICE Surface is requested */
1811         if(pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
1812         {
1813             TRACE("(%p) Choosing GL surfaces because a 3DDEVICE Surface was requested\n", This);
1814             ImplType = SURFACE_OPENGL;
1815         }
1816
1817         /* Otherwise use GDI surfaces for now */
1818         else
1819         {
1820             TRACE("(%p) Choosing GDI surfaces for 2D rendering\n", This);
1821             ImplType = SURFACE_GDI;
1822         }
1823
1824         /* Policy if all surface implementations are available:
1825          * First, check if a default type was set with winecfg. If not,
1826          * try Xrender surfaces, and use them if they work. Next, check if
1827          * accelerated OpenGL is available, and use GL surfaces in this
1828          * case. If all else fails, use GDI surfaces. If a 3DDEVICE surface
1829          * was created, always use OpenGL surfaces.
1830          *
1831          * (Note: Xrender surfaces are not implemented for now, the
1832          * unaccelerated implementation uses GDI to render in Software)
1833          */
1834
1835         /* Store the type. If it needs to be changed, all WineD3DSurfaces have to
1836          * be re-created. This could be done with IDirectDrawSurface7::Restore
1837          */
1838         This->ImplType = ImplType;
1839     }
1840     else
1841     {
1842          if((pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE ) &&
1843             (This->ImplType != SURFACE_OPENGL ) && DefaultSurfaceType == SURFACE_UNKNOWN)
1844         {
1845             /* We have to change to OpenGL,
1846              * and re-create all WineD3DSurfaces
1847              */
1848             ImplType = SURFACE_OPENGL;
1849             This->ImplType = ImplType;
1850             TRACE("(%p) Re-creating all surfaces\n", This);
1851             IDirectDrawImpl_RecreateAllSurfaces(This);
1852             TRACE("(%p) Done recreating all surfaces\n", This);
1853         }
1854         else if(This->ImplType != SURFACE_OPENGL && pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
1855         {
1856             WARN("The application requests a 3D capable surface, but a non-opengl surface was set in the registry\n");
1857             /* Do not fail surface creation, only fail 3D device creation */
1858         }
1859     }
1860
1861     /* Get the correct wined3d usage */
1862     if (pDDSD->ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE |
1863                                  DDSCAPS_BACKBUFFER     |
1864                                  DDSCAPS_3DDEVICE       ) )
1865     {
1866         Usage |= WINED3DUSAGE_RENDERTARGET;
1867
1868         pDDSD->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY |
1869                                  DDSCAPS_VISIBLE;
1870     }
1871     if (pDDSD->ddsCaps.dwCaps & (DDSCAPS_OVERLAY))
1872     {
1873         Usage |= WINED3DUSAGE_OVERLAY;
1874     }
1875     if(This->depthstencil || (pDDSD->ddsCaps.dwCaps & DDSCAPS_ZBUFFER) )
1876     {
1877         /* The depth stencil creation callback sets this flag.
1878          * Set the WineD3D usage to let it know that it's a depth
1879          * Stencil surface.
1880          */
1881         Usage |= WINED3DUSAGE_DEPTHSTENCIL;
1882     }
1883     if(pDDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
1884     {
1885         Pool = WINED3DPOOL_SYSTEMMEM;
1886     }
1887     else if(pDDSD->ddsCaps.dwCaps2 & DDSCAPS2_TEXTUREMANAGE)
1888     {
1889         Pool = WINED3DPOOL_MANAGED;
1890         /* Managed textures have the system memory flag set */
1891         pDDSD->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
1892     }
1893     else if(pDDSD->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
1894     {
1895         /* Videomemory adds localvidmem, this is mutually exclusive with systemmemory
1896          * and texturemanage
1897          */
1898         pDDSD->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM;
1899     }
1900
1901     Format = PixelFormat_DD2WineD3D(&pDDSD->u4.ddpfPixelFormat);
1902     if(Format == WINED3DFMT_UNKNOWN)
1903     {
1904         ERR("Unsupported / Unknown pixelformat\n");
1905         return DDERR_INVALIDPIXELFORMAT;
1906     }
1907
1908     /* Create the Surface object */
1909     *ppSurf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawSurfaceImpl));
1910     if(!*ppSurf)
1911     {
1912         ERR("(%p) Error allocating memory for a surface\n", This);
1913         return DDERR_OUTOFVIDEOMEMORY;
1914     }
1915     ICOM_INIT_INTERFACE(*ppSurf, IDirectDrawSurface7, IDirectDrawSurface7_Vtbl);
1916     ICOM_INIT_INTERFACE(*ppSurf, IDirectDrawSurface3, IDirectDrawSurface3_Vtbl);
1917     ICOM_INIT_INTERFACE(*ppSurf, IDirectDrawGammaControl, IDirectDrawGammaControl_Vtbl);
1918     ICOM_INIT_INTERFACE(*ppSurf, IDirect3DTexture2, IDirect3DTexture2_Vtbl);
1919     ICOM_INIT_INTERFACE(*ppSurf, IDirect3DTexture, IDirect3DTexture1_Vtbl);
1920     (*ppSurf)->ref = 1;
1921     (*ppSurf)->version = 7;
1922     (*ppSurf)->ddraw = This;
1923     (*ppSurf)->surface_desc.dwSize = sizeof(DDSURFACEDESC2);
1924     (*ppSurf)->surface_desc.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1925     DD_STRUCT_COPY_BYSIZE(&(*ppSurf)->surface_desc, pDDSD);
1926
1927     /* Surface attachments */
1928     (*ppSurf)->next_attached = NULL;
1929     (*ppSurf)->first_attached = *ppSurf;
1930
1931     /* Needed to re-create the surface on an implementation change */
1932     (*ppSurf)->ImplType = ImplType;
1933
1934     /* For D3DDevice creation */
1935     (*ppSurf)->isRenderTarget = FALSE;
1936
1937     /* A trace message for debugging */
1938     TRACE("(%p) Created IDirectDrawSurface implementation structure at %p\n", This, *ppSurf);
1939
1940     if(pDDSD->ddsCaps.dwCaps & ( DDSCAPS_PRIMARYSURFACE | DDSCAPS_TEXTURE | DDSCAPS_3DDEVICE) )
1941     {
1942         /* Render targets and textures need a IParent interface,
1943          * because WineD3D will destroy them when the swapchain
1944          * is released
1945          */
1946         parImpl = HeapAlloc(GetProcessHeap(), 0, sizeof(IParentImpl));
1947         if(!parImpl)
1948         {
1949             ERR("Out of memory when allocating memory for a IParent implementation\n");
1950             return DDERR_OUTOFMEMORY;
1951         }
1952         parImpl->ref = 1;
1953         ICOM_INIT_INTERFACE(parImpl, IParent, IParent_Vtbl);
1954         Parent = (IUnknown *) ICOM_INTERFACE(parImpl, IParent);
1955         TRACE("Using IParent interface %p as parent\n", parImpl);
1956     }
1957     else
1958     {
1959         /* Use the surface as parent */
1960         Parent = (IUnknown *) ICOM_INTERFACE(*ppSurf, IDirectDrawSurface7);
1961         TRACE("Using Surface interface %p as parent\n", *ppSurf);
1962     }
1963
1964     /* Now create the WineD3D Surface */
1965     hr = IWineD3DDevice_CreateSurface(This->wineD3DDevice,
1966                                       pDDSD->dwWidth,
1967                                       pDDSD->dwHeight,
1968                                       Format,
1969                                       TRUE /* Lockable */,
1970                                       FALSE /* Discard */,
1971                                       level,
1972                                       &(*ppSurf)->WineD3DSurface,
1973                                       ResType, Usage,
1974                                       Pool,
1975                                       WINED3DMULTISAMPLE_NONE,
1976                                       0 /* MultiSampleQuality */,
1977                                       0 /* SharedHandle */,
1978                                       ImplType,
1979                                       Parent);
1980
1981     if(hr != D3D_OK)
1982     {
1983         ERR("IWineD3DDevice::CreateSurface failed. hr = %08x\n", hr);
1984         return hr;
1985     }
1986
1987     /* Set the child of the parent implementation if it exists */
1988     if(parImpl)
1989     {
1990         parImpl->child = (IUnknown *) (*ppSurf)->WineD3DSurface;
1991         /* The IParent releases the WineD3DSurface, and
1992          * the ddraw surface does that too. Hold a reference
1993          */
1994         IWineD3DSurface_AddRef((*ppSurf)->WineD3DSurface);
1995     }
1996
1997     /* Increase the surface counter, and attach the surface */
1998     InterlockedIncrement(&This->surfaces);
1999     list_add_head(&This->surface_list, &(*ppSurf)->surface_list_entry);
2000
2001     /* Here we could store all created surfaces in the DirectDrawImpl structure,
2002      * But this could also be delegated to WineDDraw, as it keeps track of all its
2003      * resources. Not implemented for now, as there are more important things ;)
2004      */
2005
2006     /* Get the pixel format of the WineD3DSurface and store it.
2007      * Don't use the Format choosen above, WineD3D might have
2008      * changed it
2009      */
2010     Desc.Format = &Format;
2011     Desc.Type = &ResType;
2012     Desc.Usage = &Usage;
2013     Desc.Pool = &dummy_d3dpool;
2014     Desc.Size = &dummy_uint;
2015     Desc.MultiSampleType = &dummy_mst;
2016     Desc.MultiSampleQuality = &dummy_dword;
2017     Desc.Width = &Width;
2018     Desc.Height = &Height;
2019
2020     (*ppSurf)->surface_desc.dwFlags |= DDSD_PIXELFORMAT;
2021     hr = IWineD3DSurface_GetDesc((*ppSurf)->WineD3DSurface, &Desc);
2022     if(hr != D3D_OK)
2023     {
2024         ERR("IWineD3DSurface::GetDesc failed\n");
2025         IDirectDrawSurface7_Release( (IDirectDrawSurface7 *) *ppSurf);
2026         return hr;
2027     }
2028
2029     if(Format == WINED3DFMT_UNKNOWN)
2030     {
2031         FIXME("IWineD3DSurface::GetDesc returned WINED3DFMT_UNKNOWN\n");
2032     }
2033     PixelFormat_WineD3DtoDD( &(*ppSurf)->surface_desc.u4.ddpfPixelFormat, Format);
2034
2035     /* Anno 1602 stores the pitch right after surface creation, so make sure it's there.
2036      * I can't LockRect() the surface here because if OpenGL surfaces are in use, the
2037      * WineD3DDevice might not be usable for 3D yet, so an extra method was created.
2038      * TODO: Test other fourcc formats
2039      */
2040     if(Format == WINED3DFMT_DXT1 || Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3 ||
2041        Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5)
2042     {
2043         (*ppSurf)->surface_desc.dwFlags |= DDSD_LINEARSIZE;
2044         if(Format == WINED3DFMT_DXT1)
2045         {
2046             (*ppSurf)->surface_desc.u1.dwLinearSize = max(4, Width) * max(4, Height) / 2;
2047         }
2048         else
2049         {
2050             (*ppSurf)->surface_desc.u1.dwLinearSize = max(4, Width) * max(4, Height);
2051         }
2052     }
2053     else
2054     {
2055         (*ppSurf)->surface_desc.dwFlags |= DDSD_PITCH;
2056         (*ppSurf)->surface_desc.u1.lPitch = IWineD3DSurface_GetPitch((*ppSurf)->WineD3DSurface);
2057     }
2058
2059     /* Application passed a color key? Set it! */
2060     if(pDDSD->dwFlags & DDSD_CKDESTOVERLAY)
2061     {
2062         IWineD3DSurface_SetColorKey((*ppSurf)->WineD3DSurface,
2063                                     DDCKEY_DESTOVERLAY,
2064                                     (WINEDDCOLORKEY *) &pDDSD->u3.ddckCKDestOverlay);
2065     }
2066     if(pDDSD->dwFlags & DDSD_CKDESTBLT)
2067     {
2068         IWineD3DSurface_SetColorKey((*ppSurf)->WineD3DSurface,
2069                                     DDCKEY_DESTBLT,
2070                                     (WINEDDCOLORKEY *) &pDDSD->ddckCKDestBlt);
2071     }
2072     if(pDDSD->dwFlags & DDSD_CKSRCOVERLAY)
2073     {
2074         IWineD3DSurface_SetColorKey((*ppSurf)->WineD3DSurface,
2075                                     DDCKEY_SRCOVERLAY,
2076                                     (WINEDDCOLORKEY *) &pDDSD->ddckCKSrcOverlay);
2077     }
2078     if(pDDSD->dwFlags & DDSD_CKSRCBLT)
2079     {
2080         IWineD3DSurface_SetColorKey((*ppSurf)->WineD3DSurface,
2081                                     DDCKEY_SRCBLT,
2082                                     (WINEDDCOLORKEY *) &pDDSD->ddckCKSrcBlt);
2083     }
2084     if ( pDDSD->dwFlags & DDSD_LPSURFACE)
2085     {
2086         hr = IWineD3DSurface_SetMem((*ppSurf)->WineD3DSurface, pDDSD->lpSurface);
2087         if(hr != WINED3D_OK)
2088         {
2089             /* No need for a trace here, wined3d does that for us */
2090             IDirectDrawSurface7_Release(ICOM_INTERFACE((*ppSurf), IDirectDrawSurface7));
2091             return hr;
2092         }
2093     }
2094
2095     return DD_OK;
2096 }
2097 /*****************************************************************************
2098  * CreateAdditionalSurfaces
2099  *
2100  * Creates a new mipmap chain.
2101  *
2102  * Params:
2103  *  root: Root surface to attach the newly created chain to
2104  *  count: number of surfaces to create
2105  *  DDSD: Description of the surface. Intentionally not a pointer to avoid side
2106  *        effects on the caller
2107  *  CubeFaceRoot: Whether the new surface is a root of a cube map face. This
2108  *                creates an additional surface without the mipmapping flags
2109  *
2110  *****************************************************************************/
2111 static HRESULT
2112 CreateAdditionalSurfaces(IDirectDrawImpl *This,
2113                          IDirectDrawSurfaceImpl *root,
2114                          UINT count,
2115                          DDSURFACEDESC2 DDSD,
2116                          BOOL CubeFaceRoot)
2117 {
2118     UINT i, j, level = 0;
2119     HRESULT hr;
2120     IDirectDrawSurfaceImpl *last = root;
2121
2122     for(i = 0; i < count; i++)
2123     {
2124         IDirectDrawSurfaceImpl *object2 = NULL;
2125
2126         /* increase the mipmap level, but only if a mipmap is created
2127          * In this case, also halve the size
2128          */
2129         if(DDSD.ddsCaps.dwCaps & DDSCAPS_MIPMAP && !CubeFaceRoot)
2130         {
2131             level++;
2132             if(DDSD.dwWidth > 1) DDSD.dwWidth /= 2;
2133             if(DDSD.dwHeight > 1) DDSD.dwHeight /= 2;
2134             /* Set the mipmap sublevel flag according to msdn */
2135             DDSD.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
2136         }
2137         else
2138         {
2139             DDSD.ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2140         }
2141         CubeFaceRoot = FALSE;
2142
2143         hr = IDirectDrawImpl_CreateNewSurface(This,
2144                                               &DDSD,
2145                                               &object2,
2146                                               level);
2147         if(hr != DD_OK)
2148         {
2149             return hr;
2150         }
2151
2152         /* Add the new surface to the complex attachment array */
2153         for(j = 0; j < MAX_COMPLEX_ATTACHED; j++)
2154         {
2155             if(last->complex_array[j]) continue;
2156             last->complex_array[j] = object2;
2157             break;
2158         }
2159         last = object2;
2160
2161         /* Remove the (possible) back buffer cap from the new surface description,
2162          * because only one surface in the flipping chain is a back buffer, one
2163          * is a front buffer, the others are just primary surfaces.
2164          */
2165         DDSD.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER;
2166     }
2167     return DD_OK;
2168 }
2169
2170 /*****************************************************************************
2171  * IDirectDraw7::CreateSurface
2172  *
2173  * Creates a new IDirectDrawSurface object and returns its interface.
2174  *
2175  * The surface connections with wined3d are a bit tricky. Basically it works
2176  * like this:
2177  *
2178  * |------------------------|               |-----------------|
2179  * | DDraw surface          |               | WineD3DSurface  |
2180  * |                        |               |                 |
2181  * |        WineD3DSurface  |-------------->|                 |
2182  * |        Child           |<------------->| Parent          |
2183  * |------------------------|               |-----------------|
2184  *
2185  * The DDraw surface is the parent of the wined3d surface, and it releases
2186  * the WineD3DSurface when the ddraw surface is destroyed.
2187  *
2188  * However, for all surfaces which can be in a container in WineD3D,
2189  * we have to do this. These surfaces are usually complex surfaces,
2190  * so this concerns primary surfaces with a front and a back buffer,
2191  * and textures.
2192  *
2193  * |------------------------|               |-----------------|
2194  * | DDraw surface          |               | Container       |
2195  * |                        |               |                 |
2196  * |                  Child |<------------->| Parent          |
2197  * |                Texture |<------------->|                 |
2198  * |         WineD3DSurface |<----|         |          Levels |<--|
2199  * | Complex connection     |     |         |                 |   |
2200  * |------------------------|     |         |-----------------|   |
2201  *  ^                             |                               |
2202  *  |                             |                               |
2203  *  |                             |                               |
2204  *  |    |------------------|     |         |-----------------|   |
2205  *  |    | IParent          |     |-------->| WineD3DSurface  |   |
2206  *  |    |                  |               |                 |   |
2207  *  |    |            Child |<------------->| Parent          |   |
2208  *  |    |                  |               |       Container |<--|
2209  *  |    |------------------|               |-----------------|   |
2210  *  |                                                             |
2211  *  |   |----------------------|                                  |
2212  *  |   | DDraw surface 2      |                                  |
2213  *  |   |                      |                                  |
2214  *  |<->| Complex root   Child |                                  |
2215  *  |   |              Texture |                                  |
2216  *  |   |       WineD3DSurface |<----|                            |
2217  *  |   |----------------------|     |                            |
2218  *  |                                |                            |
2219  *  |    |---------------------|     |      |-----------------|   |
2220  *  |    | IParent             |     |----->| WineD3DSurface  |   |
2221  *  |    |                     |            |                 |   |
2222  *  |    |               Child |<---------->| Parent          |   |
2223  *  |    |---------------------|            |       Container |<--|
2224  *  |                                       |-----------------|   |
2225  *  |                                                             |
2226  *  |             ---More surfaces can follow---                  |
2227  *
2228  * The reason is that the IWineD3DSwapchain(render target container)
2229  * and the IWineD3DTexure(Texture container) release the parents
2230  * of their surface's children, but by releasing the complex root
2231  * the surfaces which are complexly attached to it are destroyed
2232  * too. See IDirectDrawSurface::Release for a more detailed
2233  * explanation.
2234  *
2235  * Params:
2236  *  DDSD: Description of the surface to create
2237  *  Surf: Address to store the interface pointer at
2238  *  UnkOuter: Basically for aggregation support, but ddraw doesn't support
2239  *            aggregation, so it has to be NULL
2240  *
2241  * Returns:
2242  *  DD_OK on success
2243  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
2244  *  DDERR_* if an error occurs
2245  *
2246  *****************************************************************************/
2247 static HRESULT WINAPI
2248 IDirectDrawImpl_CreateSurface(IDirectDraw7 *iface,
2249                               DDSURFACEDESC2 *DDSD,
2250                               IDirectDrawSurface7 **Surf,
2251                               IUnknown *UnkOuter)
2252 {
2253     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
2254     IDirectDrawSurfaceImpl *object = NULL;
2255     HRESULT hr;
2256     LONG extra_surfaces = 0;
2257     DDSURFACEDESC2 desc2;
2258     WINED3DDISPLAYMODE Mode;
2259
2260     TRACE("(%p)->(%p,%p,%p)\n", This, DDSD, Surf, UnkOuter);
2261
2262     /* Some checks before we start */
2263     if (TRACE_ON(ddraw))
2264     {
2265         TRACE(" (%p) Requesting surface desc :\n", This);
2266         DDRAW_dump_surface_desc(DDSD);
2267     }
2268     EnterCriticalSection(&ddraw_cs);
2269
2270     if (UnkOuter != NULL)
2271     {
2272         FIXME("(%p) : outer != NULL?\n", This);
2273         LeaveCriticalSection(&ddraw_cs);
2274         return CLASS_E_NOAGGREGATION; /* unchecked */
2275     }
2276
2277     if (Surf == NULL)
2278     {
2279         FIXME("(%p) You want to get back a surface? Don't give NULL ptrs!\n", This);
2280         LeaveCriticalSection(&ddraw_cs);
2281         return E_POINTER; /* unchecked */
2282     }
2283
2284     if (!(DDSD->dwFlags & DDSD_CAPS))
2285     {
2286         /* DVIDEO.DLL does forget the DDSD_CAPS flag ... *sigh* */
2287         DDSD->dwFlags |= DDSD_CAPS;
2288     }
2289     if (DDSD->ddsCaps.dwCaps == 0)
2290     {
2291         /* This has been checked on real Windows */
2292         DDSD->ddsCaps.dwCaps = DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
2293     }
2294
2295     if (DDSD->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD)
2296     {
2297         /* If the surface is of the 'alloconload' type, ignore the LPSURFACE field */
2298         DDSD->dwFlags &= ~DDSD_LPSURFACE;
2299     }
2300
2301     if ((DDSD->dwFlags & DDSD_LPSURFACE) && (DDSD->lpSurface == NULL))
2302     {
2303         /* Frank Herbert's Dune specifies a null pointer for the surface, ignore the LPSURFACE field */
2304         WARN("(%p) Null surface pointer specified, ignore it!\n", This);
2305         DDSD->dwFlags &= ~DDSD_LPSURFACE;
2306     }
2307
2308     if((DDSD->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE)) == (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE) &&
2309        !(This->cooperative_level & DDSCL_EXCLUSIVE))
2310     {
2311         TRACE("(%p): Attempt to create a flipable primary surface without DDSCL_EXCLUSIVE set\n", This);
2312         *Surf = NULL;
2313         LeaveCriticalSection(&ddraw_cs);
2314         return DDERR_NOEXCLUSIVEMODE;
2315     }
2316
2317     if(DDSD->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER)) {
2318         WARN("Application tried to create an explicit front or back buffer\n");
2319         LeaveCriticalSection(&ddraw_cs);
2320         return DDERR_INVALIDCAPS;
2321     }
2322     /* Check cube maps but only if the size includes them */
2323     if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2324     {
2325         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES &&
2326            !(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
2327         {
2328             WARN("Cube map faces requested without cube map flag\n");
2329             LeaveCriticalSection(&ddraw_cs);
2330             return DDERR_INVALIDCAPS;
2331         }
2332         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2333            (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) == 0)
2334         {
2335             WARN("Cube map without faces requested\n");
2336             LeaveCriticalSection(&ddraw_cs);
2337             return DDERR_INVALIDPARAMS;
2338         }
2339
2340         /* Quick tests confirm those can be created, but we don't do that yet */
2341         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2342            (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
2343         {
2344             FIXME("Partial cube maps not supported yet\n");
2345         }
2346     }
2347
2348     /* According to the msdn this flag is ignored by CreateSurface */
2349     if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2350         DDSD->ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2351
2352     /* Modify some flags */
2353     memset(&desc2, 0, sizeof(desc2));
2354     desc2.dwSize = sizeof(desc2);   /* For the struct copy */
2355     DD_STRUCT_COPY_BYSIZE(&desc2, DDSD);
2356     desc2.dwSize = sizeof(desc2);   /* To override a possibly smaller size */
2357     desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT); /* Just to be sure */
2358
2359     /* Get the video mode from WineD3D - we will need it */
2360     hr = IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
2361                                        0, /* Swapchain 0 */
2362                                        &Mode);
2363     if(FAILED(hr))
2364     {
2365         ERR("Failed to read display mode from wined3d\n");
2366         switch(This->orig_bpp)
2367         {
2368             case 8:
2369                 Mode.Format = WINED3DFMT_P8;
2370                 break;
2371
2372             case 15:
2373                 Mode.Format = WINED3DFMT_X1R5G5B5;
2374                 break;
2375
2376             case 16:
2377                 Mode.Format = WINED3DFMT_R5G6B5;
2378                 break;
2379
2380             case 24:
2381                 Mode.Format = WINED3DFMT_R8G8B8;
2382                 break;
2383
2384             case 32:
2385                 Mode.Format = WINED3DFMT_X8R8G8B8;
2386                 break;
2387         }
2388         Mode.Width = This->orig_width;
2389         Mode.Height = This->orig_height;
2390     }
2391
2392     /* No pixelformat given? Use the current screen format */
2393     if(!(desc2.dwFlags & DDSD_PIXELFORMAT))
2394     {
2395         desc2.dwFlags |= DDSD_PIXELFORMAT;
2396         desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT);
2397
2398         /* Wait: It could be a Z buffer */
2399         if(desc2.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
2400         {
2401             switch(desc2.u2.dwMipMapCount) /* Who had this glorious idea? */
2402             {
2403                 case 15:
2404                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_D15S1);
2405                     break;
2406                 case 16:
2407                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_D16);
2408                     break;
2409                 case 24:
2410                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_D24X8);
2411                     break;
2412                 case 32:
2413                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_D32);
2414                     break;
2415                 default:
2416                     ERR("Unknown Z buffer bit depth\n");
2417             }
2418         }
2419         else
2420         {
2421             PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, Mode.Format);
2422         }
2423     }
2424
2425     /* No Width or no Height? Use the original screen size
2426      */
2427     if(!(desc2.dwFlags & DDSD_WIDTH) ||
2428        !(desc2.dwFlags & DDSD_HEIGHT) )
2429     {
2430         /* Invalid for non-render targets */
2431         if(!(desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
2432         {
2433             WARN("Creating a non-Primary surface without Width or Height info, returning DDERR_INVALIDPARAMS\n");
2434             *Surf = NULL;
2435             LeaveCriticalSection(&ddraw_cs);
2436             return DDERR_INVALIDPARAMS;
2437         }
2438
2439         desc2.dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
2440         desc2.dwWidth = Mode.Width;
2441         desc2.dwHeight = Mode.Height;
2442     }
2443
2444     /* Mipmap count fixes */
2445     if(desc2.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
2446     {
2447         if(desc2.ddsCaps.dwCaps & DDSCAPS_COMPLEX)
2448         {
2449             if(desc2.dwFlags & DDSD_MIPMAPCOUNT)
2450             {
2451                 /* Mipmap count is given, should not be 0 */
2452                 if( desc2.u2.dwMipMapCount == 0 )
2453                 {
2454                     LeaveCriticalSection(&ddraw_cs);
2455                     return DDERR_INVALIDPARAMS;
2456                 }
2457             }
2458             else
2459             {
2460                 /* Undocumented feature: Create sublevels until
2461                  * either the width or the height is 1
2462                  */
2463                 DWORD min = desc2.dwWidth < desc2.dwHeight ?
2464                             desc2.dwWidth : desc2.dwHeight;
2465                 desc2.u2.dwMipMapCount = 0;
2466                 while( min )
2467                 {
2468                     desc2.u2.dwMipMapCount += 1;
2469                     min >>= 1;
2470                 }
2471             }
2472         }
2473         else
2474         {
2475             /* Not-complex mipmap -> Mipmapcount = 1 */
2476             desc2.u2.dwMipMapCount = 1;
2477         }
2478         extra_surfaces = desc2.u2.dwMipMapCount - 1;
2479
2480         /* There's a mipmap count in the created surface in any case */
2481         desc2.dwFlags |= DDSD_MIPMAPCOUNT;
2482     }
2483     /* If no mipmap is given, the texture has only one level */
2484
2485     /* The first surface is a front buffer, the back buffer is created afterwards */
2486     if( (desc2.dwFlags & DDSD_CAPS) && (desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) )
2487     {
2488         desc2.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
2489     }
2490
2491     /* The root surface in a cube map is positive x */
2492     if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
2493     {
2494         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
2495         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEX;
2496     }
2497
2498     /* Create the first surface */
2499     hr = IDirectDrawImpl_CreateNewSurface(This, &desc2, &object, 0);
2500     if( hr != DD_OK)
2501     {
2502         ERR("IDirectDrawImpl_CreateNewSurface failed with %08x\n", hr);
2503         LeaveCriticalSection(&ddraw_cs);
2504         return hr;
2505     }
2506     object->is_complex_root = TRUE;
2507
2508     *Surf = ICOM_INTERFACE(object, IDirectDrawSurface7);
2509
2510     /* Create Additional surfaces if necessary
2511      * This applies to Primary surfaces which have a back buffer count
2512      * set, but not to mipmap textures. In case of Mipmap textures,
2513      * wineD3D takes care of the creation of additional surfaces
2514      */
2515     if(DDSD->dwFlags & DDSD_BACKBUFFERCOUNT)
2516     {
2517         extra_surfaces = DDSD->dwBackBufferCount;
2518         desc2.ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER; /* It's not a front buffer */
2519         desc2.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
2520     }
2521
2522     hr = DD_OK;
2523     if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
2524     {
2525         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
2526         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEZ;
2527         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
2528         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEZ;
2529         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEZ;
2530         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
2531         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEZ;
2532         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEY;
2533         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
2534         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEY;
2535         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEY;
2536         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
2537         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEY;
2538         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEX;
2539         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
2540         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEX;
2541         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEX;
2542     }
2543
2544     hr |= CreateAdditionalSurfaces(This, object, extra_surfaces, desc2, FALSE);
2545     if(hr != DD_OK)
2546     {
2547         /* This destroys and possibly created surfaces too */
2548         IDirectDrawSurface_Release( ICOM_INTERFACE(object, IDirectDrawSurface7) );
2549         LeaveCriticalSection(&ddraw_cs);
2550         return hr;
2551     }
2552
2553     /* If the implementation is OpenGL and there's no d3ddevice, attach a d3ddevice
2554      * But attach the d3ddevice only if the currently created surface was
2555      * a primary surface (2D app in 3D mode) or a 3DDEVICE surface (3D app)
2556      * The only case I can think of where this doesn't apply is when a
2557      * 2D app was configured by the user to run with OpenGL and it didn't create
2558      * the render target as first surface. In this case the render target creation
2559      * will cause the 3D init.
2560      */
2561     if( (This->ImplType == SURFACE_OPENGL) && !(This->d3d_initialized) &&
2562         desc2.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE) )
2563     {
2564         IDirectDrawSurfaceImpl *target = object, *surface;
2565         struct list *entry;
2566
2567         /* Search for the primary to use as render target */
2568         LIST_FOR_EACH(entry, &This->surface_list)
2569         {
2570             surface = LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
2571             if((surface->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER)) ==
2572                (DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER))
2573             {
2574                 /* found */
2575                 target = surface;
2576                 TRACE("Using primary %p as render target\n", target);
2577                 break;
2578             }
2579         }
2580
2581         TRACE("(%p) Attaching a D3DDevice, rendertarget = %p\n", This, target);
2582         hr = IDirectDrawImpl_AttachD3DDevice(This, target);
2583         if(hr != D3D_OK)
2584         {
2585             IDirectDrawSurfaceImpl *release_surf;
2586             ERR("IDirectDrawImpl_AttachD3DDevice failed, hr = %x\n", hr);
2587             *Surf = NULL;
2588
2589             /* The before created surface structures are in an incomplete state here.
2590              * WineD3D holds the reference on the IParents, and it released them on the failure
2591              * already. So the regular release method implementation would fail on the attempt
2592              * to destroy either the IParents or the swapchain. So free the surface here.
2593              * The surface structure here is a list, not a tree, because onscreen targets
2594              * cannot be cube textures
2595              */
2596             while(object)
2597             {
2598                 release_surf = object;
2599                 object = object->complex_array[0];
2600                 IDirectDrawSurfaceImpl_Destroy(release_surf);
2601             }
2602             LeaveCriticalSection(&ddraw_cs);
2603             return hr;
2604         }
2605     }
2606
2607     /* Addref the ddraw interface to keep an reference for each surface */
2608     IDirectDraw7_AddRef(iface);
2609     object->ifaceToRelease = (IUnknown *) iface;
2610
2611     /* Create a WineD3DTexture if a texture was requested */
2612     if(desc2.ddsCaps.dwCaps & DDSCAPS_TEXTURE)
2613     {
2614         UINT levels;
2615         WINED3DFORMAT Format;
2616         WINED3DPOOL Pool = WINED3DPOOL_DEFAULT;
2617
2618         This->tex_root = object;
2619
2620         if(desc2.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
2621         {
2622             /* a mipmap is created, create enough levels */
2623             levels = desc2.u2.dwMipMapCount;
2624         }
2625         else
2626         {
2627             /* No mipmap is created, create one level */
2628             levels = 1;
2629         }
2630
2631         /* DDSCAPS_SYSTEMMEMORY textures are in WINED3DPOOL_SYSTEMMEM */
2632         if(DDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
2633         {
2634             Pool = WINED3DPOOL_SYSTEMMEM;
2635         }
2636         /* Should I forward the MANAGED cap to the managed pool ? */
2637
2638         /* Get the format. It's set already by CreateNewSurface */
2639         Format = PixelFormat_DD2WineD3D(&object->surface_desc.u4.ddpfPixelFormat);
2640
2641         /* The surfaces are already created, the callback only
2642          * passes the IWineD3DSurface to WineD3D
2643          */
2644         if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
2645         {
2646             hr = IWineD3DDevice_CreateCubeTexture(This->wineD3DDevice,
2647                                                   DDSD->dwWidth, /* Edgelength */
2648                                                   levels,
2649                                                   0, /* usage */
2650                                                   Format,
2651                                                   Pool,
2652                                                   (IWineD3DCubeTexture **) &object->wineD3DTexture,
2653                                                   0, /* SharedHandle */
2654                                                   (IUnknown *) ICOM_INTERFACE(object, IDirectDrawSurface7),
2655                                                   D3D7CB_CreateSurface);
2656         }
2657         else
2658         {
2659             hr = IWineD3DDevice_CreateTexture(This->wineD3DDevice,
2660                                               DDSD->dwWidth, DDSD->dwHeight,
2661                                               levels, /* MipMapCount = Levels */
2662                                               0, /* usage */
2663                                               Format,
2664                                               Pool,
2665                                               (IWineD3DTexture **) &object->wineD3DTexture,
2666                                               0, /* SharedHandle */
2667                                               (IUnknown *) ICOM_INTERFACE(object, IDirectDrawSurface7),
2668                                               D3D7CB_CreateSurface );
2669         }
2670         This->tex_root = NULL;
2671     }
2672
2673     LeaveCriticalSection(&ddraw_cs);
2674     return hr;
2675 }
2676
2677 #define DDENUMSURFACES_SEARCHTYPE (DDENUMSURFACES_CANBECREATED|DDENUMSURFACES_DOESEXIST)
2678 #define DDENUMSURFACES_MATCHTYPE (DDENUMSURFACES_ALL|DDENUMSURFACES_MATCH|DDENUMSURFACES_NOMATCH)
2679
2680 static BOOL
2681 Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
2682                                     const DDPIXELFORMAT *provided)
2683 {
2684     /* Some flags must be present in both or neither for a match. */
2685     static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
2686         | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
2687         | DDPF_ZBUFFER | DDPF_STENCILBUFFER;
2688
2689     if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
2690         return FALSE;
2691
2692     if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
2693         return FALSE;
2694
2695     if (requested->dwFlags & DDPF_FOURCC)
2696         if (requested->dwFourCC != provided->dwFourCC)
2697             return FALSE;
2698
2699     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
2700                               |DDPF_LUMINANCE|DDPF_BUMPDUDV))
2701         if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
2702             return FALSE;
2703
2704     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
2705                               |DDPF_LUMINANCE|DDPF_BUMPDUDV))
2706         if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
2707             return FALSE;
2708
2709     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
2710         if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
2711             return FALSE;
2712
2713     /* I could be wrong about the bumpmapping. MSDN docs are vague. */
2714     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
2715                               |DDPF_BUMPDUDV))
2716         if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
2717             return FALSE;
2718
2719     if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
2720         if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
2721             return FALSE;
2722
2723     return TRUE;
2724 }
2725
2726 static BOOL
2727 IDirectDrawImpl_DDSD_Match(const DDSURFACEDESC2* requested,
2728                            const DDSURFACEDESC2* provided)
2729 {
2730     struct compare_info
2731     {
2732         DWORD flag;
2733         ptrdiff_t offset;
2734         size_t size;
2735     };
2736
2737 #define CMP(FLAG, FIELD)                                \
2738         { DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
2739           sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
2740
2741     static const struct compare_info compare[] =
2742     {
2743         CMP(ALPHABITDEPTH, dwAlphaBitDepth),
2744         CMP(BACKBUFFERCOUNT, dwBackBufferCount),
2745         CMP(CAPS, ddsCaps),
2746         CMP(CKDESTBLT, ddckCKDestBlt),
2747         CMP(CKDESTOVERLAY, u3 /* ddckCKDestOverlay */),
2748         CMP(CKSRCBLT, ddckCKSrcBlt),
2749         CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
2750         CMP(HEIGHT, dwHeight),
2751         CMP(LINEARSIZE, u1 /* dwLinearSize */),
2752         CMP(LPSURFACE, lpSurface),
2753         CMP(MIPMAPCOUNT, u2 /* dwMipMapCount */),
2754         CMP(PITCH, u1 /* lPitch */),
2755         /* PIXELFORMAT: manual */
2756         CMP(REFRESHRATE, u2 /* dwRefreshRate */),
2757         CMP(TEXTURESTAGE, dwTextureStage),
2758         CMP(WIDTH, dwWidth),
2759         /* ZBUFFERBITDEPTH: "obsolete" */
2760     };
2761
2762 #undef CMP
2763
2764     unsigned int i;
2765
2766     if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
2767         return FALSE;
2768
2769     for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
2770     {
2771         if (requested->dwFlags & compare[i].flag
2772             && memcmp((const char *)provided + compare[i].offset,
2773                       (const char *)requested + compare[i].offset,
2774                       compare[i].size) != 0)
2775             return FALSE;
2776     }
2777
2778     if (requested->dwFlags & DDSD_PIXELFORMAT)
2779     {
2780         if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
2781                                                 &provided->u4.ddpfPixelFormat))
2782             return FALSE;
2783     }
2784
2785     return TRUE;
2786 }
2787
2788 #undef DDENUMSURFACES_SEARCHTYPE
2789 #undef DDENUMSURFACES_MATCHTYPE
2790
2791 /*****************************************************************************
2792  * IDirectDraw7::EnumSurfaces
2793  *
2794  * Loops through all surfaces attached to this device and calls the
2795  * application callback. This can't be relayed to WineD3DDevice,
2796  * because some WineD3DSurfaces' parents are IParent objects
2797  *
2798  * Params:
2799  *  Flags: Some filtering flags. See IDirectDrawImpl_EnumSurfacesCallback
2800  *  DDSD: Description to filter for
2801  *  Context: Application-provided pointer, it's passed unmodified to the
2802  *           Callback function
2803  *  Callback: Address to call for each surface
2804  *
2805  * Returns:
2806  *  DDERR_INVALIDPARAMS if the callback is NULL
2807  *  DD_OK on success
2808  *
2809  *****************************************************************************/
2810 static HRESULT WINAPI
2811 IDirectDrawImpl_EnumSurfaces(IDirectDraw7 *iface,
2812                              DWORD Flags,
2813                              DDSURFACEDESC2 *DDSD,
2814                              void *Context,
2815                              LPDDENUMSURFACESCALLBACK7 Callback)
2816 {
2817     /* The surface enumeration is handled by WineDDraw,
2818      * because it keeps track of all surfaces attached to
2819      * it. The filtering is done by our callback function,
2820      * because WineDDraw doesn't handle ddraw-like surface
2821      * caps structures
2822      */
2823     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
2824     IDirectDrawSurfaceImpl *surf;
2825     BOOL all, nomatch;
2826     DDSURFACEDESC2 desc;
2827     struct list *entry, *entry2;
2828
2829     all = Flags & DDENUMSURFACES_ALL;
2830     nomatch = Flags & DDENUMSURFACES_NOMATCH;
2831
2832     TRACE("(%p)->(%x,%p,%p,%p)\n", This, Flags, DDSD, Context, Callback);
2833     EnterCriticalSection(&ddraw_cs);
2834
2835     if(!Callback)
2836     {
2837         LeaveCriticalSection(&ddraw_cs);
2838         return DDERR_INVALIDPARAMS;
2839     }
2840
2841     /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
2842     LIST_FOR_EACH_SAFE(entry, entry2, &This->surface_list)
2843     {
2844         surf = LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
2845         if (all || (nomatch != IDirectDrawImpl_DDSD_Match(DDSD, &surf->surface_desc)))
2846         {
2847             desc = surf->surface_desc;
2848             IDirectDrawSurface7_AddRef(ICOM_INTERFACE(surf, IDirectDrawSurface7));
2849             if(Callback( ICOM_INTERFACE(surf, IDirectDrawSurface7), &desc, Context) != DDENUMRET_OK)
2850             {
2851                 LeaveCriticalSection(&ddraw_cs);
2852                 return DD_OK;
2853             }
2854         }
2855     }
2856     LeaveCriticalSection(&ddraw_cs);
2857     return DD_OK;
2858 }
2859
2860 static HRESULT WINAPI
2861 findRenderTarget(IDirectDrawSurface7 *surface,
2862                  DDSURFACEDESC2 *desc,
2863                  void *ctx)
2864 {
2865     IDirectDrawSurfaceImpl *surf = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, surface);
2866     IDirectDrawSurfaceImpl **target = (IDirectDrawSurfaceImpl **) ctx;
2867
2868     if(!surf->isRenderTarget) {
2869         *target = surf;
2870         IDirectDrawSurface7_Release(surface);
2871         return DDENUMRET_CANCEL;
2872     }
2873
2874     /* Recurse into the surface tree */
2875     IDirectDrawSurface7_EnumAttachedSurfaces(surface, ctx, findRenderTarget);
2876
2877     IDirectDrawSurface7_Release(surface);
2878     if(*target) return DDENUMRET_CANCEL;
2879     else return DDENUMRET_OK; /* Continue with the next neighbor surface */
2880 }
2881
2882 /*****************************************************************************
2883  * D3D7CB_CreateRenderTarget
2884  *
2885  * Callback called by WineD3D to create Surfaces for render target usage
2886  * This function takes the D3D target from the IDirectDrawImpl structure,
2887  * and returns the WineD3DSurface. To avoid double usage, the surface
2888  * is marked as render target afterwards
2889  *
2890  * Params
2891  *  device: The WineD3DDevice's parent
2892  *  Width, Height, Format: Dimensions and pixelformat of the render target
2893  *                         Ignored, because the surface already exists
2894  *  MultiSample, MultisampleQuality, Lockable: Ignored for the same reason
2895  *  Lockable: ignored
2896  *  ppSurface: Address to pass the surface pointer back at
2897  *  pSharedHandle: Ignored
2898  *
2899  * Returns:
2900  *  Always returns D3D_OK
2901  *
2902  *****************************************************************************/
2903 static HRESULT WINAPI
2904 D3D7CB_CreateRenderTarget(IUnknown *device, IUnknown *pSuperior,
2905                           UINT Width, UINT Height,
2906                           WINED3DFORMAT Format,
2907                           WINED3DMULTISAMPLE_TYPE MultiSample,
2908                           DWORD MultisampleQuality,
2909                           BOOL Lockable,
2910                           IWineD3DSurface** ppSurface,
2911                           HANDLE* pSharedHandle)
2912 {
2913     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, device);
2914     IDirectDrawSurfaceImpl *d3dSurface = This->d3d_target, *target = NULL;
2915     TRACE("(%p) call back\n", device);
2916
2917     if(d3dSurface->isRenderTarget)
2918     {
2919         IDirectDrawSurface7_EnumAttachedSurfaces(ICOM_INTERFACE(d3dSurface, IDirectDrawSurface7),
2920                                                  &target, findRenderTarget);
2921     }
2922     else
2923     {
2924         target = d3dSurface;
2925     }
2926
2927     if(!target)
2928     {
2929         target = This->d3d_target;
2930         ERR(" (%p) : No DirectDrawSurface found to create the back buffer. Using the front buffer as back buffer. Uncertain consequences\n", This);
2931     }
2932
2933     /* TODO: Return failure if the dimensions do not match, but this shouldn't happen */
2934
2935     *ppSurface = target->WineD3DSurface;
2936     target->isRenderTarget = TRUE;
2937     TRACE("Returning wineD3DSurface %p, it belongs to surface %p\n", *ppSurface, d3dSurface);
2938     return D3D_OK;
2939 }
2940
2941 static HRESULT WINAPI
2942 D3D7CB_CreateDepthStencilSurface(IUnknown *device,
2943                                  IUnknown *pSuperior,
2944                                  UINT Width,
2945                                  UINT Height,
2946                                  WINED3DFORMAT Format,
2947                                  WINED3DMULTISAMPLE_TYPE MultiSample,
2948                                  DWORD MultisampleQuality,
2949                                  BOOL Discard,
2950                                  IWineD3DSurface** ppSurface,
2951                                  HANDLE* pSharedHandle)
2952 {
2953     /* Create a Depth Stencil surface to make WineD3D happy */
2954     HRESULT hr = D3D_OK;
2955     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, device);
2956     DDSURFACEDESC2 ddsd;
2957
2958     TRACE("(%p) call back\n", device);
2959
2960     *ppSurface = NULL;
2961
2962     /* Create a DirectDraw surface */
2963     memset(&ddsd, 0, sizeof(ddsd));
2964     ddsd.dwSize = sizeof(ddsd);
2965     ddsd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
2966     ddsd.dwFlags = DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
2967     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
2968     ddsd.dwHeight = Height;
2969     ddsd.dwWidth = Width;
2970     if(Format != 0)
2971     {
2972       PixelFormat_WineD3DtoDD(&ddsd.u4.ddpfPixelFormat, Format);
2973     }
2974     else
2975     {
2976       ddsd.dwFlags ^= DDSD_PIXELFORMAT;
2977     }
2978
2979     This->depthstencil = TRUE;
2980     hr = IDirectDraw7_CreateSurface((IDirectDraw7 *) This,
2981                                     &ddsd,
2982                                     (IDirectDrawSurface7 **) &This->DepthStencilBuffer,
2983                                     NULL);
2984     This->depthstencil = FALSE;
2985     if(FAILED(hr))
2986     {
2987         ERR(" (%p) Creating a DepthStencil Surface failed, result = %x\n", This, hr);
2988         return hr;
2989     }
2990     *ppSurface = This->DepthStencilBuffer->WineD3DSurface;
2991     return D3D_OK;
2992 }
2993
2994 /*****************************************************************************
2995  * D3D7CB_CreateAdditionalSwapChain
2996  *
2997  * Callback function for WineD3D which creates a new WineD3DSwapchain
2998  * interface. It also creates an IParent interface to store that pointer,
2999  * so the WineD3DSwapchain has a parent and can be released when the D3D
3000  * device is destroyed
3001  *****************************************************************************/
3002 static HRESULT WINAPI
3003 D3D7CB_CreateAdditionalSwapChain(IUnknown *device,
3004                                  WINED3DPRESENT_PARAMETERS* pPresentationParameters,
3005                                  IWineD3DSwapChain ** ppSwapChain)
3006 {
3007     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, device);
3008     IParentImpl *object = NULL;
3009     HRESULT res = D3D_OK;
3010     IWineD3DSwapChain *swapchain;
3011     TRACE("(%p) call back\n", device);
3012
3013     object = HeapAlloc(GetProcessHeap(),  HEAP_ZERO_MEMORY, sizeof(IParentImpl));
3014     if (NULL == object)
3015     {
3016         FIXME("Allocation of memory failed\n");
3017         *ppSwapChain = NULL;
3018         return DDERR_OUTOFVIDEOMEMORY;
3019     }
3020
3021     ICOM_INIT_INTERFACE(object, IParent, IParent_Vtbl);
3022     object->ref = 1;
3023
3024     res = IWineD3DDevice_CreateAdditionalSwapChain(This->wineD3DDevice,
3025                                                    pPresentationParameters,
3026                                                    &swapchain,
3027                                                    (IUnknown*) ICOM_INTERFACE(object, IParent),
3028                                                    D3D7CB_CreateRenderTarget,
3029                                                    D3D7CB_CreateDepthStencilSurface);
3030     if (res != D3D_OK)
3031     {
3032         FIXME("(%p) call to IWineD3DDevice_CreateAdditionalSwapChain failed\n", This);
3033         HeapFree(GetProcessHeap(), 0 , object);
3034         *ppSwapChain = NULL;
3035     }
3036     else
3037     {
3038         *ppSwapChain = swapchain;
3039         object->child = (IUnknown *) swapchain;
3040     }
3041
3042     return res;
3043 }
3044
3045 /*****************************************************************************
3046  * IDirectDrawImpl_AttachD3DDevice
3047  *
3048  * Initializes the D3D capabilities of WineD3D
3049  *
3050  * Params:
3051  *  primary: The primary surface for D3D
3052  *
3053  * Returns
3054  *  DD_OK on success,
3055  *  DDERR_* otherwise
3056  *
3057  *****************************************************************************/
3058 static HRESULT WINAPI
3059 IDirectDrawImpl_AttachD3DDevice(IDirectDrawImpl *This,
3060                                 IDirectDrawSurfaceImpl *primary)
3061 {
3062     HRESULT hr;
3063     HWND                  window;
3064
3065     WINED3DPRESENT_PARAMETERS localParameters;
3066
3067     TRACE("(%p)->(%p)\n", This, primary);
3068
3069     /* Get the window */
3070     hr = IWineD3DDevice_GetHWND(This->wineD3DDevice,
3071                                 &window);
3072     if(hr != D3D_OK)
3073     {
3074         ERR("IWineD3DDevice::GetHWND failed\n");
3075         return hr;
3076     }
3077
3078     /* If there's no window, create a hidden window. WineD3D needs it */
3079     if(window == 0)
3080     {
3081         window = CreateWindowExA(0, This->classname, "Hidden D3D Window",
3082                                  WS_DISABLED, 0, 0,
3083                                  GetSystemMetrics(SM_CXSCREEN),
3084                                  GetSystemMetrics(SM_CYSCREEN),
3085                                  NULL, NULL, GetModuleHandleA(0), NULL);
3086
3087         ShowWindow(window, SW_HIDE);   /* Just to be sure */
3088         WARN("(%p) No window for the Direct3DDevice, created a hidden window. HWND=%p\n", This, window);
3089         This->d3d_window = window;
3090     }
3091     else
3092     {
3093         TRACE("(%p) Using existing window %p for Direct3D rendering\n", This, window);
3094     }
3095
3096     /* Store the future Render Target surface */
3097     This->d3d_target = primary;
3098
3099     /* Use the surface description for the device parameters, not the
3100      * Device settings. The app might render to an offscreen surface
3101      */
3102     localParameters.BackBufferWidth                 = primary->surface_desc.dwWidth;
3103     localParameters.BackBufferHeight                = primary->surface_desc.dwHeight;
3104     localParameters.BackBufferFormat                = PixelFormat_DD2WineD3D(&primary->surface_desc.u4.ddpfPixelFormat);
3105     localParameters.BackBufferCount                 = (primary->surface_desc.dwFlags & DDSD_BACKBUFFERCOUNT) ? primary->surface_desc.dwBackBufferCount : 0;
3106     localParameters.MultiSampleType                 = WINED3DMULTISAMPLE_NONE;
3107     localParameters.MultiSampleQuality              = 0;
3108     localParameters.SwapEffect                      = WINED3DSWAPEFFECT_COPY;
3109     localParameters.hDeviceWindow                   = window;
3110     localParameters.Windowed                        = !(This->cooperative_level & DDSCL_FULLSCREEN);
3111     localParameters.EnableAutoDepthStencil          = TRUE;
3112     localParameters.AutoDepthStencilFormat          = WINED3DFMT_D16;
3113     localParameters.Flags                           = 0;
3114     localParameters.FullScreen_RefreshRateInHz      = WINED3DPRESENT_RATE_DEFAULT; /* Default rate: It's already set */
3115     localParameters.PresentationInterval            = WINED3DPRESENT_INTERVAL_DEFAULT;
3116
3117     TRACE("Passing mode %d\n", localParameters.BackBufferFormat);
3118
3119     /* Set this NOW, otherwise creating the depth stencil surface will cause a
3120      * recursive loop until ram or emulated video memory is full
3121      */
3122     This->d3d_initialized = TRUE;
3123
3124     hr = IWineD3DDevice_Init3D(This->wineD3DDevice,
3125                                &localParameters,
3126                                D3D7CB_CreateAdditionalSwapChain);
3127     if(FAILED(hr))
3128     {
3129         This->d3d_target = NULL;
3130         This->d3d_initialized = FALSE;
3131         return hr;
3132     }
3133
3134     This->declArraySize = 2;
3135     This->decls = HeapAlloc(GetProcessHeap(),
3136                             HEAP_ZERO_MEMORY,
3137                             sizeof(*This->decls) * This->declArraySize);
3138     if(!This->decls)
3139     {
3140         ERR("Error allocating an array for the converted vertex decls\n");
3141         This->declArraySize = 0;
3142         hr = IWineD3DDevice_Uninit3D(This->wineD3DDevice,
3143                                      D3D7CB_DestroyDepthStencilSurface,
3144                                      D3D7CB_DestroySwapChain);
3145         return E_OUTOFMEMORY;
3146     }
3147
3148     /* Create an Index Buffer parent */
3149     TRACE("(%p) Successfully initialized 3D\n", This);
3150     return DD_OK;
3151 }
3152
3153 /*****************************************************************************
3154  * DirectDrawCreateClipper (DDRAW.@)
3155  *
3156  * Creates a new IDirectDrawClipper object.
3157  *
3158  * Params:
3159  *  Clipper: Address to write the interface pointer to
3160  *  UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3161  *            NULL
3162  *
3163  * Returns:
3164  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
3165  *  E_OUTOFMEMORY if allocating the object failed
3166  *
3167  *****************************************************************************/
3168 HRESULT WINAPI
3169 DirectDrawCreateClipper(DWORD Flags,
3170                         LPDIRECTDRAWCLIPPER *Clipper,
3171                         IUnknown *UnkOuter)
3172 {
3173     IDirectDrawClipperImpl* object;
3174     TRACE("(%08x,%p,%p)\n", Flags, Clipper, UnkOuter);
3175
3176     EnterCriticalSection(&ddraw_cs);
3177     if (UnkOuter != NULL)
3178     {
3179         LeaveCriticalSection(&ddraw_cs);
3180         return CLASS_E_NOAGGREGATION;
3181     }
3182
3183     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3184                      sizeof(IDirectDrawClipperImpl));
3185     if (object == NULL)
3186     {
3187         LeaveCriticalSection(&ddraw_cs);
3188         return E_OUTOFMEMORY;
3189     }
3190
3191     ICOM_INIT_INTERFACE(object, IDirectDrawClipper, IDirectDrawClipper_Vtbl);
3192     object->ref = 1;
3193     object->wineD3DClipper = pWineDirect3DCreateClipper((IUnknown *) object);
3194     if(!object->wineD3DClipper)
3195     {
3196         HeapFree(GetProcessHeap(), 0, object);
3197         LeaveCriticalSection(&ddraw_cs);
3198         return E_OUTOFMEMORY;
3199     }
3200
3201     *Clipper = (IDirectDrawClipper *) object;
3202     LeaveCriticalSection(&ddraw_cs);
3203     return DD_OK;
3204 }
3205
3206 /*****************************************************************************
3207  * IDirectDraw7::CreateClipper
3208  *
3209  * Creates a DDraw clipper. See DirectDrawCreateClipper for details
3210  *
3211  *****************************************************************************/
3212 static HRESULT WINAPI
3213 IDirectDrawImpl_CreateClipper(IDirectDraw7 *iface,
3214                               DWORD Flags,
3215                               IDirectDrawClipper **Clipper,
3216                               IUnknown *UnkOuter)
3217 {
3218     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
3219     TRACE("(%p)->(%x,%p,%p)\n", This, Flags, Clipper, UnkOuter);
3220     return DirectDrawCreateClipper(Flags, Clipper, UnkOuter);
3221 }
3222
3223 /*****************************************************************************
3224  * IDirectDraw7::CreatePalette
3225  *
3226  * Creates a new IDirectDrawPalette object
3227  *
3228  * Params:
3229  *  Flags: The flags for the new clipper
3230  *  ColorTable: Color table to assign to the new clipper
3231  *  Palette: Address to write the interface pointer to
3232  *  UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3233  *            NULL
3234  *
3235  * Returns:
3236  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
3237  *  E_OUTOFMEMORY if allocating the object failed
3238  *
3239  *****************************************************************************/
3240 static HRESULT WINAPI
3241 IDirectDrawImpl_CreatePalette(IDirectDraw7 *iface,
3242                               DWORD Flags,
3243                               PALETTEENTRY *ColorTable,
3244                               IDirectDrawPalette **Palette,
3245                               IUnknown *pUnkOuter)
3246 {
3247     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
3248     IDirectDrawPaletteImpl *object;
3249     HRESULT hr = DDERR_GENERIC;
3250     TRACE("(%p)->(%x,%p,%p,%p)\n", This, Flags, ColorTable, Palette, pUnkOuter);
3251
3252     EnterCriticalSection(&ddraw_cs);
3253     if(pUnkOuter != NULL)
3254     {
3255         WARN("pUnkOuter is %p, returning CLASS_E_NOAGGREGATION\n", pUnkOuter);
3256         LeaveCriticalSection(&ddraw_cs);
3257         return CLASS_E_NOAGGREGATION;
3258     }
3259
3260     /* The refcount test shows that a cooplevel is required for this */
3261     if(!This->cooperative_level)
3262     {
3263         WARN("No cooperative level set, returning DDERR_NOCOOPERATIVELEVELSET\n");
3264         LeaveCriticalSection(&ddraw_cs);
3265         return DDERR_NOCOOPERATIVELEVELSET;
3266     }
3267
3268     object = HeapAlloc(GetProcessHeap(), 0, sizeof(IDirectDrawPaletteImpl));
3269     if(!object)
3270     {
3271         ERR("Out of memory when allocating memory for a palette implementation\n");
3272         LeaveCriticalSection(&ddraw_cs);
3273         return E_OUTOFMEMORY;
3274     }
3275
3276     ICOM_INIT_INTERFACE(object, IDirectDrawPalette, IDirectDrawPalette_Vtbl);
3277     object->ref = 1;
3278     object->ddraw_owner = This;
3279
3280     hr = IWineD3DDevice_CreatePalette(This->wineD3DDevice, Flags, ColorTable, &object->wineD3DPalette, (IUnknown *) ICOM_INTERFACE(object, IDirectDrawPalette) );
3281     if(hr != DD_OK)
3282     {
3283         HeapFree(GetProcessHeap(), 0, object);
3284         LeaveCriticalSection(&ddraw_cs);
3285         return hr;
3286     }
3287
3288     IDirectDraw7_AddRef(iface);
3289     object->ifaceToRelease = (IUnknown *) iface;
3290     *Palette = ICOM_INTERFACE(object, IDirectDrawPalette);
3291     LeaveCriticalSection(&ddraw_cs);
3292     return DD_OK;
3293 }
3294
3295 /*****************************************************************************
3296  * IDirectDraw7::DuplicateSurface
3297  *
3298  * Duplicates a surface. The surface memory points to the same memory as
3299  * the original surface, and it's released when the last surface referencing
3300  * it is released. I guess that's beyond Wine's surface management right now
3301  * (Idea: create a new DDraw surface with the same WineD3DSurface. I need a
3302  * test application to implement this)
3303  *
3304  * Params:
3305  *  Src: Address of the source surface
3306  *  Dest: Address to write the new surface pointer to
3307  *
3308  * Returns:
3309  *  See IDirectDraw7::CreateSurface
3310  *
3311  *****************************************************************************/
3312 static HRESULT WINAPI
3313 IDirectDrawImpl_DuplicateSurface(IDirectDraw7 *iface,
3314                                  IDirectDrawSurface7 *Src,
3315                                  IDirectDrawSurface7 **Dest)
3316 {
3317     ICOM_THIS_FROM(IDirectDrawImpl, IDirectDraw7, iface);
3318     IDirectDrawSurfaceImpl *Surf = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, Src);
3319
3320     FIXME("(%p)->(%p,%p)\n", This, Surf, Dest);
3321
3322     /* For now, simply create a new, independent surface */
3323     return IDirectDraw7_CreateSurface(iface,
3324                                       &Surf->surface_desc,
3325                                       Dest,
3326                                       NULL);
3327 }
3328
3329 /*****************************************************************************
3330  * IDirectDraw7 VTable
3331  *****************************************************************************/
3332 const IDirectDraw7Vtbl IDirectDraw7_Vtbl =
3333 {
3334     /*** IUnknown ***/
3335     IDirectDrawImpl_QueryInterface,
3336     IDirectDrawImpl_AddRef,
3337     IDirectDrawImpl_Release,
3338     /*** IDirectDraw ***/
3339     IDirectDrawImpl_Compact,
3340     IDirectDrawImpl_CreateClipper,
3341     IDirectDrawImpl_CreatePalette,
3342     IDirectDrawImpl_CreateSurface,
3343     IDirectDrawImpl_DuplicateSurface,
3344     IDirectDrawImpl_EnumDisplayModes,
3345     IDirectDrawImpl_EnumSurfaces,
3346     IDirectDrawImpl_FlipToGDISurface,
3347     IDirectDrawImpl_GetCaps,
3348     IDirectDrawImpl_GetDisplayMode,
3349     IDirectDrawImpl_GetFourCCCodes,
3350     IDirectDrawImpl_GetGDISurface,
3351     IDirectDrawImpl_GetMonitorFrequency,
3352     IDirectDrawImpl_GetScanLine,
3353     IDirectDrawImpl_GetVerticalBlankStatus,
3354     IDirectDrawImpl_Initialize,
3355     IDirectDrawImpl_RestoreDisplayMode,
3356     IDirectDrawImpl_SetCooperativeLevel,
3357     IDirectDrawImpl_SetDisplayMode,
3358     IDirectDrawImpl_WaitForVerticalBlank,
3359     /*** IDirectDraw2 ***/
3360     IDirectDrawImpl_GetAvailableVidMem,
3361     /*** IDirectDraw7 ***/
3362     IDirectDrawImpl_GetSurfaceFromDC,
3363     IDirectDrawImpl_RestoreAllSurfaces,
3364     IDirectDrawImpl_TestCooperativeLevel,
3365     IDirectDrawImpl_GetDeviceIdentifier,
3366     /*** IDirectDraw7 ***/
3367     IDirectDrawImpl_StartModeTest,
3368     IDirectDrawImpl_EvaluateMode
3369 };
3370
3371 /*****************************************************************************
3372  * IDirectDrawImpl_FindDecl
3373  *
3374  * Finds the WineD3D vertex declaration for a specific fvf, and creates one
3375  * if none was found.
3376  *
3377  * This function is in ddraw.c and the DDraw object space because D3D7
3378  * vertex buffers are created using the IDirect3D interface to the ddraw
3379  * object, so they can be valid across D3D devices(theoretically. The ddraw
3380  * object also owns the wined3d device
3381  *
3382  * Parameters:
3383  *  This: Device
3384  *  fvf: Fvf to find the decl for
3385  *
3386  * Returns:
3387  *  NULL in case of an error, the IWineD3DVertexDeclaration interface for the
3388  *  fvf otherwise.
3389  *
3390  *****************************************************************************/
3391 IWineD3DVertexDeclaration *
3392 IDirectDrawImpl_FindDecl(IDirectDrawImpl *This,
3393                          DWORD fvf)
3394 {
3395     HRESULT hr;
3396     IWineD3DVertexDeclaration* pDecl = NULL;
3397     int p, low, high; /* deliberately signed */
3398     struct FvfToDecl *convertedDecls = This->decls;
3399
3400     TRACE("Searching for declaration for fvf %08x... ", fvf);
3401
3402     low = 0;
3403     high = This->numConvertedDecls - 1;
3404     while(low <= high) {
3405         p = (low + high) >> 1;
3406         TRACE("%d ", p);
3407         if(convertedDecls[p].fvf == fvf) {
3408             TRACE("found %p\n", convertedDecls[p].decl);
3409             return convertedDecls[p].decl;
3410         } else if(convertedDecls[p].fvf < fvf) {
3411             low = p + 1;
3412         } else {
3413             high = p - 1;
3414         }
3415     }
3416     TRACE("not found. Creating and inserting at position %d.\n", low);
3417
3418     hr = IWineD3DDevice_CreateVertexDeclarationFromFVF(This->wineD3DDevice,
3419                                                        &pDecl,
3420                                                        (IUnknown *) ICOM_INTERFACE(This, IDirectDraw7),
3421                                                        fvf);
3422     if (hr != S_OK) return NULL;
3423
3424     if(This->declArraySize == This->numConvertedDecls) {
3425         int grow = max(This->declArraySize / 2, 8);
3426         convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
3427                                      sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
3428         if(!convertedDecls) {
3429             /* This will destroy it */
3430             IWineD3DVertexDeclaration_Release(pDecl);
3431             return NULL;
3432         }
3433         This->decls = convertedDecls;
3434         This->declArraySize += grow;
3435     }
3436
3437     memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
3438     convertedDecls[low].decl = pDecl;
3439     convertedDecls[low].fvf = fvf;
3440     This->numConvertedDecls++;
3441
3442     TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
3443     return pDecl;
3444 }