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 "ddraw_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  29
  30 /* Device identifier. Don't relay it to WineD3D */
  31 static const DDDEVICEIDENTIFIER2 deviceidentifier =
  32 {
  33     "display",
  34     "DirectDraw HAL",
  35     { { 0x00010001, 0x00010001 } },
  36     0, 0, 0, 0,
  37     /* a8373c10-7ac4-4deb-849a-009844d08b2d */
  38     {0xa8373c10,0x7ac4,0x4deb, {0x84,0x9a,0x00,0x98,0x44,0xd0,0x8b,0x2d}},
  39     0
  40 };
  41
  42 static struct enum_device_entry
  43 {
  44     char interface_name[100];
  45     char device_name[100];
  46     const GUID *device_guid;
  47 } device_list7[] =
  48 {
  49     /* T&L HAL device */
  50     {
  51         "WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D",
  52         "Wine D3D7 T&L HAL",
  53         &IID_IDirect3DTnLHalDevice,
  54     },
  55
  56     /* HAL device */
  57     {
  58         "WINE Direct3D7 Hardware acceleration using WineD3D",
  59         "Direct3D HAL",
  60         &IID_IDirect3DHALDevice,
  61     },
  62
  63     /* RGB device */
  64     {
  65         "WINE Direct3D7 RGB Software Emulation using WineD3D",
  66         "Wine D3D7 RGB",
  67         &IID_IDirect3DRGBDevice,
  68     },
  69 };
  70
  71 static void STDMETHODCALLTYPE ddraw_null_wined3d_object_destroyed(void *parent) {}
  72
  73 const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops =
  74 {
  75     ddraw_null_wined3d_object_destroyed,
  76 };
  77
  78 static inline IDirectDrawImpl *impl_from_IDirectDraw(IDirectDraw *iface)
  79 {
  80     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirectDraw_iface);
  81 }
  82
  83 static inline IDirectDrawImpl *impl_from_IDirectDraw2(IDirectDraw2 *iface)
  84 {
  85     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirectDraw2_iface);
  86 }
  87
  88 static inline IDirectDrawImpl *impl_from_IDirectDraw4(IDirectDraw4 *iface)
  89 {
  90     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirectDraw4_iface);
  91 }
  92
  93 static inline IDirectDrawImpl *impl_from_IDirectDraw7(IDirectDraw7 *iface)
  94 {
  95     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirectDraw7_iface);
  96 }
  97
  98 static inline IDirectDrawImpl *impl_from_IDirect3D(IDirect3D *iface)
  99 {
 100     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirect3D_iface);
 101 }
 102
 103 static inline IDirectDrawImpl *impl_from_IDirect3D2(IDirect3D2 *iface)
 104 {
 105     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirect3D2_iface);
 106 }
 107
 108 static inline IDirectDrawImpl *impl_from_IDirect3D3(IDirect3D3 *iface)
 109 {
 110     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirect3D3_iface);
 111 }
 112
 113 static inline IDirectDrawImpl *impl_from_IDirect3D7(IDirect3D7 *iface)
 114 {
 115     return CONTAINING_RECORD(iface, IDirectDrawImpl, IDirect3D7_iface);
 116 }
 117
 118 /*****************************************************************************
 119  * IUnknown Methods
 120  *****************************************************************************/
 121
 122 /*****************************************************************************
 123  * IDirectDraw7::QueryInterface
 124  *
 125  * Queries different interfaces of the DirectDraw object. It can return
 126  * IDirectDraw interfaces in version 1, 2, 4 and 7, and IDirect3D interfaces
 127  * in version 1, 2, 3 and 7. An IDirect3DDevice can be created with this
 128  * method.
 129  * The returned interface is AddRef()-ed before it's returned
 130  *
 131  * Used for version 1, 2, 4 and 7
 132  *
 133  * Params:
 134  *  refiid: Interface ID asked for
 135  *  obj: Used to return the interface pointer
 136  *
 137  * Returns:
 138  *  S_OK if an interface was found
 139  *  E_NOINTERFACE if the requested interface wasn't found
 140  *
 141  *****************************************************************************/
 142 static HRESULT WINAPI ddraw7_QueryInterface(IDirectDraw7 *iface, REFIID refiid, void **obj)
 143 {
 144     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
 145
 146     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(refiid), obj);
 147
 148     /* Can change surface impl type */
 149     wined3d_mutex_lock();
 150
 151     /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
 152     *obj = NULL;
 153
 154     if(!refiid)
 155     {
 156         wined3d_mutex_unlock();
 157         return DDERR_INVALIDPARAMS;
 158     }
 159
 160     /* Check DirectDraw Interfaces */
 161     if ( IsEqualGUID( &IID_IUnknown, refiid ) ||
 162          IsEqualGUID( &IID_IDirectDraw7, refiid ) )
 163     {
 164         *obj = This;
 165         TRACE("(%p) Returning IDirectDraw7 interface at %p\n", This, *obj);
 166     }
 167     else if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) )
 168     {
 169         *obj = &This->IDirectDraw4_iface;
 170         TRACE("(%p) Returning IDirectDraw4 interface at %p\n", This, *obj);
 171     }
 172     else if ( IsEqualGUID( &IID_IDirectDraw3, refiid ) )
 173     {
 174         /* This Interface exists in ddrawex.dll, it is implemented in a wrapper */
 175         WARN("IDirectDraw3 is not valid in ddraw.dll\n");
 176         *obj = NULL;
 177         wined3d_mutex_unlock();
 178         return E_NOINTERFACE;
 179     }
 180     else if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) )
 181     {
 182         *obj = &This->IDirectDraw2_iface;
 183         TRACE("(%p) Returning IDirectDraw2 interface at %p\n", This, *obj);
 184     }
 185     else if ( IsEqualGUID( &IID_IDirectDraw, refiid ) )
 186     {
 187         *obj = &This->IDirectDraw_iface;
 188         TRACE("(%p) Returning IDirectDraw interface at %p\n", This, *obj);
 189     }
 190
 191     /* Direct3D
 192      * The refcount unit test revealed that an IDirect3D7 interface can only be queried
 193      * from a DirectDraw object that was created as an IDirectDraw7 interface. No idea
 194      * who had this idea and why. The older interfaces can query and IDirect3D version
 195      * because they are all created as IDirectDraw(1). This isn't really crucial behavior,
 196      * and messy to implement with the common creation function, so it has been left out here.
 197      */
 198     else if ( IsEqualGUID( &IID_IDirect3D  , refiid ) ||
 199               IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
 200               IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
 201               IsEqualGUID( &IID_IDirect3D7 , refiid ) )
 202     {
 203         /* Check the surface implementation */
 204         if (DefaultSurfaceType != WINED3D_SURFACE_TYPE_OPENGL)
 205         {
 206             WARN("The app requests a Direct3D interface, but non-opengl surfaces where set in winecfg\n");
 207             /* Do not abort here, only reject 3D Device creation */
 208         }
 209
 210         if ( IsEqualGUID( &IID_IDirect3D  , refiid ) )
 211         {
 212             This->d3dversion = 1;
 213             *obj = &This->IDirect3D_iface;
 214             TRACE(" returning Direct3D interface at %p.\n", *obj);
 215         }
 216         else if ( IsEqualGUID( &IID_IDirect3D2  , refiid ) )
 217         {
 218             This->d3dversion = 2;
 219             *obj = &This->IDirect3D2_iface;
 220             TRACE(" returning Direct3D2 interface at %p.\n", *obj);
 221         }
 222         else if ( IsEqualGUID( &IID_IDirect3D3  , refiid ) )
 223         {
 224             This->d3dversion = 3;
 225             *obj = &This->IDirect3D3_iface;
 226             TRACE(" returning Direct3D3 interface at %p.\n", *obj);
 227         }
 228         else if(IsEqualGUID( &IID_IDirect3D7  , refiid ))
 229         {
 230             This->d3dversion = 7;
 231             *obj = &This->IDirect3D7_iface;
 232             TRACE(" returning Direct3D7 interface at %p.\n", *obj);
 233         }
 234     }
 235     /* Unknown interface */
 236     else
 237     {
 238         ERR("(%p)->(%s, %p): No interface found\n", This, debugstr_guid(refiid), obj);
 239         wined3d_mutex_unlock();
 240         return E_NOINTERFACE;
 241     }
 242
 243     IUnknown_AddRef( (IUnknown *) *obj );
 244     wined3d_mutex_unlock();
 245
 246     return S_OK;
 247 }
 248
 249 static HRESULT WINAPI ddraw4_QueryInterface(IDirectDraw4 *iface, REFIID riid, void **object)
 250 {
 251     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
 252
 253     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 254
 255     return ddraw7_QueryInterface(&This->IDirectDraw7_iface, riid, object);
 256 }
 257
 258 static HRESULT WINAPI ddraw2_QueryInterface(IDirectDraw2 *iface, REFIID riid, void **object)
 259 {
 260     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
 261
 262     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 263
 264     return ddraw7_QueryInterface(&This->IDirectDraw7_iface, riid, object);
 265 }
 266
 267 static HRESULT WINAPI ddraw1_QueryInterface(IDirectDraw *iface, REFIID riid, void **object)
 268 {
 269     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
 270
 271     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 272
 273     return ddraw7_QueryInterface(&This->IDirectDraw7_iface, riid, object);
 274 }
 275
 276 static HRESULT WINAPI d3d7_QueryInterface(IDirect3D7 *iface, REFIID riid, void **object)
 277 {
 278     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
 279
 280     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 281
 282     return ddraw7_QueryInterface(&This->IDirectDraw7_iface, riid, object);
 283 }
 284
 285 static HRESULT WINAPI d3d3_QueryInterface(IDirect3D3 *iface, REFIID riid, void **object)
 286 {
 287     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
 288
 289     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 290
 291     return ddraw7_QueryInterface(&This->IDirectDraw7_iface, riid, object);
 292 }
 293
 294 static HRESULT WINAPI d3d2_QueryInterface(IDirect3D2 *iface, REFIID riid, void **object)
 295 {
 296     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
 297
 298     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 299
 300     return ddraw7_QueryInterface(&This->IDirectDraw7_iface, riid, object);
 301 }
 302
 303 static HRESULT WINAPI d3d1_QueryInterface(IDirect3D *iface, REFIID riid, void **object)
 304 {
 305     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
 306
 307     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 308
 309     return ddraw7_QueryInterface(&This->IDirectDraw7_iface, riid, object);
 310 }
 311
 312 /*****************************************************************************
 313  * IDirectDraw7::AddRef
 314  *
 315  * Increases the interfaces refcount, basically
 316  *
 317  * DDraw refcounting is a bit tricky. The different DirectDraw interface
 318  * versions have individual refcounts, but the IDirect3D interfaces do not.
 319  * All interfaces are from one object, that means calling QueryInterface on an
 320  * IDirectDraw7 interface for an IDirectDraw4 interface does not create a new
 321  * IDirectDrawImpl object.
 322  *
 323  * That means all AddRef and Release implementations of IDirectDrawX work
 324  * with their own counter, and IDirect3DX::AddRef thunk to IDirectDraw (1),
 325  * except of IDirect3D7 which thunks to IDirectDraw7
 326  *
 327  * Returns: The new refcount
 328  *
 329  *****************************************************************************/
 330 static ULONG WINAPI ddraw7_AddRef(IDirectDraw7 *iface)
 331 {
 332     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
 333     ULONG ref = InterlockedIncrement(&This->ref7);
 334
 335     TRACE("%p increasing refcount to %u.\n", This, ref);
 336
 337     if(ref == 1) InterlockedIncrement(&This->numIfaces);
 338
 339     return ref;
 340 }
 341
 342 static ULONG WINAPI ddraw4_AddRef(IDirectDraw4 *iface)
 343 {
 344     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
 345     ULONG ref = InterlockedIncrement(&This->ref4);
 346
 347     TRACE("%p increasing refcount to %u.\n", This, ref);
 348
 349     if (ref == 1) InterlockedIncrement(&This->numIfaces);
 350
 351     return ref;
 352 }
 353
 354 static ULONG WINAPI ddraw2_AddRef(IDirectDraw2 *iface)
 355 {
 356     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
 357     ULONG ref = InterlockedIncrement(&This->ref2);
 358
 359     TRACE("%p increasing refcount to %u.\n", This, ref);
 360
 361     if (ref == 1) InterlockedIncrement(&This->numIfaces);
 362
 363     return ref;
 364 }
 365
 366 static ULONG WINAPI ddraw1_AddRef(IDirectDraw *iface)
 367 {
 368     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
 369     ULONG ref = InterlockedIncrement(&This->ref1);
 370
 371     TRACE("%p increasing refcount to %u.\n", This, ref);
 372
 373     if (ref == 1) InterlockedIncrement(&This->numIfaces);
 374
 375     return ref;
 376 }
 377
 378 static ULONG WINAPI d3d7_AddRef(IDirect3D7 *iface)
 379 {
 380     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
 381
 382     TRACE("iface %p.\n", iface);
 383
 384     return ddraw7_AddRef(&This->IDirectDraw7_iface);
 385 }
 386
 387 static ULONG WINAPI d3d3_AddRef(IDirect3D3 *iface)
 388 {
 389     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
 390
 391     TRACE("iface %p.\n", iface);
 392
 393     return ddraw1_AddRef(&This->IDirectDraw_iface);
 394 }
 395
 396 static ULONG WINAPI d3d2_AddRef(IDirect3D2 *iface)
 397 {
 398     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
 399
 400     TRACE("iface %p.\n", iface);
 401
 402     return ddraw1_AddRef(&This->IDirectDraw_iface);
 403 }
 404
 405 static ULONG WINAPI d3d1_AddRef(IDirect3D *iface)
 406 {
 407     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
 408
 409     TRACE("iface %p.\n", iface);
 410
 411     return ddraw1_AddRef(&This->IDirectDraw_iface);
 412 }
 413
 414 void ddraw_destroy_swapchain(IDirectDrawImpl *ddraw)
 415 {
 416     TRACE("Destroying the swapchain.\n");
 417
 418     wined3d_swapchain_decref(ddraw->wined3d_swapchain);
 419     ddraw->wined3d_swapchain = NULL;
 420
 421     if (DefaultSurfaceType == WINED3D_SURFACE_TYPE_OPENGL)
 422     {
 423         UINT i;
 424
 425         for (i = 0; i < ddraw->numConvertedDecls; ++i)
 426         {
 427             wined3d_vertex_declaration_decref(ddraw->decls[i].decl);
 428         }
 429         HeapFree(GetProcessHeap(), 0, ddraw->decls);
 430         ddraw->numConvertedDecls = 0;
 431
 432         if (FAILED(wined3d_device_uninit_3d(ddraw->wined3d_device)))
 433         {
 434             ERR("Failed to uninit 3D.\n");
 435         }
 436         else
 437         {
 438             /* Free the d3d window if one was created. */
 439             if (ddraw->d3d_window && ddraw->d3d_window != ddraw->dest_window)
 440             {
 441                 TRACE("Destroying the hidden render window %p.\n", ddraw->d3d_window);
 442                 DestroyWindow(ddraw->d3d_window);
 443                 ddraw->d3d_window = 0;
 444             }
 445         }
 446
 447         ddraw->d3d_initialized = FALSE;
 448     }
 449     else
 450     {
 451         wined3d_device_uninit_gdi(ddraw->wined3d_device);
 452     }
 453
 454     ddraw_set_swapchain_window(ddraw, NULL);
 455
 456     TRACE("Swapchain destroyed.\n");
 457 }
 458
 459 /*****************************************************************************
 460  * ddraw_destroy
 461  *
 462  * Destroys a ddraw object if all refcounts are 0. This is to share code
 463  * between the IDirectDrawX::Release functions
 464  *
 465  * Params:
 466  *  This: DirectDraw object to destroy
 467  *
 468  *****************************************************************************/
 469 static void ddraw_destroy(IDirectDrawImpl *This)
 470 {
 471     IDirectDraw7_SetCooperativeLevel(&This->IDirectDraw7_iface, NULL, DDSCL_NORMAL);
 472     IDirectDraw7_RestoreDisplayMode(&This->IDirectDraw7_iface);
 473
 474     /* Destroy the device window if we created one */
 475     if(This->devicewindow != 0)
 476     {
 477         TRACE(" (%p) Destroying the device window %p\n", This, This->devicewindow);
 478         DestroyWindow(This->devicewindow);
 479         This->devicewindow = 0;
 480     }
 481
 482     wined3d_mutex_lock();
 483     list_remove(&This->ddraw_list_entry);
 484     wined3d_mutex_unlock();
 485
 486     if (This->wined3d_swapchain)
 487         ddraw_destroy_swapchain(This);
 488     wined3d_device_decref(This->wined3d_device);
 489     wined3d_decref(This->wined3d);
 490
 491     /* Now free the object */
 492     HeapFree(GetProcessHeap(), 0, This);
 493 }
 494
 495 /*****************************************************************************
 496  * IDirectDraw7::Release
 497  *
 498  * Decreases the refcount. If the refcount falls to 0, the object is destroyed
 499  *
 500  * Returns: The new refcount
 501  *****************************************************************************/
 502 static ULONG WINAPI ddraw7_Release(IDirectDraw7 *iface)
 503 {
 504     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
 505     ULONG ref = InterlockedDecrement(&This->ref7);
 506
 507     TRACE("%p decreasing refcount to %u.\n", This, ref);
 508
 509     if (!ref && !InterlockedDecrement(&This->numIfaces))
 510         ddraw_destroy(This);
 511
 512     return ref;
 513 }
 514
 515 static ULONG WINAPI ddraw4_Release(IDirectDraw4 *iface)
 516 {
 517     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
 518     ULONG ref = InterlockedDecrement(&This->ref4);
 519
 520     TRACE("%p decreasing refcount to %u.\n", This, ref);
 521
 522     if (!ref && !InterlockedDecrement(&This->numIfaces))
 523         ddraw_destroy(This);
 524
 525     return ref;
 526 }
 527
 528 static ULONG WINAPI ddraw2_Release(IDirectDraw2 *iface)
 529 {
 530     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
 531     ULONG ref = InterlockedDecrement(&This->ref2);
 532
 533     TRACE("%p decreasing refcount to %u.\n", This, ref);
 534
 535     if (!ref && !InterlockedDecrement(&This->numIfaces))
 536         ddraw_destroy(This);
 537
 538     return ref;
 539 }
 540
 541 static ULONG WINAPI ddraw1_Release(IDirectDraw *iface)
 542 {
 543     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
 544     ULONG ref = InterlockedDecrement(&This->ref1);
 545
 546     TRACE("%p decreasing refcount to %u.\n", This, ref);
 547
 548     if (!ref && !InterlockedDecrement(&This->numIfaces))
 549         ddraw_destroy(This);
 550
 551     return ref;
 552 }
 553
 554 static ULONG WINAPI d3d7_Release(IDirect3D7 *iface)
 555 {
 556     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
 557
 558     TRACE("iface %p.\n", iface);
 559
 560     return ddraw7_Release(&This->IDirectDraw7_iface);
 561 }
 562
 563 static ULONG WINAPI d3d3_Release(IDirect3D3 *iface)
 564 {
 565     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
 566
 567     TRACE("iface %p.\n", iface);
 568
 569     return ddraw1_Release(&This->IDirectDraw_iface);
 570 }
 571
 572 static ULONG WINAPI d3d2_Release(IDirect3D2 *iface)
 573 {
 574     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
 575
 576     TRACE("iface %p.\n", iface);
 577
 578     return ddraw1_Release(&This->IDirectDraw_iface);
 579 }
 580
 581 static ULONG WINAPI d3d1_Release(IDirect3D *iface)
 582 {
 583     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
 584
 585     TRACE("iface %p.\n", iface);
 586
 587     return ddraw1_Release(&This->IDirectDraw_iface);
 588 }
 589
 590 /*****************************************************************************
 591  * IDirectDraw methods
 592  *****************************************************************************/
 593
 594 static HRESULT ddraw_set_focus_window(IDirectDrawImpl *ddraw, HWND window)
 595 {
 596     /* FIXME: This looks wrong, exclusive mode should imply a destination
 597      * window. */
 598     if ((ddraw->cooperative_level & DDSCL_EXCLUSIVE) && ddraw->dest_window)
 599     {
 600         TRACE("Setting DDSCL_SETFOCUSWINDOW with an already set window, returning DDERR_HWNDALREADYSET.\n");
 601         return DDERR_HWNDALREADYSET;
 602     }
 603
 604     ddraw->focuswindow = window;
 605
 606     /* Use the focus window for drawing too. */
 607     ddraw->dest_window = ddraw->focuswindow;
 608
 609     return DD_OK;
 610 }
 611
 612 static HRESULT ddraw_attach_d3d_device(IDirectDrawImpl *ddraw,
 613         struct wined3d_swapchain_desc *swapchain_desc)
 614 {
 615     HWND window = swapchain_desc->device_window;
 616     HRESULT hr;
 617
 618     TRACE("ddraw %p.\n", ddraw);
 619
 620     if (!window || window == GetDesktopWindow())
 621     {
 622         window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "Hidden D3D Window",
 623                 WS_DISABLED, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
 624                 NULL, NULL, NULL, NULL);
 625         if (!window)
 626         {
 627             ERR("Failed to create window, last error %#x.\n", GetLastError());
 628             return E_FAIL;
 629         }
 630
 631         ShowWindow(window, SW_HIDE);   /* Just to be sure */
 632         WARN("No window for the Direct3DDevice, created hidden window %p.\n", window);
 633
 634         swapchain_desc->device_window = window;
 635     }
 636     else
 637     {
 638         TRACE("Using existing window %p for Direct3D rendering.\n", window);
 639     }
 640     ddraw->d3d_window = window;
 641
 642     /* Set this NOW, otherwise creating the depth stencil surface will cause a
 643      * recursive loop until ram or emulated video memory is full. */
 644     ddraw->d3d_initialized = TRUE;
 645     hr = wined3d_device_init_3d(ddraw->wined3d_device, swapchain_desc);
 646     if (FAILED(hr))
 647     {
 648         ddraw->d3d_initialized = FALSE;
 649         return hr;
 650     }
 651
 652     ddraw->declArraySize = 2;
 653     ddraw->decls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw->decls) * ddraw->declArraySize);
 654     if (!ddraw->decls)
 655     {
 656         ERR("Error allocating an array for the converted vertex decls.\n");
 657         ddraw->declArraySize = 0;
 658         hr = wined3d_device_uninit_3d(ddraw->wined3d_device);
 659         return E_OUTOFMEMORY;
 660     }
 661
 662     TRACE("Successfully initialized 3D.\n");
 663
 664     return DD_OK;
 665 }
 666
 667 static HRESULT ddraw_create_swapchain(IDirectDrawImpl *ddraw, HWND window, BOOL windowed)
 668 {
 669     struct wined3d_swapchain_desc swapchain_desc;
 670     struct wined3d_display_mode mode;
 671     HRESULT hr = WINED3D_OK;
 672
 673     /* FIXME: wined3d_get_adapter_display_mode() would be more appropriate
 674      * here, since we don't actually have a swapchain yet, but
 675      * wined3d_device_get_display_mode() has some special handling for color
 676      * depth changes. */
 677     hr = wined3d_device_get_display_mode(ddraw->wined3d_device, 0, &mode);
 678     if (FAILED(hr))
 679     {
 680         ERR("Failed to get display mode.\n");
 681         return hr;
 682     }
 683
 684     memset(&swapchain_desc, 0, sizeof(swapchain_desc));
 685     swapchain_desc.backbuffer_width = mode.width;
 686     swapchain_desc.backbuffer_height = mode.height;
 687     swapchain_desc.backbuffer_format = mode.format_id;
 688     swapchain_desc.swap_effect = WINED3D_SWAP_EFFECT_COPY;
 689     swapchain_desc.device_window = window;
 690     swapchain_desc.windowed = windowed;
 691
 692     if (DefaultSurfaceType == WINED3D_SURFACE_TYPE_OPENGL)
 693         hr = ddraw_attach_d3d_device(ddraw, &swapchain_desc);
 694     else
 695         hr = wined3d_device_init_gdi(ddraw->wined3d_device, &swapchain_desc);
 696
 697     if (FAILED(hr))
 698     {
 699         ERR("Failed to create swapchain, hr %#x.\n", hr);
 700         return hr;
 701     }
 702
 703     if (FAILED(hr = wined3d_device_get_swapchain(ddraw->wined3d_device, 0, &ddraw->wined3d_swapchain)))
 704     {
 705         ERR("Failed to get swapchain, hr %#x.\n", hr);
 706         ddraw->wined3d_swapchain = NULL;
 707         return hr;
 708     }
 709
 710     ddraw_set_swapchain_window(ddraw, window);
 711
 712     return DD_OK;
 713 }
 714
 715 /*****************************************************************************
 716  * IDirectDraw7::SetCooperativeLevel
 717  *
 718  * Sets the cooperative level for the DirectDraw object, and the window
 719  * assigned to it. The cooperative level determines the general behavior
 720  * of the DirectDraw application
 721  *
 722  * Warning: This is quite tricky, as it's not really documented which
 723  * cooperative levels can be combined with each other. If a game fails
 724  * after this function, try to check the cooperative levels passed on
 725  * Windows, and if it returns something different.
 726  *
 727  * If you think that this function caused the failure because it writes a
 728  * fixme, be sure to run again with a +ddraw trace.
 729  *
 730  * What is known about cooperative levels (See the ddraw modes test):
 731  * DDSCL_EXCLUSIVE and DDSCL_FULLSCREEN must be used with each other
 732  * DDSCL_NORMAL is not compatible with DDSCL_EXCLUSIVE or DDSCL_FULLSCREEN
 733  * DDSCL_SETFOCUSWINDOW can be passed only in DDSCL_NORMAL mode, but after that
 734  * DDSCL_FULLSCREEN can be activated
 735  * DDSCL_SETFOCUSWINDOW may only be used with DDSCL_NOWINDOWCHANGES
 736  *
 737  * Handled flags: DDSCL_NORMAL, DDSCL_FULLSCREEN, DDSCL_EXCLUSIVE,
 738  *                DDSCL_SETFOCUSWINDOW (partially),
 739  *                DDSCL_MULTITHREADED (work in progress)
 740  *
 741  * Unhandled flags, which should be implemented
 742  *  DDSCL_SETDEVICEWINDOW: Sets a window specially used for rendering (I don't
 743  *  expect any difference to a normal window for wine)
 744  *  DDSCL_CREATEDEVICEWINDOW: Tells ddraw to create its own window for
 745  *  rendering (Possible test case: Half-Life)
 746  *
 747  * Unsure about these: DDSCL_FPUSETUP DDSCL_FPURESERVE
 748  *
 749  * These don't seem very important for wine:
 750  *  DDSCL_ALLOWREBOOT, DDSCL_NOWINDOWCHANGES, DDSCL_ALLOWMODEX
 751  *
 752  * Returns:
 753  *  DD_OK if the cooperative level was set successfully
 754  *  DDERR_INVALIDPARAMS if the passed cooperative level combination is invalid
 755  *  DDERR_HWNDALREADYSET if DDSCL_SETFOCUSWINDOW is passed in exclusive mode
 756  *   (Probably others too, have to investigate)
 757  *
 758  *****************************************************************************/
 759 static HRESULT WINAPI ddraw7_SetCooperativeLevel(IDirectDraw7 *iface, HWND hwnd, DWORD cooplevel)
 760 {
 761     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
 762     struct wined3d_stateblock *stateblock;
 763     struct wined3d_surface *rt, *ds;
 764     BOOL restore_state = FALSE;
 765     HWND window;
 766     HRESULT hr;
 767
 768     TRACE("iface %p, window %p, flags %#x.\n", iface, hwnd, cooplevel);
 769     DDRAW_dump_cooperativelevel(cooplevel);
 770
 771     wined3d_mutex_lock();
 772
 773     /* Get the old window */
 774     window = This->dest_window;
 775
 776     /* Tests suggest that we need one of them: */
 777     if(!(cooplevel & (DDSCL_SETFOCUSWINDOW |
 778                       DDSCL_NORMAL         |
 779                       DDSCL_EXCLUSIVE      )))
 780     {
 781         TRACE("Incorrect cooplevel flags, returning DDERR_INVALIDPARAMS\n");
 782         wined3d_mutex_unlock();
 783         return DDERR_INVALIDPARAMS;
 784     }
 785
 786     if ((cooplevel & DDSCL_CREATEDEVICEWINDOW) && !(cooplevel & DDSCL_EXCLUSIVE))
 787     {
 788         WARN("DDSCL_CREATEDEVICEWINDOW requires DDSCL_EXCLUSIVE.\n");
 789         wined3d_mutex_unlock();
 790         return DDERR_INVALIDPARAMS;
 791     }
 792
 793     /* Handle those levels first which set various hwnds */
 794     if ((cooplevel & DDSCL_SETFOCUSWINDOW) && !(cooplevel & DDSCL_CREATEDEVICEWINDOW))
 795     {
 796         /* This isn't compatible with a lot of flags */
 797         if (cooplevel & (DDSCL_MULTITHREADED
 798                 | DDSCL_FPUSETUP
 799                 | DDSCL_FPUPRESERVE
 800                 | DDSCL_ALLOWREBOOT
 801                 | DDSCL_ALLOWMODEX
 802                 | DDSCL_SETDEVICEWINDOW
 803                 | DDSCL_NORMAL
 804                 | DDSCL_EXCLUSIVE
 805                 | DDSCL_FULLSCREEN))
 806         {
 807             WARN("Called with incompatible flags, returning DDERR_INVALIDPARAMS.\n");
 808             wined3d_mutex_unlock();
 809             return DDERR_INVALIDPARAMS;
 810         }
 811
 812         hr = ddraw_set_focus_window(This, hwnd);
 813         wined3d_mutex_unlock();
 814         return hr;
 815     }
 816
 817     if (cooplevel & DDSCL_EXCLUSIVE)
 818     {
 819         if (!(cooplevel & DDSCL_FULLSCREEN) || !(hwnd || (cooplevel & DDSCL_CREATEDEVICEWINDOW)))
 820         {
 821             WARN("DDSCL_EXCLUSIVE requires DDSCL_FULLSCREEN and a window.\n");
 822             wined3d_mutex_unlock();
 823             return DDERR_INVALIDPARAMS;
 824         }
 825
 826         if (cooplevel & DDSCL_CREATEDEVICEWINDOW)
 827         {
 828             HWND device_window;
 829
 830             if (!This->focuswindow && !(cooplevel & DDSCL_SETFOCUSWINDOW))
 831             {
 832                 WARN("No focus window set.\n");
 833                 wined3d_mutex_unlock();
 834                 return DDERR_NOFOCUSWINDOW;
 835             }
 836
 837             device_window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "DirectDrawDeviceWnd",
 838                     WS_POPUP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
 839                     NULL, NULL, NULL, NULL);
 840             if (!device_window)
 841             {
 842                 ERR("Failed to create window, last error %#x.\n", GetLastError());
 843                 wined3d_mutex_unlock();
 844                 return E_FAIL;
 845             }
 846
 847             ShowWindow(device_window, SW_SHOW);
 848             TRACE("Created a device window %p.\n", device_window);
 849
 850             /* Native apparently leaks the created device window if setting the
 851              * focus window below fails. */
 852             This->cooperative_level |= DDSCL_CREATEDEVICEWINDOW;
 853             This->devicewindow = device_window;
 854
 855             if (cooplevel & DDSCL_SETFOCUSWINDOW)
 856             {
 857                 if (!hwnd)
 858                 {
 859                     wined3d_mutex_unlock();
 860                     return DDERR_NOHWND;
 861                 }
 862
 863                 if (FAILED(hr = ddraw_set_focus_window(This, hwnd)))
 864                 {
 865                     wined3d_mutex_unlock();
 866                     return hr;
 867                 }
 868             }
 869
 870             hwnd = device_window;
 871         }
 872     }
 873     else
 874     {
 875         if (This->cooperative_level & DDSCL_CREATEDEVICEWINDOW)
 876             DestroyWindow(This->devicewindow);
 877         This->devicewindow = NULL;
 878         This->focuswindow = NULL;
 879     }
 880
 881     if ((This->cooperative_level & DDSCL_EXCLUSIVE)
 882             && (hwnd != window || !(cooplevel & DDSCL_EXCLUSIVE)))
 883         wined3d_device_release_focus_window(This->wined3d_device);
 884
 885     if ((cooplevel & DDSCL_FULLSCREEN) != (This->cooperative_level & DDSCL_FULLSCREEN) || hwnd != window)
 886     {
 887         if (This->cooperative_level & DDSCL_FULLSCREEN)
 888             wined3d_device_restore_fullscreen_window(This->wined3d_device, window);
 889
 890         if (cooplevel & DDSCL_FULLSCREEN)
 891         {
 892             struct wined3d_display_mode display_mode;
 893
 894             wined3d_get_adapter_display_mode(This->wined3d, WINED3DADAPTER_DEFAULT, &display_mode);
 895             wined3d_device_setup_fullscreen_window(This->wined3d_device, hwnd,
 896                     display_mode.width, display_mode.height);
 897         }
 898     }
 899
 900     if ((cooplevel & DDSCL_EXCLUSIVE)
 901             && (hwnd != window || !(This->cooperative_level & DDSCL_EXCLUSIVE)))
 902     {
 903         hr = wined3d_device_acquire_focus_window(This->wined3d_device, hwnd);
 904         if (FAILED(hr))
 905         {
 906             ERR("Failed to acquire focus window, hr %#x.\n", hr);
 907             wined3d_mutex_unlock();
 908             return hr;
 909         }
 910     }
 911
 912     /* Don't override focus windows or private device windows */
 913     if (hwnd && !This->focuswindow && !This->devicewindow && (hwnd != window))
 914         This->dest_window = hwnd;
 915
 916     if (cooplevel & DDSCL_MULTITHREADED && !(This->cooperative_level & DDSCL_MULTITHREADED))
 917         wined3d_device_set_multithreaded(This->wined3d_device);
 918
 919     if (This->wined3d_swapchain)
 920     {
 921         if (DefaultSurfaceType != WINED3D_SURFACE_TYPE_GDI)
 922         {
 923             restore_state = TRUE;
 924
 925             if (FAILED(hr = wined3d_stateblock_create(This->wined3d_device, WINED3D_SBT_ALL, &stateblock)))
 926             {
 927                 ERR("Failed to create stateblock, hr %#x.\n", hr);
 928                 wined3d_mutex_unlock();
 929                 return hr;
 930             }
 931
 932             if (FAILED(hr = wined3d_stateblock_capture(stateblock)))
 933             {
 934                 ERR("Failed to capture stateblock, hr %#x.\n", hr);
 935                 wined3d_stateblock_decref(stateblock);
 936                 wined3d_mutex_unlock();
 937                 return hr;
 938             }
 939
 940             wined3d_device_get_render_target(This->wined3d_device, 0, &rt);
 941             if (rt == This->wined3d_frontbuffer)
 942             {
 943                 wined3d_surface_decref(rt);
 944                 rt = NULL;
 945             }
 946
 947             wined3d_device_get_depth_stencil(This->wined3d_device, &ds);
 948         }
 949
 950         ddraw_destroy_swapchain(This);
 951     }
 952
 953     if (FAILED(hr = ddraw_create_swapchain(This, This->dest_window, !(cooplevel & DDSCL_FULLSCREEN))))
 954         ERR("Failed to create swapchain, hr %#x.\n", hr);
 955
 956     if (restore_state)
 957     {
 958         if (ds)
 959         {
 960             wined3d_device_set_depth_stencil(This->wined3d_device, ds);
 961             wined3d_surface_decref(ds);
 962         }
 963
 964         if (rt)
 965         {
 966             wined3d_device_set_render_target(This->wined3d_device, 0, rt, FALSE);
 967             wined3d_surface_decref(rt);
 968         }
 969
 970         hr = wined3d_stateblock_apply(stateblock);
 971         wined3d_stateblock_decref(stateblock);
 972         if (FAILED(hr))
 973         {
 974             ERR("Failed to apply stateblock, hr %#x.\n", hr);
 975             wined3d_mutex_unlock();
 976             return hr;
 977         }
 978     }
 979
 980     /* Unhandled flags */
 981     if(cooplevel & DDSCL_ALLOWREBOOT)
 982         WARN("(%p) Unhandled flag DDSCL_ALLOWREBOOT, harmless\n", This);
 983     if(cooplevel & DDSCL_ALLOWMODEX)
 984         WARN("(%p) Unhandled flag DDSCL_ALLOWMODEX, harmless\n", This);
 985     if(cooplevel & DDSCL_FPUSETUP)
 986         WARN("(%p) Unhandled flag DDSCL_FPUSETUP, harmless\n", This);
 987
 988     /* Store the cooperative_level */
 989     This->cooperative_level = cooplevel;
 990     TRACE("SetCooperativeLevel retuning DD_OK\n");
 991     wined3d_mutex_unlock();
 992
 993     return DD_OK;
 994 }
 995
 996 static HRESULT WINAPI ddraw4_SetCooperativeLevel(IDirectDraw4 *iface, HWND window, DWORD flags)
 997 {
 998     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
 999
1000     TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1001
1002     return ddraw7_SetCooperativeLevel(&This->IDirectDraw7_iface, window, flags);
1003 }
1004
1005 static HRESULT WINAPI ddraw2_SetCooperativeLevel(IDirectDraw2 *iface, HWND window, DWORD flags)
1006 {
1007     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1008
1009     TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1010
1011     return ddraw7_SetCooperativeLevel(&This->IDirectDraw7_iface, window, flags);
1012 }
1013
1014 static HRESULT WINAPI ddraw1_SetCooperativeLevel(IDirectDraw *iface, HWND window, DWORD flags)
1015 {
1016     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1017
1018     TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1019
1020     return ddraw7_SetCooperativeLevel(&This->IDirectDraw7_iface, window, flags);
1021 }
1022
1023 /*****************************************************************************
1024  *
1025  * Helper function for SetDisplayMode and RestoreDisplayMode
1026  *
1027  * Implements DirectDraw's SetDisplayMode, but ignores the value of
1028  * ForceRefreshRate, since it is already handled by
1029  * ddraw7_SetDisplayMode.  RestoreDisplayMode can use this function
1030  * without worrying that ForceRefreshRate will override the refresh rate.  For
1031  * argument and return value documentation, see
1032  * ddraw7_SetDisplayMode.
1033  *
1034  *****************************************************************************/
1035 static HRESULT ddraw_set_display_mode(IDirectDrawImpl *ddraw, DWORD Width, DWORD Height,
1036         DWORD BPP, DWORD RefreshRate, DWORD Flags)
1037 {
1038     struct wined3d_display_mode mode;
1039     enum wined3d_format_id format;
1040     HRESULT hr;
1041
1042     TRACE("ddraw %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n", ddraw, Width,
1043             Height, BPP, RefreshRate, Flags);
1044
1045     wined3d_mutex_lock();
1046     if( !Width || !Height )
1047     {
1048         ERR("Width %u, Height %u, what to do?\n", Width, Height);
1049         /* It looks like Need for Speed Porsche Unleashed expects DD_OK here */
1050         wined3d_mutex_unlock();
1051         return DD_OK;
1052     }
1053
1054     switch(BPP)
1055     {
1056         case 8:  format = WINED3DFMT_P8_UINT;          break;
1057         case 15: format = WINED3DFMT_B5G5R5X1_UNORM;   break;
1058         case 16: format = WINED3DFMT_B5G6R5_UNORM;     break;
1059         case 24: format = WINED3DFMT_B8G8R8_UNORM;     break;
1060         case 32: format = WINED3DFMT_B8G8R8X8_UNORM;   break;
1061         default: format = WINED3DFMT_UNKNOWN;          break;
1062     }
1063
1064     if (FAILED(hr = wined3d_device_get_display_mode(ddraw->wined3d_device, 0, &mode)))
1065     {
1066         ERR("Failed to get current display mode, hr %#x.\n", hr);
1067     }
1068     else if (mode.width == Width
1069             && mode.height == Height
1070             && mode.format_id == format
1071             && mode.refresh_rate == RefreshRate)
1072     {
1073         TRACE("Skipping redundant mode setting call.\n");
1074         wined3d_mutex_unlock();
1075         return DD_OK;
1076     }
1077
1078     /* Check the exclusive mode
1079     if(!(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
1080         return DDERR_NOEXCLUSIVEMODE;
1081      * This is WRONG. Don't know if the SDK is completely
1082      * wrong and if there are any conditions when DDERR_NOEXCLUSIVE
1083      * is returned, but Half-Life 1.1.1.1 (Steam version)
1084      * depends on this
1085      */
1086
1087     mode.width = Width;
1088     mode.height = Height;
1089     mode.refresh_rate = RefreshRate;
1090     mode.format_id = format;
1091
1092     /* TODO: The possible return values from msdn suggest that
1093      * the screen mode can't be changed if a surface is locked
1094      * or some drawing is in progress
1095      */
1096
1097     /* TODO: Lose the primary surface */
1098     hr = wined3d_device_set_display_mode(ddraw->wined3d_device, 0, &mode);
1099
1100     wined3d_mutex_unlock();
1101
1102     switch(hr)
1103     {
1104         case WINED3DERR_NOTAVAILABLE:       return DDERR_UNSUPPORTED;
1105         default:                            return hr;
1106     }
1107 }
1108
1109 /*****************************************************************************
1110  * IDirectDraw7::SetDisplayMode
1111  *
1112  * Sets the display screen resolution, color depth and refresh frequency
1113  * when in fullscreen mode (in theory).
1114  * Possible return values listed in the SDK suggest that this method fails
1115  * when not in fullscreen mode, but this is wrong. Windows 2000 happily sets
1116  * the display mode in DDSCL_NORMAL mode without an hwnd specified.
1117  * It seems to be valid to pass 0 for With and Height, this has to be tested
1118  * It could mean that the current video mode should be left as-is. (But why
1119  * call it then?)
1120  *
1121  * Params:
1122  *  Height, Width: Screen dimension
1123  *  BPP: Color depth in Bits per pixel
1124  *  Refreshrate: Screen refresh rate
1125  *  Flags: Other stuff
1126  *
1127  * Returns
1128  *  DD_OK on success
1129  *
1130  *****************************************************************************/
1131 static HRESULT WINAPI ddraw7_SetDisplayMode(IDirectDraw7 *iface, DWORD Width, DWORD Height,
1132         DWORD BPP, DWORD RefreshRate, DWORD Flags)
1133 {
1134     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1135
1136     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1137             iface, Width, Height, BPP, RefreshRate, Flags);
1138
1139     if (force_refresh_rate != 0)
1140     {
1141         TRACE("ForceRefreshRate overriding passed-in refresh rate (%u Hz) to %u Hz\n",
1142                 RefreshRate, force_refresh_rate);
1143         RefreshRate = force_refresh_rate;
1144     }
1145
1146     return ddraw_set_display_mode(This, Width, Height, BPP, RefreshRate, Flags);
1147 }
1148
1149 static HRESULT WINAPI ddraw4_SetDisplayMode(IDirectDraw4 *iface, DWORD width, DWORD height,
1150         DWORD bpp, DWORD refresh_rate, DWORD flags)
1151 {
1152     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1153
1154     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1155             iface, width, height, bpp, refresh_rate, flags);
1156
1157     return ddraw7_SetDisplayMode(&This->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1158 }
1159
1160 static HRESULT WINAPI ddraw2_SetDisplayMode(IDirectDraw2 *iface,
1161         DWORD width, DWORD height, DWORD bpp, DWORD refresh_rate, DWORD flags)
1162 {
1163     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1164
1165     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1166             iface, width, height, bpp, refresh_rate, flags);
1167
1168     return ddraw7_SetDisplayMode(&This->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1169 }
1170
1171 static HRESULT WINAPI ddraw1_SetDisplayMode(IDirectDraw *iface, DWORD width, DWORD height, DWORD bpp)
1172 {
1173     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1174
1175     TRACE("iface %p, width %u, height %u, bpp %u.\n", iface, width, height, bpp);
1176
1177     return ddraw7_SetDisplayMode(&This->IDirectDraw7_iface, width, height, bpp, 0, 0);
1178 }
1179
1180 /*****************************************************************************
1181  * IDirectDraw7::RestoreDisplayMode
1182  *
1183  * Restores the display mode to what it was at creation time. Basically.
1184  *
1185  * A problem arises when there are 2 DirectDraw objects using the same hwnd:
1186  *  -> DD_1 finds the screen at 1400x1050x32 when created, sets it to 640x480x16
1187  *  -> DD_2 is created, finds the screen at 640x480x16, sets it to 1024x768x32
1188  *  -> DD_1 is released. The screen should be left at 1024x768x32.
1189  *  -> DD_2 is released. The screen should be set to 1400x1050x32
1190  * This case is unhandled right now, but Empire Earth does it this way.
1191  * (But perhaps there is something in SetCooperativeLevel to prevent this)
1192  *
1193  * The msdn says that this method resets the display mode to what it was before
1194  * SetDisplayMode was called. What if SetDisplayModes is called 2 times??
1195  *
1196  * Returns
1197  *  DD_OK on success
1198  *  DDERR_NOEXCLUSIVE mode if the device isn't in fullscreen mode
1199  *
1200  *****************************************************************************/
1201 static HRESULT WINAPI ddraw7_RestoreDisplayMode(IDirectDraw7 *iface)
1202 {
1203     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1204
1205     TRACE("iface %p.\n", iface);
1206
1207     return ddraw_set_display_mode(This, This->orig_width, This->orig_height, This->orig_bpp, 0, 0);
1208 }
1209
1210 static HRESULT WINAPI ddraw4_RestoreDisplayMode(IDirectDraw4 *iface)
1211 {
1212     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1213
1214     TRACE("iface %p.\n", iface);
1215
1216     return ddraw7_RestoreDisplayMode(&This->IDirectDraw7_iface);
1217 }
1218
1219 static HRESULT WINAPI ddraw2_RestoreDisplayMode(IDirectDraw2 *iface)
1220 {
1221     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1222
1223     TRACE("iface %p.\n", iface);
1224
1225     return ddraw7_RestoreDisplayMode(&This->IDirectDraw7_iface);
1226 }
1227
1228 static HRESULT WINAPI ddraw1_RestoreDisplayMode(IDirectDraw *iface)
1229 {
1230     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1231
1232     TRACE("iface %p.\n", iface);
1233
1234     return ddraw7_RestoreDisplayMode(&This->IDirectDraw7_iface);
1235 }
1236
1237 /*****************************************************************************
1238  * IDirectDraw7::GetCaps
1239  *
1240  * Returns the drives capabilities
1241  *
1242  * Used for version 1, 2, 4 and 7
1243  *
1244  * Params:
1245  *  DriverCaps: Structure to write the Hardware accelerated caps to
1246  *  HelCaps: Structure to write the emulation caps to
1247  *
1248  * Returns
1249  *  This implementation returns DD_OK only
1250  *
1251  *****************************************************************************/
1252 static HRESULT WINAPI ddraw7_GetCaps(IDirectDraw7 *iface, DDCAPS *DriverCaps, DDCAPS *HELCaps)
1253 {
1254     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1255     DDCAPS caps;
1256     WINED3DCAPS winecaps;
1257     HRESULT hr;
1258     DDSCAPS2 ddscaps = {0, 0, 0, 0};
1259
1260     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, DriverCaps, HELCaps);
1261
1262     /* One structure must be != NULL */
1263     if( (!DriverCaps) && (!HELCaps) )
1264     {
1265         ERR("(%p) Invalid params to ddraw7_GetCaps\n", This);
1266         return DDERR_INVALIDPARAMS;
1267     }
1268
1269     memset(&caps, 0, sizeof(caps));
1270     memset(&winecaps, 0, sizeof(winecaps));
1271     caps.dwSize = sizeof(caps);
1272
1273     wined3d_mutex_lock();
1274     hr = wined3d_device_get_device_caps(This->wined3d_device, &winecaps);
1275     if (FAILED(hr))
1276     {
1277         WARN("IWineD3DDevice::GetDeviceCaps failed\n");
1278         wined3d_mutex_unlock();
1279         return hr;
1280     }
1281
1282     hr = IDirectDraw7_GetAvailableVidMem(iface, &ddscaps, &caps.dwVidMemTotal, &caps.dwVidMemFree);
1283     wined3d_mutex_unlock();
1284     if(FAILED(hr)) {
1285         WARN("IDirectDraw7::GetAvailableVidMem failed\n");
1286         return hr;
1287     }
1288
1289     caps.dwCaps = winecaps.ddraw_caps.caps;
1290     caps.dwCaps2 = winecaps.ddraw_caps.caps2;
1291     caps.dwCKeyCaps = winecaps.ddraw_caps.color_key_caps;
1292     caps.dwFXCaps = winecaps.ddraw_caps.fx_caps;
1293     caps.dwPalCaps = winecaps.ddraw_caps.pal_caps;
1294     caps.ddsCaps.dwCaps = winecaps.ddraw_caps.dds_caps;
1295     caps.dwSVBCaps = winecaps.ddraw_caps.svb_caps;
1296     caps.dwSVBCKeyCaps = winecaps.ddraw_caps.svb_color_key_caps;
1297     caps.dwSVBFXCaps = winecaps.ddraw_caps.svb_fx_caps;
1298     caps.dwVSBCaps = winecaps.ddraw_caps.vsb_caps;
1299     caps.dwVSBCKeyCaps = winecaps.ddraw_caps.vsb_color_key_caps;
1300     caps.dwVSBFXCaps = winecaps.ddraw_caps.vsb_fx_caps;
1301     caps.dwSSBCaps = winecaps.ddraw_caps.ssb_caps;
1302     caps.dwSSBCKeyCaps = winecaps.ddraw_caps.ssb_color_key_caps;
1303     caps.dwSSBFXCaps = winecaps.ddraw_caps.ssb_fx_caps;
1304
1305     /* Even if WineD3D supports 3D rendering, remove the cap if ddraw is configured
1306      * not to use it
1307      */
1308     if (DefaultSurfaceType == WINED3D_SURFACE_TYPE_GDI)
1309     {
1310         caps.dwCaps &= ~DDCAPS_3D;
1311         caps.ddsCaps.dwCaps &= ~(DDSCAPS_3DDEVICE | DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_ZBUFFER);
1312     }
1313     if (winecaps.ddraw_caps.stride_align)
1314     {
1315         caps.dwCaps |= DDCAPS_ALIGNSTRIDE;
1316         caps.dwAlignStrideAlign = winecaps.ddraw_caps.stride_align;
1317     }
1318
1319     if(DriverCaps)
1320     {
1321         DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps);
1322         if (TRACE_ON(ddraw))
1323         {
1324             TRACE("Driver Caps :\n");
1325             DDRAW_dump_DDCAPS(DriverCaps);
1326         }
1327
1328     }
1329     if(HELCaps)
1330     {
1331         DD_STRUCT_COPY_BYSIZE(HELCaps, &caps);
1332         if (TRACE_ON(ddraw))
1333         {
1334             TRACE("HEL Caps :\n");
1335             DDRAW_dump_DDCAPS(HELCaps);
1336         }
1337     }
1338
1339     return DD_OK;
1340 }
1341
1342 static HRESULT WINAPI ddraw4_GetCaps(IDirectDraw4 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1343 {
1344     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1345
1346     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1347
1348     return ddraw7_GetCaps(&This->IDirectDraw7_iface, driver_caps, hel_caps);
1349 }
1350
1351 static HRESULT WINAPI ddraw2_GetCaps(IDirectDraw2 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1352 {
1353     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1354
1355     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1356
1357     return ddraw7_GetCaps(&This->IDirectDraw7_iface, driver_caps, hel_caps);
1358 }
1359
1360 static HRESULT WINAPI ddraw1_GetCaps(IDirectDraw *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1361 {
1362     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1363
1364     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1365
1366     return ddraw7_GetCaps(&This->IDirectDraw7_iface, driver_caps, hel_caps);
1367 }
1368
1369 /*****************************************************************************
1370  * IDirectDraw7::Compact
1371  *
1372  * No idea what it does, MSDN says it's not implemented.
1373  *
1374  * Returns
1375  *  DD_OK, but this is unchecked
1376  *
1377  *****************************************************************************/
1378 static HRESULT WINAPI ddraw7_Compact(IDirectDraw7 *iface)
1379 {
1380     TRACE("iface %p.\n", iface);
1381
1382     return DD_OK;
1383 }
1384
1385 static HRESULT WINAPI ddraw4_Compact(IDirectDraw4 *iface)
1386 {
1387     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1388
1389     TRACE("iface %p.\n", iface);
1390
1391     return ddraw7_Compact(&This->IDirectDraw7_iface);
1392 }
1393
1394 static HRESULT WINAPI ddraw2_Compact(IDirectDraw2 *iface)
1395 {
1396     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1397
1398     TRACE("iface %p.\n", iface);
1399
1400     return ddraw7_Compact(&This->IDirectDraw7_iface);
1401 }
1402
1403 static HRESULT WINAPI ddraw1_Compact(IDirectDraw *iface)
1404 {
1405     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1406
1407     TRACE("iface %p.\n", iface);
1408
1409     return ddraw7_Compact(&This->IDirectDraw7_iface);
1410 }
1411
1412 /*****************************************************************************
1413  * IDirectDraw7::GetDisplayMode
1414  *
1415  * Returns information about the current display mode
1416  *
1417  * Exists in Version 1, 2, 4 and 7
1418  *
1419  * Params:
1420  *  DDSD: Address of a surface description structure to write the info to
1421  *
1422  * Returns
1423  *  DD_OK
1424  *
1425  *****************************************************************************/
1426 static HRESULT WINAPI ddraw7_GetDisplayMode(IDirectDraw7 *iface, DDSURFACEDESC2 *DDSD)
1427 {
1428     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1429     struct wined3d_display_mode mode;
1430     HRESULT hr;
1431     DWORD Size;
1432
1433     TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
1434
1435     wined3d_mutex_lock();
1436     /* This seems sane */
1437     if (!DDSD)
1438     {
1439         wined3d_mutex_unlock();
1440         return DDERR_INVALIDPARAMS;
1441     }
1442
1443     /* The necessary members of LPDDSURFACEDESC and LPDDSURFACEDESC2 are equal,
1444      * so one method can be used for all versions (Hopefully) */
1445     hr = wined3d_device_get_display_mode(This->wined3d_device, 0, &mode);
1446     if (FAILED(hr))
1447     {
1448         ERR(" (%p) IWineD3DDevice::GetDisplayMode returned %08x\n", This, hr);
1449         wined3d_mutex_unlock();
1450         return hr;
1451     }
1452
1453     Size = DDSD->dwSize;
1454     memset(DDSD, 0, Size);
1455
1456     DDSD->dwSize = Size;
1457     DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
1458     DDSD->dwWidth = mode.width;
1459     DDSD->dwHeight = mode.height;
1460     DDSD->u2.dwRefreshRate = 60;
1461     DDSD->ddsCaps.dwCaps = 0;
1462     DDSD->u4.ddpfPixelFormat.dwSize = sizeof(DDSD->u4.ddpfPixelFormat);
1463     PixelFormat_WineD3DtoDD(&DDSD->u4.ddpfPixelFormat, mode.format_id);
1464     DDSD->u1.lPitch = mode.width * DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount / 8;
1465
1466     if(TRACE_ON(ddraw))
1467     {
1468         TRACE("Returning surface desc :\n");
1469         DDRAW_dump_surface_desc(DDSD);
1470     }
1471
1472     wined3d_mutex_unlock();
1473
1474     return DD_OK;
1475 }
1476
1477 static HRESULT WINAPI ddraw4_GetDisplayMode(IDirectDraw4 *iface, DDSURFACEDESC2 *surface_desc)
1478 {
1479     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1480
1481     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1482
1483     return ddraw7_GetDisplayMode(&This->IDirectDraw7_iface, surface_desc);
1484 }
1485
1486 static HRESULT WINAPI ddraw2_GetDisplayMode(IDirectDraw2 *iface, DDSURFACEDESC *surface_desc)
1487 {
1488     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1489
1490     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1491
1492     /* FIXME: Test sizes, properly convert surface_desc */
1493     return ddraw7_GetDisplayMode(&This->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1494 }
1495
1496 static HRESULT WINAPI ddraw1_GetDisplayMode(IDirectDraw *iface, DDSURFACEDESC *surface_desc)
1497 {
1498     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1499
1500     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1501
1502     /* FIXME: Test sizes, properly convert surface_desc */
1503     return ddraw7_GetDisplayMode(&This->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1504 }
1505
1506 /*****************************************************************************
1507  * IDirectDraw7::GetFourCCCodes
1508  *
1509  * Returns an array of supported FourCC codes.
1510  *
1511  * Exists in Version 1, 2, 4 and 7
1512  *
1513  * Params:
1514  *  NumCodes: Contains the number of Codes that Codes can carry. Returns the number
1515  *            of enumerated codes
1516  *  Codes: Pointer to an array of DWORDs where the supported codes are written
1517  *         to
1518  *
1519  * Returns
1520  *  Always returns DD_OK, as it's a stub for now
1521  *
1522  *****************************************************************************/
1523 static HRESULT WINAPI ddraw7_GetFourCCCodes(IDirectDraw7 *iface, DWORD *NumCodes, DWORD *Codes)
1524 {
1525     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1526     static const enum wined3d_format_id formats[] =
1527     {
1528         WINED3DFMT_YUY2, WINED3DFMT_UYVY, WINED3DFMT_YV12,
1529         WINED3DFMT_DXT1, WINED3DFMT_DXT2, WINED3DFMT_DXT3, WINED3DFMT_DXT4, WINED3DFMT_DXT5,
1530         WINED3DFMT_ATI2N, WINED3DFMT_NVHU, WINED3DFMT_NVHS
1531     };
1532     struct wined3d_display_mode mode;
1533     DWORD count = 0, i, outsize;
1534     HRESULT hr;
1535
1536     TRACE("iface %p, codes_count %p, codes %p.\n", iface, NumCodes, Codes);
1537
1538     wined3d_device_get_display_mode(This->wined3d_device, 0, &mode);
1539
1540     outsize = NumCodes && Codes ? *NumCodes : 0;
1541
1542     for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); ++i)
1543     {
1544         hr = wined3d_check_device_format(This->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL,
1545                 mode.format_id, 0, WINED3D_RTYPE_SURFACE, formats[i], DefaultSurfaceType);
1546         if (SUCCEEDED(hr))
1547         {
1548             if (count < outsize)
1549                 Codes[count] = formats[i];
1550             ++count;
1551         }
1552     }
1553     if(NumCodes) {
1554         TRACE("Returning %u FourCC codes\n", count);
1555         *NumCodes = count;
1556     }
1557
1558     return DD_OK;
1559 }
1560
1561 static HRESULT WINAPI ddraw4_GetFourCCCodes(IDirectDraw4 *iface, DWORD *codes_count, DWORD *codes)
1562 {
1563     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1564
1565     TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1566
1567     return ddraw7_GetFourCCCodes(&This->IDirectDraw7_iface, codes_count, codes);
1568 }
1569
1570 static HRESULT WINAPI ddraw2_GetFourCCCodes(IDirectDraw2 *iface, DWORD *codes_count, DWORD *codes)
1571 {
1572     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1573
1574     TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1575
1576     return ddraw7_GetFourCCCodes(&This->IDirectDraw7_iface, codes_count, codes);
1577 }
1578
1579 static HRESULT WINAPI ddraw1_GetFourCCCodes(IDirectDraw *iface, DWORD *codes_count, DWORD *codes)
1580 {
1581     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1582
1583     TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1584
1585     return ddraw7_GetFourCCCodes(&This->IDirectDraw7_iface, codes_count, codes);
1586 }
1587
1588 /*****************************************************************************
1589  * IDirectDraw7::GetMonitorFrequency
1590  *
1591  * Returns the monitor's frequency
1592  *
1593  * Exists in Version 1, 2, 4 and 7
1594  *
1595  * Params:
1596  *  Freq: Pointer to a DWORD to write the frequency to
1597  *
1598  * Returns
1599  *  Always returns DD_OK
1600  *
1601  *****************************************************************************/
1602 static HRESULT WINAPI ddraw7_GetMonitorFrequency(IDirectDraw7 *iface, DWORD *Freq)
1603 {
1604     FIXME("iface %p, frequency %p stub!\n", iface, Freq);
1605
1606     /* Ideally this should be in WineD3D, as it concerns the screen setup,
1607      * but for now this should make the games happy
1608      */
1609     *Freq = 60;
1610     return DD_OK;
1611 }
1612
1613 static HRESULT WINAPI ddraw4_GetMonitorFrequency(IDirectDraw4 *iface, DWORD *frequency)
1614 {
1615     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1616
1617     TRACE("iface %p, frequency %p.\n", iface, frequency);
1618
1619     return ddraw7_GetMonitorFrequency(&This->IDirectDraw7_iface, frequency);
1620 }
1621
1622 static HRESULT WINAPI ddraw2_GetMonitorFrequency(IDirectDraw2 *iface, DWORD *frequency)
1623 {
1624     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1625
1626     TRACE("iface %p, frequency %p.\n", iface, frequency);
1627
1628     return ddraw7_GetMonitorFrequency(&This->IDirectDraw7_iface, frequency);
1629 }
1630
1631 static HRESULT WINAPI ddraw1_GetMonitorFrequency(IDirectDraw *iface, DWORD *frequency)
1632 {
1633     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1634
1635     TRACE("iface %p, frequency %p.\n", iface, frequency);
1636
1637     return ddraw7_GetMonitorFrequency(&This->IDirectDraw7_iface, frequency);
1638 }
1639
1640 /*****************************************************************************
1641  * IDirectDraw7::GetVerticalBlankStatus
1642  *
1643  * Returns the Vertical blank status of the monitor. This should be in WineD3D
1644  * too basically, but as it's a semi stub, I didn't create a function there
1645  *
1646  * Params:
1647  *  status: Pointer to a BOOL to be filled with the vertical blank status
1648  *
1649  * Returns
1650  *  DD_OK on success
1651  *  DDERR_INVALIDPARAMS if status is NULL
1652  *
1653  *****************************************************************************/
1654 static HRESULT WINAPI ddraw7_GetVerticalBlankStatus(IDirectDraw7 *iface, BOOL *status)
1655 {
1656     static BOOL fake_vblank;
1657
1658     TRACE("iface %p, status %p.\n", iface, status);
1659
1660     if(!status)
1661         return DDERR_INVALIDPARAMS;
1662
1663     *status = fake_vblank;
1664     fake_vblank = !fake_vblank;
1665
1666     return DD_OK;
1667 }
1668
1669 static HRESULT WINAPI ddraw4_GetVerticalBlankStatus(IDirectDraw4 *iface, BOOL *status)
1670 {
1671     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1672
1673     TRACE("iface %p, status %p.\n", iface, status);
1674
1675     return ddraw7_GetVerticalBlankStatus(&This->IDirectDraw7_iface, status);
1676 }
1677
1678 static HRESULT WINAPI ddraw2_GetVerticalBlankStatus(IDirectDraw2 *iface, BOOL *status)
1679 {
1680     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1681
1682     TRACE("iface %p, status %p.\n", iface, status);
1683
1684     return ddraw7_GetVerticalBlankStatus(&This->IDirectDraw7_iface, status);
1685 }
1686
1687 static HRESULT WINAPI ddraw1_GetVerticalBlankStatus(IDirectDraw *iface, BOOL *status)
1688 {
1689     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1690
1691     TRACE("iface %p, status %p.\n", iface, status);
1692
1693     return ddraw7_GetVerticalBlankStatus(&This->IDirectDraw7_iface, status);
1694 }
1695
1696 /*****************************************************************************
1697  * IDirectDraw7::GetAvailableVidMem
1698  *
1699  * Returns the total and free video memory
1700  *
1701  * Params:
1702  *  Caps: Specifies the memory type asked for
1703  *  total: Pointer to a DWORD to be filled with the total memory
1704  *  free: Pointer to a DWORD to be filled with the free memory
1705  *
1706  * Returns
1707  *  DD_OK on success
1708  *  DDERR_INVALIDPARAMS of free and total are NULL
1709  *
1710  *****************************************************************************/
1711 static HRESULT WINAPI ddraw7_GetAvailableVidMem(IDirectDraw7 *iface, DDSCAPS2 *Caps, DWORD *total,
1712         DWORD *free)
1713 {
1714     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1715     HRESULT hr = DD_OK;
1716
1717     TRACE("iface %p, caps %p, total %p, free %p.\n", iface, Caps, total, free);
1718
1719     if(TRACE_ON(ddraw))
1720     {
1721         TRACE("(%p) Asked for memory with description: ", This);
1722         DDRAW_dump_DDSCAPS2(Caps);
1723     }
1724     wined3d_mutex_lock();
1725
1726     /* Todo: System memory vs local video memory vs non-local video memory
1727      * The MSDN also mentions differences between texture memory and other
1728      * resources, but that's not important
1729      */
1730
1731     if( (!total) && (!free) )
1732     {
1733         wined3d_mutex_unlock();
1734         return DDERR_INVALIDPARAMS;
1735     }
1736
1737     if (free)
1738         *free = wined3d_device_get_available_texture_mem(This->wined3d_device);
1739     if (total)
1740     {
1741         struct wined3d_adapter_identifier desc = {0};
1742
1743         hr = wined3d_get_adapter_identifier(This->wined3d, WINED3DADAPTER_DEFAULT, 0, &desc);
1744         *total = desc.video_memory;
1745     }
1746
1747     wined3d_mutex_unlock();
1748
1749     return hr;
1750 }
1751
1752 static HRESULT WINAPI ddraw4_GetAvailableVidMem(IDirectDraw4 *iface,
1753         DDSCAPS2 *caps, DWORD *total, DWORD *free)
1754 {
1755     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1756
1757     TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1758
1759     return ddraw7_GetAvailableVidMem(&This->IDirectDraw7_iface, caps, total, free);
1760 }
1761
1762 static HRESULT WINAPI ddraw2_GetAvailableVidMem(IDirectDraw2 *iface,
1763         DDSCAPS *caps, DWORD *total, DWORD *free)
1764 {
1765     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1766     DDSCAPS2 caps2;
1767
1768     TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1769
1770     DDRAW_Convert_DDSCAPS_1_To_2(caps, &caps2);
1771     return ddraw7_GetAvailableVidMem(&This->IDirectDraw7_iface, &caps2, total, free);
1772 }
1773
1774 /*****************************************************************************
1775  * IDirectDraw7::Initialize
1776  *
1777  * Initializes a DirectDraw interface.
1778  *
1779  * Params:
1780  *  GUID: Interface identifier. Well, don't know what this is really good
1781  *   for
1782  *
1783  * Returns
1784  *  Returns DD_OK on the first call,
1785  *  DDERR_ALREADYINITIALIZED on repeated calls
1786  *
1787  *****************************************************************************/
1788 static HRESULT WINAPI ddraw7_Initialize(IDirectDraw7 *iface, GUID *guid)
1789 {
1790     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1791
1792     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1793
1794     if (This->initialized)
1795         return DDERR_ALREADYINITIALIZED;
1796
1797     /* FIXME: To properly take the GUID into account we should call
1798      * ddraw_init() here instead of in DDRAW_Create(). */
1799     if (guid)
1800         FIXME("Ignoring guid %s.\n", debugstr_guid(guid));
1801
1802     This->initialized = TRUE;
1803     return DD_OK;
1804 }
1805
1806 static HRESULT WINAPI ddraw4_Initialize(IDirectDraw4 *iface, GUID *guid)
1807 {
1808     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1809
1810     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1811
1812     return ddraw7_Initialize(&This->IDirectDraw7_iface, guid);
1813 }
1814
1815 static HRESULT WINAPI ddraw2_Initialize(IDirectDraw2 *iface, GUID *guid)
1816 {
1817     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1818
1819     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1820
1821     return ddraw7_Initialize(&This->IDirectDraw7_iface, guid);
1822 }
1823
1824 static HRESULT WINAPI ddraw1_Initialize(IDirectDraw *iface, GUID *guid)
1825 {
1826     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1827
1828     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1829
1830     return ddraw7_Initialize(&This->IDirectDraw7_iface, guid);
1831 }
1832
1833 static HRESULT WINAPI d3d1_Initialize(IDirect3D *iface, REFIID riid)
1834 {
1835     TRACE("iface %p, riid %s.\n", iface, debugstr_guid(riid));
1836
1837     return DDERR_ALREADYINITIALIZED;
1838 }
1839
1840 /*****************************************************************************
1841  * IDirectDraw7::FlipToGDISurface
1842  *
1843  * "Makes the surface that the GDI writes to the primary surface"
1844  * Looks like some windows specific thing we don't have to care about.
1845  * According to MSDN it permits GDI dialog boxes in FULLSCREEN mode. Good to
1846  * show error boxes ;)
1847  * Well, just return DD_OK.
1848  *
1849  * Returns:
1850  *  Always returns DD_OK
1851  *
1852  *****************************************************************************/
1853 static HRESULT WINAPI ddraw7_FlipToGDISurface(IDirectDraw7 *iface)
1854 {
1855     FIXME("iface %p stub!\n", iface);
1856
1857     return DD_OK;
1858 }
1859
1860 static HRESULT WINAPI ddraw4_FlipToGDISurface(IDirectDraw4 *iface)
1861 {
1862     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1863
1864     TRACE("iface %p.\n", iface);
1865
1866     return ddraw7_FlipToGDISurface(&This->IDirectDraw7_iface);
1867 }
1868
1869 static HRESULT WINAPI ddraw2_FlipToGDISurface(IDirectDraw2 *iface)
1870 {
1871     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1872
1873     TRACE("iface %p.\n", iface);
1874
1875     return ddraw7_FlipToGDISurface(&This->IDirectDraw7_iface);
1876 }
1877
1878 static HRESULT WINAPI ddraw1_FlipToGDISurface(IDirectDraw *iface)
1879 {
1880     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1881
1882     TRACE("iface %p.\n", iface);
1883
1884     return ddraw7_FlipToGDISurface(&This->IDirectDraw7_iface);
1885 }
1886
1887 /*****************************************************************************
1888  * IDirectDraw7::WaitForVerticalBlank
1889  *
1890  * This method allows applications to get in sync with the vertical blank
1891  * interval.
1892  * The wormhole demo in the DirectX 7 sdk uses this call, and it doesn't
1893  * redraw the screen, most likely because of this stub
1894  *
1895  * Parameters:
1896  *  Flags: one of DDWAITVB_BLOCKBEGIN, DDWAITVB_BLOCKBEGINEVENT
1897  *         or DDWAITVB_BLOCKEND
1898  *  h: Not used, according to MSDN
1899  *
1900  * Returns:
1901  *  Always returns DD_OK
1902  *
1903  *****************************************************************************/
1904 static HRESULT WINAPI ddraw7_WaitForVerticalBlank(IDirectDraw7 *iface, DWORD Flags, HANDLE event)
1905 {
1906     static BOOL hide;
1907
1908     TRACE("iface %p, flags %#x, event %p.\n", iface, Flags, event);
1909
1910     /* This function is called often, so print the fixme only once */
1911     if(!hide)
1912     {
1913         FIXME("iface %p, flags %#x, event %p stub!\n", iface, Flags, event);
1914         hide = TRUE;
1915     }
1916
1917     /* MSDN says DDWAITVB_BLOCKBEGINEVENT is not supported */
1918     if(Flags & DDWAITVB_BLOCKBEGINEVENT)
1919         return DDERR_UNSUPPORTED; /* unchecked */
1920
1921     return DD_OK;
1922 }
1923
1924 static HRESULT WINAPI ddraw4_WaitForVerticalBlank(IDirectDraw4 *iface, DWORD flags, HANDLE event)
1925 {
1926     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
1927
1928     TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1929
1930     return ddraw7_WaitForVerticalBlank(&This->IDirectDraw7_iface, flags, event);
1931 }
1932
1933 static HRESULT WINAPI ddraw2_WaitForVerticalBlank(IDirectDraw2 *iface, DWORD flags, HANDLE event)
1934 {
1935     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
1936
1937     TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1938
1939     return ddraw7_WaitForVerticalBlank(&This->IDirectDraw7_iface, flags, event);
1940 }
1941
1942 static HRESULT WINAPI ddraw1_WaitForVerticalBlank(IDirectDraw *iface, DWORD flags, HANDLE event)
1943 {
1944     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
1945
1946     TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1947
1948     return ddraw7_WaitForVerticalBlank(&This->IDirectDraw7_iface, flags, event);
1949 }
1950
1951 /*****************************************************************************
1952  * IDirectDraw7::GetScanLine
1953  *
1954  * Returns the scan line that is being drawn on the monitor
1955  *
1956  * Parameters:
1957  *  Scanline: Address to write the scan line value to
1958  *
1959  * Returns:
1960  *  Always returns DD_OK
1961  *
1962  *****************************************************************************/
1963 static HRESULT WINAPI ddraw7_GetScanLine(IDirectDraw7 *iface, DWORD *Scanline)
1964 {
1965     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
1966     struct wined3d_display_mode mode;
1967     static BOOL hide = FALSE;
1968     DWORD time, frame_progress, lines;
1969
1970     TRACE("iface %p, line %p.\n", iface, Scanline);
1971
1972     /* This function is called often, so print the fixme only once */
1973     if(!hide)
1974     {
1975         FIXME("iface %p, line %p partial stub!\n", iface, Scanline);
1976         hide = TRUE;
1977     }
1978
1979     wined3d_mutex_lock();
1980     wined3d_device_get_display_mode(This->wined3d_device, 0, &mode);
1981     wined3d_mutex_unlock();
1982
1983     /* Fake the line sweeping of the monitor */
1984     /* FIXME: We should synchronize with a source to keep the refresh rate */
1985
1986     /* Simulate a 60Hz display */
1987     time = GetTickCount();
1988     frame_progress = time & 15; /* time % (1000 / 60) */
1989     if (!frame_progress)
1990     {
1991         *Scanline = 0;
1992         return DDERR_VERTICALBLANKINPROGRESS;
1993     }
1994
1995     /* Convert frame_progress to estimated scan line. Return any line from
1996      * block determined by time. Some lines may be never returned */
1997     lines = mode.height / 15;
1998     *Scanline = (frame_progress - 1) * lines + time % lines;
1999     return DD_OK;
2000 }
2001
2002 static HRESULT WINAPI ddraw4_GetScanLine(IDirectDraw4 *iface, DWORD *line)
2003 {
2004     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
2005
2006     TRACE("iface %p, line %p.\n", iface, line);
2007
2008     return ddraw7_GetScanLine(&This->IDirectDraw7_iface, line);
2009 }
2010
2011 static HRESULT WINAPI ddraw2_GetScanLine(IDirectDraw2 *iface, DWORD *line)
2012 {
2013     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
2014
2015     TRACE("iface %p, line %p.\n", iface, line);
2016
2017     return ddraw7_GetScanLine(&This->IDirectDraw7_iface, line);
2018 }
2019
2020 static HRESULT WINAPI ddraw1_GetScanLine(IDirectDraw *iface, DWORD *line)
2021 {
2022     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
2023
2024     TRACE("iface %p, line %p.\n", iface, line);
2025
2026     return ddraw7_GetScanLine(&This->IDirectDraw7_iface, line);
2027 }
2028
2029 /*****************************************************************************
2030  * IDirectDraw7::TestCooperativeLevel
2031  *
2032  * Informs the application about the state of the video adapter, depending
2033  * on the cooperative level
2034  *
2035  * Returns:
2036  *  DD_OK if the device is in a sane state
2037  *  DDERR_NOEXCLUSIVEMODE or DDERR_EXCLUSIVEMODEALREADYSET
2038  *  if the state is not correct(See below)
2039  *
2040  *****************************************************************************/
2041 static HRESULT WINAPI ddraw7_TestCooperativeLevel(IDirectDraw7 *iface)
2042 {
2043     TRACE("iface %p.\n", iface);
2044
2045     return DD_OK;
2046 }
2047
2048 static HRESULT WINAPI ddraw4_TestCooperativeLevel(IDirectDraw4 *iface)
2049 {
2050     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
2051
2052     TRACE("iface %p.\n", iface);
2053
2054     return ddraw7_TestCooperativeLevel(&This->IDirectDraw7_iface);
2055 }
2056
2057 /*****************************************************************************
2058  * IDirectDraw7::GetGDISurface
2059  *
2060  * Returns the surface that GDI is treating as the primary surface.
2061  * For Wine this is the front buffer
2062  *
2063  * Params:
2064  *  GDISurface: Address to write the surface pointer to
2065  *
2066  * Returns:
2067  *  DD_OK if the surface was found
2068  *  DDERR_NOTFOUND if the GDI surface wasn't found
2069  *
2070  *****************************************************************************/
2071 static HRESULT WINAPI ddraw7_GetGDISurface(IDirectDraw7 *iface, IDirectDrawSurface7 **GDISurface)
2072 {
2073     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
2074
2075     TRACE("iface %p, surface %p.\n", iface, GDISurface);
2076
2077     wined3d_mutex_lock();
2078
2079     if (!(*GDISurface = &This->primary->IDirectDrawSurface7_iface))
2080     {
2081         WARN("Primary not created yet.\n");
2082         wined3d_mutex_unlock();
2083         return DDERR_NOTFOUND;
2084     }
2085     IDirectDrawSurface7_AddRef(*GDISurface);
2086
2087     wined3d_mutex_unlock();
2088
2089     return DD_OK;
2090 }
2091
2092 static HRESULT WINAPI ddraw4_GetGDISurface(IDirectDraw4 *iface, IDirectDrawSurface4 **surface)
2093 {
2094     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
2095     IDirectDrawSurface7 *surface7;
2096     IDirectDrawSurfaceImpl *surface_impl;
2097     HRESULT hr;
2098
2099     TRACE("iface %p, surface %p.\n", iface, surface);
2100
2101     hr = ddraw7_GetGDISurface(&This->IDirectDraw7_iface, &surface7);
2102     if (FAILED(hr))
2103     {
2104         *surface = NULL;
2105         return hr;
2106     }
2107     surface_impl = impl_from_IDirectDrawSurface7(surface7);
2108     *surface = &surface_impl->IDirectDrawSurface4_iface;
2109     IDirectDrawSurface4_AddRef(*surface);
2110     IDirectDrawSurface7_Release(surface7);
2111
2112     return hr;
2113 }
2114
2115 static HRESULT WINAPI ddraw2_GetGDISurface(IDirectDraw2 *iface, IDirectDrawSurface **surface)
2116 {
2117     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
2118     IDirectDrawSurface7 *surface7;
2119     IDirectDrawSurfaceImpl *surface_impl;
2120     HRESULT hr;
2121
2122     TRACE("iface %p, surface %p.\n", iface, surface);
2123
2124     hr = ddraw7_GetGDISurface(&This->IDirectDraw7_iface, &surface7);
2125     if (FAILED(hr))
2126     {
2127         *surface = NULL;
2128         return hr;
2129     }
2130     surface_impl = impl_from_IDirectDrawSurface7(surface7);
2131     *surface = &surface_impl->IDirectDrawSurface_iface;
2132     IDirectDrawSurface_AddRef(*surface);
2133     IDirectDrawSurface7_Release(surface7);
2134
2135     return hr;
2136 }
2137
2138 static HRESULT WINAPI ddraw1_GetGDISurface(IDirectDraw *iface, IDirectDrawSurface **surface)
2139 {
2140     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
2141     IDirectDrawSurface7 *surface7;
2142     IDirectDrawSurfaceImpl *surface_impl;
2143     HRESULT hr;
2144
2145     TRACE("iface %p, surface %p.\n", iface, surface);
2146
2147     hr = ddraw7_GetGDISurface(&This->IDirectDraw7_iface, &surface7);
2148     if (FAILED(hr))
2149     {
2150         *surface = NULL;
2151         return hr;
2152     }
2153     surface_impl = impl_from_IDirectDrawSurface7(surface7);
2154     *surface = &surface_impl->IDirectDrawSurface_iface;
2155     IDirectDrawSurface_AddRef(*surface);
2156     IDirectDrawSurface7_Release(surface7);
2157
2158     return hr;
2159 }
2160
2161 struct displaymodescallback_context
2162 {
2163     LPDDENUMMODESCALLBACK func;
2164     void *context;
2165 };
2166
2167 static HRESULT CALLBACK EnumDisplayModesCallbackThunk(DDSURFACEDESC2 *surface_desc, void *context)
2168 {
2169     struct displaymodescallback_context *cbcontext = context;
2170     DDSURFACEDESC desc;
2171
2172     DDSD2_to_DDSD(surface_desc, &desc);
2173     return cbcontext->func(&desc, cbcontext->context);
2174 }
2175
2176 /*****************************************************************************
2177  * IDirectDraw7::EnumDisplayModes
2178  *
2179  * Enumerates the supported Display modes. The modes can be filtered with
2180  * the DDSD parameter.
2181  *
2182  * Params:
2183  *  Flags: can be DDEDM_REFRESHRATES and DDEDM_STANDARDVGAMODES. For old ddraw
2184  *         versions (3 and older?) this is reserved and must be 0.
2185  *  DDSD: Surface description to filter the modes
2186  *  Context: Pointer passed back to the callback function
2187  *  cb: Application-provided callback function
2188  *
2189  * Returns:
2190  *  DD_OK on success
2191  *  DDERR_INVALIDPARAMS if the callback wasn't set
2192  *
2193  *****************************************************************************/
2194 static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
2195         DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMMODESCALLBACK2 cb)
2196 {
2197     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
2198     struct wined3d_display_mode *enum_modes = NULL;
2199     struct wined3d_display_mode mode;
2200     unsigned int modenum, fmt;
2201     DDSURFACEDESC2 callback_sd;
2202     unsigned enum_mode_count = 0, enum_mode_array_size = 0;
2203     DDPIXELFORMAT pixelformat;
2204
2205     static const enum wined3d_format_id checkFormatList[] =
2206     {
2207         WINED3DFMT_B8G8R8X8_UNORM,
2208         WINED3DFMT_B5G6R5_UNORM,
2209         WINED3DFMT_P8_UINT,
2210     };
2211
2212     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2213             iface, Flags, DDSD, Context, cb);
2214
2215     if (!cb)
2216         return DDERR_INVALIDPARAMS;
2217
2218     wined3d_mutex_lock();
2219     if(!(Flags & DDEDM_REFRESHRATES))
2220     {
2221         enum_mode_array_size = 16;
2222         enum_modes = HeapAlloc(GetProcessHeap(), 0, sizeof(*enum_modes) * enum_mode_array_size);
2223         if (!enum_modes)
2224         {
2225             ERR("Out of memory\n");
2226             wined3d_mutex_unlock();
2227             return DDERR_OUTOFMEMORY;
2228         }
2229     }
2230
2231     pixelformat.dwSize = sizeof(pixelformat);
2232     for(fmt = 0; fmt < (sizeof(checkFormatList) / sizeof(checkFormatList[0])); fmt++)
2233     {
2234         modenum = 0;
2235         while (wined3d_enum_adapter_modes(This->wined3d, WINED3DADAPTER_DEFAULT,
2236                 checkFormatList[fmt], modenum++, &mode) == WINED3D_OK)
2237         {
2238             PixelFormat_WineD3DtoDD(&pixelformat, mode.format_id);
2239             if (DDSD)
2240             {
2241                 if (DDSD->dwFlags & DDSD_WIDTH && mode.width != DDSD->dwWidth)
2242                     continue;
2243                 if (DDSD->dwFlags & DDSD_HEIGHT && mode.height != DDSD->dwHeight)
2244                     continue;
2245                 if (DDSD->dwFlags & DDSD_REFRESHRATE && mode.refresh_rate != DDSD->u2.dwRefreshRate)
2246                     continue;
2247                 if (DDSD->dwFlags & DDSD_PIXELFORMAT
2248                         && pixelformat.u1.dwRGBBitCount != DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount)
2249                     continue;
2250             }
2251
2252             if(!(Flags & DDEDM_REFRESHRATES))
2253             {
2254                 /* DX docs state EnumDisplayMode should return only unique modes. If DDEDM_REFRESHRATES is not set, refresh
2255                  * rate doesn't matter when determining if the mode is unique. So modes only differing in refresh rate have
2256                  * to be reduced to a single unique result in such case.
2257                  */
2258                 BOOL found = FALSE;
2259                 unsigned i;
2260
2261                 for (i = 0; i < enum_mode_count; i++)
2262                 {
2263                     if (enum_modes[i].width == mode.width && enum_modes[i].height == mode.height
2264                             && enum_modes[i].format_id == mode.format_id)
2265                     {
2266                         found = TRUE;
2267                         break;
2268                     }
2269                 }
2270
2271                 if(found) continue;
2272             }
2273
2274             memset(&callback_sd, 0, sizeof(callback_sd));
2275             callback_sd.dwSize = sizeof(callback_sd);
2276             callback_sd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
2277
2278             callback_sd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH|DDSD_REFRESHRATE;
2279             if (Flags & DDEDM_REFRESHRATES)
2280                 callback_sd.u2.dwRefreshRate = mode.refresh_rate;
2281
2282             callback_sd.dwWidth = mode.width;
2283             callback_sd.dwHeight = mode.height;
2284
2285             callback_sd.u4.ddpfPixelFormat=pixelformat;
2286
2287             /* Calc pitch and DWORD align like MSDN says */
2288             callback_sd.u1.lPitch = (callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8) * mode.width;
2289             callback_sd.u1.lPitch = (callback_sd.u1.lPitch + 3) & ~3;
2290
2291             TRACE("Enumerating %dx%dx%d @%d\n", callback_sd.dwWidth, callback_sd.dwHeight, callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount,
2292               callback_sd.u2.dwRefreshRate);
2293
2294             if(cb(&callback_sd, Context) == DDENUMRET_CANCEL)
2295             {
2296                 TRACE("Application asked to terminate the enumeration\n");
2297                 HeapFree(GetProcessHeap(), 0, enum_modes);
2298                 wined3d_mutex_unlock();
2299                 return DD_OK;
2300             }
2301
2302             if(!(Flags & DDEDM_REFRESHRATES))
2303             {
2304                 if (enum_mode_count == enum_mode_array_size)
2305                 {
2306                     struct wined3d_display_mode *new_enum_modes;
2307
2308                     enum_mode_array_size *= 2;
2309                     new_enum_modes = HeapReAlloc(GetProcessHeap(), 0, enum_modes,
2310                             sizeof(*new_enum_modes) * enum_mode_array_size);
2311                     if (!new_enum_modes)
2312                     {
2313                         ERR("Out of memory\n");
2314                         HeapFree(GetProcessHeap(), 0, enum_modes);
2315                         wined3d_mutex_unlock();
2316                         return DDERR_OUTOFMEMORY;
2317                     }
2318
2319                     enum_modes = new_enum_modes;
2320                 }
2321
2322                 enum_modes[enum_mode_count++] = mode;
2323             }
2324         }
2325     }
2326
2327     TRACE("End of enumeration\n");
2328     HeapFree(GetProcessHeap(), 0, enum_modes);
2329     wined3d_mutex_unlock();
2330
2331     return DD_OK;
2332 }
2333
2334 static HRESULT WINAPI ddraw4_EnumDisplayModes(IDirectDraw4 *iface, DWORD flags,
2335         DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMMODESCALLBACK2 callback)
2336 {
2337     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
2338
2339     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2340             iface, flags, surface_desc, context, callback);
2341
2342     return ddraw7_EnumDisplayModes(&This->IDirectDraw7_iface, flags, surface_desc, context, callback);
2343 }
2344
2345 static HRESULT WINAPI ddraw2_EnumDisplayModes(IDirectDraw2 *iface, DWORD flags,
2346         DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2347 {
2348     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
2349     struct displaymodescallback_context cbcontext;
2350     DDSURFACEDESC2 surface_desc2;
2351
2352     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2353             iface, flags, surface_desc, context, callback);
2354
2355     cbcontext.func = callback;
2356     cbcontext.context = context;
2357
2358     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2359     return ddraw7_EnumDisplayModes(&This->IDirectDraw7_iface, flags,
2360             surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2361 }
2362
2363 static HRESULT WINAPI ddraw1_EnumDisplayModes(IDirectDraw *iface, DWORD flags,
2364         DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2365 {
2366     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
2367     struct displaymodescallback_context cbcontext;
2368     DDSURFACEDESC2 surface_desc2;
2369
2370     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2371             iface, flags, surface_desc, context, callback);
2372
2373     cbcontext.func = callback;
2374     cbcontext.context = context;
2375
2376     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2377     return ddraw7_EnumDisplayModes(&This->IDirectDraw7_iface, flags,
2378             surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2379 }
2380
2381 /*****************************************************************************
2382  * IDirectDraw7::EvaluateMode
2383  *
2384  * Used with IDirectDraw7::StartModeTest to test video modes.
2385  * EvaluateMode is used to pass or fail a mode, and continue with the next
2386  * mode
2387  *
2388  * Params:
2389  *  Flags: DDEM_MODEPASSED or DDEM_MODEFAILED
2390  *  Timeout: Returns the amount of seconds left before the mode would have
2391  *           been failed automatically
2392  *
2393  * Returns:
2394  *  This implementation always DD_OK, because it's a stub
2395  *
2396  *****************************************************************************/
2397 static HRESULT WINAPI ddraw7_EvaluateMode(IDirectDraw7 *iface, DWORD Flags, DWORD *Timeout)
2398 {
2399     FIXME("iface %p, flags %#x, timeout %p stub!\n", iface, Flags, Timeout);
2400
2401     /* When implementing this, implement it in WineD3D */
2402
2403     return DD_OK;
2404 }
2405
2406 /*****************************************************************************
2407  * IDirectDraw7::GetDeviceIdentifier
2408  *
2409  * Returns the device identifier, which gives information about the driver
2410  * Our device identifier is defined at the beginning of this file.
2411  *
2412  * Params:
2413  *  DDDI: Address for the returned structure
2414  *  Flags: Can be DDGDI_GETHOSTIDENTIFIER
2415  *
2416  * Returns:
2417  *  On success it returns DD_OK
2418  *  DDERR_INVALIDPARAMS if DDDI is NULL
2419  *
2420  *****************************************************************************/
2421 static HRESULT WINAPI ddraw7_GetDeviceIdentifier(IDirectDraw7 *iface,
2422         DDDEVICEIDENTIFIER2 *DDDI, DWORD Flags)
2423 {
2424     TRACE("iface %p, device_identifier %p, flags %#x.\n", iface, DDDI, Flags);
2425
2426     if(!DDDI)
2427         return DDERR_INVALIDPARAMS;
2428
2429     /* The DDGDI_GETHOSTIDENTIFIER returns the information about the 2D
2430      * host adapter, if there's a secondary 3D adapter. This doesn't apply
2431      * to any modern hardware, nor is it interesting for Wine, so ignore it.
2432      * Size of DDDEVICEIDENTIFIER2 may be aligned to 8 bytes and thus 4
2433      * bytes too long. So only copy the relevant part of the structure
2434      */
2435
2436     memcpy(DDDI, &deviceidentifier, FIELD_OFFSET(DDDEVICEIDENTIFIER2, dwWHQLLevel) + sizeof(DWORD));
2437     return DD_OK;
2438 }
2439
2440 static HRESULT WINAPI ddraw4_GetDeviceIdentifier(IDirectDraw4 *iface,
2441         DDDEVICEIDENTIFIER *identifier, DWORD flags)
2442 {
2443     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
2444     DDDEVICEIDENTIFIER2 identifier2;
2445     HRESULT hr;
2446
2447     TRACE("iface %p, identifier %p, flags %#x.\n", iface, identifier, flags);
2448
2449     hr = ddraw7_GetDeviceIdentifier(&This->IDirectDraw7_iface, &identifier2, flags);
2450     DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(&identifier2, identifier);
2451
2452     return hr;
2453 }
2454
2455 /*****************************************************************************
2456  * IDirectDraw7::GetSurfaceFromDC
2457  *
2458  * Returns the Surface for a GDI device context handle.
2459  * Is this related to IDirectDrawSurface::GetDC ???
2460  *
2461  * Params:
2462  *  hdc: hdc to return the surface for
2463  *  Surface: Address to write the surface pointer to
2464  *
2465  * Returns:
2466  *  Always returns DD_OK because it's a stub
2467  *
2468  *****************************************************************************/
2469 static HRESULT WINAPI ddraw7_GetSurfaceFromDC(IDirectDraw7 *iface, HDC hdc,
2470         IDirectDrawSurface7 **Surface)
2471 {
2472     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
2473     struct wined3d_surface *wined3d_surface;
2474     HRESULT hr;
2475
2476     TRACE("iface %p, dc %p, surface %p.\n", iface, hdc, Surface);
2477
2478     if (!Surface) return E_INVALIDARG;
2479
2480     hr = wined3d_device_get_surface_from_dc(This->wined3d_device, hdc, &wined3d_surface);
2481     if (FAILED(hr))
2482     {
2483         TRACE("No surface found for dc %p.\n", hdc);
2484         *Surface = NULL;
2485         return DDERR_NOTFOUND;
2486     }
2487
2488     *Surface = wined3d_surface_get_parent(wined3d_surface);
2489     IDirectDrawSurface7_AddRef(*Surface);
2490     TRACE("Returning surface %p.\n", Surface);
2491     return DD_OK;
2492 }
2493
2494 static HRESULT WINAPI ddraw4_GetSurfaceFromDC(IDirectDraw4 *iface, HDC dc,
2495         IDirectDrawSurface4 **surface)
2496 {
2497     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
2498     IDirectDrawSurface7 *surface7;
2499     IDirectDrawSurfaceImpl *surface_impl;
2500     HRESULT hr;
2501
2502     TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2503
2504     if (!surface) return E_INVALIDARG;
2505
2506     hr = ddraw7_GetSurfaceFromDC(&This->IDirectDraw7_iface, dc, &surface7);
2507     if (FAILED(hr))
2508     {
2509         *surface = NULL;
2510         return hr;
2511     }
2512     surface_impl = impl_from_IDirectDrawSurface7(surface7);
2513     /* Tests say this is true */
2514     *surface = (IDirectDrawSurface4 *)&surface_impl->IDirectDrawSurface_iface;
2515     IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
2516     IDirectDrawSurface7_Release(surface7);
2517
2518     return hr;
2519 }
2520
2521 /*****************************************************************************
2522  * IDirectDraw7::RestoreAllSurfaces
2523  *
2524  * Calls the restore method of all surfaces
2525  *
2526  * Params:
2527  *
2528  * Returns:
2529  *  Always returns DD_OK because it's a stub
2530  *
2531  *****************************************************************************/
2532 static HRESULT WINAPI ddraw7_RestoreAllSurfaces(IDirectDraw7 *iface)
2533 {
2534     FIXME("iface %p stub!\n", iface);
2535
2536     /* This isn't hard to implement: Enumerate all WineD3D surfaces,
2537      * get their parent and call their restore method. Do not implement
2538      * it in WineD3D, as restoring a surface means re-creating the
2539      * WineD3DDSurface
2540      */
2541     return DD_OK;
2542 }
2543
2544 static HRESULT WINAPI ddraw4_RestoreAllSurfaces(IDirectDraw4 *iface)
2545 {
2546     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
2547
2548     TRACE("iface %p.\n", iface);
2549
2550     return ddraw7_RestoreAllSurfaces(&This->IDirectDraw7_iface);
2551 }
2552
2553 /*****************************************************************************
2554  * IDirectDraw7::StartModeTest
2555  *
2556  * Tests the specified video modes to update the system registry with
2557  * refresh rate information. StartModeTest starts the mode test,
2558  * EvaluateMode is used to fail or pass a mode. If EvaluateMode
2559  * isn't called within 15 seconds, the mode is failed automatically
2560  *
2561  * As refresh rates are handled by the X server, I don't think this
2562  * Method is important
2563  *
2564  * Params:
2565  *  Modes: An array of mode specifications
2566  *  NumModes: The number of modes in Modes
2567  *  Flags: Some flags...
2568  *
2569  * Returns:
2570  *  Returns DDERR_TESTFINISHED if flags contains DDSMT_ISTESTREQUIRED,
2571  *  if no modes are passed, DDERR_INVALIDPARAMS is returned,
2572  *  otherwise DD_OK
2573  *
2574  *****************************************************************************/
2575 static HRESULT WINAPI ddraw7_StartModeTest(IDirectDraw7 *iface, SIZE *Modes, DWORD NumModes, DWORD Flags)
2576 {
2577     FIXME("iface %p, modes %p, mode_count %u, flags %#x partial stub!\n",
2578             iface, Modes, NumModes, Flags);
2579
2580     /* This looks sane */
2581     if( (!Modes) || (NumModes == 0) ) return DDERR_INVALIDPARAMS;
2582
2583     /* DDSMT_ISTESTREQUIRED asks if a mode test is necessary.
2584      * As it is not, DDERR_TESTFINISHED is returned
2585      * (hopefully that's correct
2586      *
2587     if(Flags & DDSMT_ISTESTREQUIRED) return DDERR_TESTFINISHED;
2588      * well, that value doesn't (yet) exist in the wine headers, so ignore it
2589      */
2590
2591     return DD_OK;
2592 }
2593
2594 /*****************************************************************************
2595  * ddraw_create_surface
2596  *
2597  * A helper function for IDirectDraw7::CreateSurface. It creates a new surface
2598  * with the passed parameters.
2599  *
2600  * Params:
2601  *  DDSD: Description of the surface to create
2602  *  Surf: Address to store the interface pointer at
2603  *
2604  * Returns:
2605  *  DD_OK on success
2606  *
2607  *****************************************************************************/
2608 static HRESULT ddraw_create_surface(IDirectDrawImpl *This, DDSURFACEDESC2 *pDDSD,
2609         IDirectDrawSurfaceImpl **ppSurf, UINT level, UINT version)
2610 {
2611     HRESULT hr;
2612
2613     TRACE("ddraw %p, surface_desc %p, surface %p, level %u.\n",
2614             This, pDDSD, ppSurf, level);
2615
2616     if (TRACE_ON(ddraw))
2617     {
2618         TRACE(" (%p) Requesting surface desc :\n", This);
2619         DDRAW_dump_surface_desc(pDDSD);
2620     }
2621
2622     if ((pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) && DefaultSurfaceType != WINED3D_SURFACE_TYPE_OPENGL)
2623     {
2624         WARN("The application requests a 3D capable surface, but a non-OpenGL surface type was set in the registry.\n");
2625         /* Do not fail surface creation, only fail 3D device creation. */
2626     }
2627
2628     /* Create the Surface object */
2629     *ppSurf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawSurfaceImpl));
2630     if(!*ppSurf)
2631     {
2632         ERR("(%p) Error allocating memory for a surface\n", This);
2633         return DDERR_OUTOFVIDEOMEMORY;
2634     }
2635
2636     hr = ddraw_surface_init(*ppSurf, This, pDDSD, level, version);
2637     if (FAILED(hr))
2638     {
2639         WARN("Failed to initialize surface, hr %#x.\n", hr);
2640         HeapFree(GetProcessHeap(), 0, *ppSurf);
2641         return hr;
2642     }
2643
2644     /* Increase the surface counter, and attach the surface */
2645     list_add_head(&This->surface_list, &(*ppSurf)->surface_list_entry);
2646
2647     TRACE("Created surface %p.\n", *ppSurf);
2648
2649     return DD_OK;
2650 }
2651 /*****************************************************************************
2652  * CreateAdditionalSurfaces
2653  *
2654  * Creates a new mipmap chain.
2655  *
2656  * Params:
2657  *  root: Root surface to attach the newly created chain to
2658  *  count: number of surfaces to create
2659  *  DDSD: Description of the surface. Intentionally not a pointer to avoid side
2660  *        effects on the caller
2661  *  CubeFaceRoot: Whether the new surface is a root of a cube map face. This
2662  *                creates an additional surface without the mipmapping flags
2663  *
2664  *****************************************************************************/
2665 static HRESULT
2666 CreateAdditionalSurfaces(IDirectDrawImpl *This,
2667                          IDirectDrawSurfaceImpl *root,
2668                          UINT count,
2669                          DDSURFACEDESC2 DDSD,
2670                          BOOL CubeFaceRoot, UINT version)
2671 {
2672     UINT i, j, level = 0;
2673     HRESULT hr;
2674     IDirectDrawSurfaceImpl *last = root;
2675
2676     for(i = 0; i < count; i++)
2677     {
2678         IDirectDrawSurfaceImpl *object2 = NULL;
2679
2680         /* increase the mipmap level, but only if a mipmap is created
2681          * In this case, also halve the size
2682          */
2683         if(DDSD.ddsCaps.dwCaps & DDSCAPS_MIPMAP && !CubeFaceRoot)
2684         {
2685             level++;
2686             if(DDSD.dwWidth > 1) DDSD.dwWidth /= 2;
2687             if(DDSD.dwHeight > 1) DDSD.dwHeight /= 2;
2688             /* Set the mipmap sublevel flag according to msdn */
2689             DDSD.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
2690         }
2691         else
2692         {
2693             DDSD.ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2694         }
2695         CubeFaceRoot = FALSE;
2696
2697         hr = ddraw_create_surface(This, &DDSD, &object2, level, version);
2698         if(hr != DD_OK)
2699         {
2700             return hr;
2701         }
2702
2703         /* Add the new surface to the complex attachment array */
2704         for(j = 0; j < MAX_COMPLEX_ATTACHED; j++)
2705         {
2706             if(last->complex_array[j]) continue;
2707             last->complex_array[j] = object2;
2708             break;
2709         }
2710         last = object2;
2711
2712         /* Remove the (possible) back buffer cap from the new surface description,
2713          * because only one surface in the flipping chain is a back buffer, one
2714          * is a front buffer, the others are just primary surfaces.
2715          */
2716         DDSD.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER;
2717     }
2718     return DD_OK;
2719 }
2720
2721 static HRESULT CDECL ddraw_reset_enum_callback(struct wined3d_resource *resource)
2722 {
2723     return DD_OK;
2724 }
2725
2726 /*****************************************************************************
2727  * IDirectDraw7::CreateSurface
2728  *
2729  * Creates a new IDirectDrawSurface object and returns its interface.
2730  *
2731  * The surface connections with wined3d are a bit tricky. Basically it works
2732  * like this:
2733  *
2734  * |------------------------|               |-----------------|
2735  * | DDraw surface          |               | WineD3DSurface  |
2736  * |                        |               |                 |
2737  * |        WineD3DSurface  |-------------->|                 |
2738  * |        Child           |<------------->| Parent          |
2739  * |------------------------|               |-----------------|
2740  *
2741  * The DDraw surface is the parent of the wined3d surface, and it releases
2742  * the WineD3DSurface when the ddraw surface is destroyed.
2743  *
2744  * However, for all surfaces which can be in a container in WineD3D,
2745  * we have to do this. These surfaces are usually complex surfaces,
2746  * so this concerns primary surfaces with a front and a back buffer,
2747  * and textures.
2748  *
2749  * |------------------------|               |-----------------|
2750  * | DDraw surface          |               | Container       |
2751  * |                        |               |                 |
2752  * |                  Child |<------------->| Parent          |
2753  * |                Texture |<------------->|                 |
2754  * |         WineD3DSurface |<----|         |          Levels |<--|
2755  * | Complex connection     |     |         |                 |   |
2756  * |------------------------|     |         |-----------------|   |
2757  *  ^                             |                               |
2758  *  |                             |                               |
2759  *  |                             |                               |
2760  *  |    |------------------|     |         |-----------------|   |
2761  *  |    | IParent          |     |-------->| WineD3DSurface  |   |
2762  *  |    |                  |               |                 |   |
2763  *  |    |            Child |<------------->| Parent          |   |
2764  *  |    |                  |               |       Container |<--|
2765  *  |    |------------------|               |-----------------|   |
2766  *  |                                                             |
2767  *  |   |----------------------|                                  |
2768  *  |   | DDraw surface 2      |                                  |
2769  *  |   |                      |                                  |
2770  *  |<->| Complex root   Child |                                  |
2771  *  |   |              Texture |                                  |
2772  *  |   |       WineD3DSurface |<----|                            |
2773  *  |   |----------------------|     |                            |
2774  *  |                                |                            |
2775  *  |    |---------------------|     |      |-----------------|   |
2776  *  |    | IParent             |     |----->| WineD3DSurface  |   |
2777  *  |    |                     |            |                 |   |
2778  *  |    |               Child |<---------->| Parent          |   |
2779  *  |    |---------------------|            |       Container |<--|
2780  *  |                                       |-----------------|   |
2781  *  |                                                             |
2782  *  |             ---More surfaces can follow---                  |
2783  *
2784  * The reason is that the IWineD3DSwapchain(render target container)
2785  * and the IWineD3DTexure(Texture container) release the parents
2786  * of their surface's children, but by releasing the complex root
2787  * the surfaces which are complexly attached to it are destroyed
2788  * too. See IDirectDrawSurface::Release for a more detailed
2789  * explanation.
2790  *
2791  * Params:
2792  *  DDSD: Description of the surface to create
2793  *  Surf: Address to store the interface pointer at
2794  *  UnkOuter: Basically for aggregation support, but ddraw doesn't support
2795  *            aggregation, so it has to be NULL
2796  *
2797  * Returns:
2798  *  DD_OK on success
2799  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
2800  *  DDERR_* if an error occurs
2801  *
2802  *****************************************************************************/
2803 static HRESULT CreateSurface(IDirectDrawImpl *ddraw, DDSURFACEDESC2 *DDSD,
2804         IDirectDrawSurfaceImpl **Surf, IUnknown *UnkOuter, UINT version)
2805 {
2806     IDirectDrawSurfaceImpl *object = NULL;
2807     struct wined3d_display_mode mode;
2808     HRESULT hr;
2809     LONG extra_surfaces = 0;
2810     DDSURFACEDESC2 desc2;
2811     const DWORD sysvidmem = DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY;
2812
2813     TRACE("ddraw %p, surface_desc %p, surface %p, outer_unknown %p.\n", ddraw, DDSD, Surf, UnkOuter);
2814
2815     /* Some checks before we start */
2816     if (TRACE_ON(ddraw))
2817     {
2818         TRACE(" (%p) Requesting surface desc :\n", ddraw);
2819         DDRAW_dump_surface_desc(DDSD);
2820     }
2821
2822     if (UnkOuter != NULL)
2823     {
2824         FIXME("(%p) : outer != NULL?\n", ddraw);
2825         return CLASS_E_NOAGGREGATION; /* unchecked */
2826     }
2827
2828     if (Surf == NULL)
2829     {
2830         FIXME("(%p) You want to get back a surface? Don't give NULL ptrs!\n", ddraw);
2831         return E_POINTER; /* unchecked */
2832     }
2833
2834     if (!(DDSD->dwFlags & DDSD_CAPS))
2835     {
2836         /* DVIDEO.DLL does forget the DDSD_CAPS flag ... *sigh* */
2837         DDSD->dwFlags |= DDSD_CAPS;
2838     }
2839
2840     if (DDSD->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD)
2841     {
2842         /* If the surface is of the 'alloconload' type, ignore the LPSURFACE field */
2843         DDSD->dwFlags &= ~DDSD_LPSURFACE;
2844     }
2845
2846     if ((DDSD->dwFlags & DDSD_LPSURFACE) && (DDSD->lpSurface == NULL))
2847     {
2848         /* Frank Herbert's Dune specifies a null pointer for the surface, ignore the LPSURFACE field */
2849         WARN("(%p) Null surface pointer specified, ignore it!\n", ddraw);
2850         DDSD->dwFlags &= ~DDSD_LPSURFACE;
2851     }
2852
2853     if((DDSD->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE)) == (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE) &&
2854        !(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
2855     {
2856         TRACE("(%p): Attempt to create a flipable primary surface without DDSCL_EXCLUSIVE set\n",
2857                 ddraw);
2858         *Surf = NULL;
2859         return DDERR_NOEXCLUSIVEMODE;
2860     }
2861
2862     if((DDSD->ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER | DDSCAPS_PRIMARYSURFACE)) == (DDSCAPS_BACKBUFFER | DDSCAPS_PRIMARYSURFACE))
2863     {
2864         WARN("Application wanted to create back buffer primary surface\n");
2865         return DDERR_INVALIDCAPS;
2866     }
2867
2868     if((DDSD->ddsCaps.dwCaps & sysvidmem) == sysvidmem)
2869     {
2870         /* This is a special switch in ddrawex.dll, but not allowed in ddraw.dll */
2871         WARN("Application tries to put the surface in both system and video memory\n");
2872         *Surf = NULL;
2873         return DDERR_INVALIDCAPS;
2874     }
2875
2876     /* Check cube maps but only if the size includes them */
2877     if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2878     {
2879         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES &&
2880            !(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
2881         {
2882             WARN("Cube map faces requested without cube map flag\n");
2883             return DDERR_INVALIDCAPS;
2884         }
2885         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2886            (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) == 0)
2887         {
2888             WARN("Cube map without faces requested\n");
2889             return DDERR_INVALIDPARAMS;
2890         }
2891
2892         /* Quick tests confirm those can be created, but we don't do that yet */
2893         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2894            (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
2895         {
2896             FIXME("Partial cube maps not supported yet\n");
2897         }
2898     }
2899
2900     /* According to the msdn this flag is ignored by CreateSurface */
2901     if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2902         DDSD->ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2903
2904     /* Modify some flags */
2905     copy_to_surfacedesc2(&desc2, DDSD);
2906     desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT); /* Just to be sure */
2907
2908     /* Get the video mode from WineD3D - we will need it */
2909     hr = wined3d_device_get_display_mode(ddraw->wined3d_device, 0, &mode);
2910     if (FAILED(hr))
2911     {
2912         ERR("Failed to read display mode from wined3d\n");
2913         switch(ddraw->orig_bpp)
2914         {
2915             case 8:
2916                 mode.format_id = WINED3DFMT_P8_UINT;
2917                 break;
2918
2919             case 15:
2920                 mode.format_id = WINED3DFMT_B5G5R5X1_UNORM;
2921                 break;
2922
2923             case 16:
2924                 mode.format_id = WINED3DFMT_B5G6R5_UNORM;
2925                 break;
2926
2927             case 24:
2928                 mode.format_id = WINED3DFMT_B8G8R8_UNORM;
2929                 break;
2930
2931             case 32:
2932                 mode.format_id = WINED3DFMT_B8G8R8X8_UNORM;
2933                 break;
2934         }
2935         mode.width = ddraw->orig_width;
2936         mode.height = ddraw->orig_height;
2937     }
2938
2939     /* No pixelformat given? Use the current screen format */
2940     if(!(desc2.dwFlags & DDSD_PIXELFORMAT))
2941     {
2942         desc2.dwFlags |= DDSD_PIXELFORMAT;
2943         desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT);
2944
2945         PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, mode.format_id);
2946     }
2947
2948     /* No Width or no Height? Use the original screen size
2949      */
2950     if(!(desc2.dwFlags & DDSD_WIDTH) ||
2951        !(desc2.dwFlags & DDSD_HEIGHT) )
2952     {
2953         /* Invalid for non-render targets */
2954         if(!(desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
2955         {
2956             WARN("Creating a non-Primary surface without Width or Height info, returning DDERR_INVALIDPARAMS\n");
2957             *Surf = NULL;
2958             return DDERR_INVALIDPARAMS;
2959         }
2960
2961         desc2.dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
2962         desc2.dwWidth = mode.width;
2963         desc2.dwHeight = mode.height;
2964     }
2965
2966     if (!desc2.dwWidth || !desc2.dwHeight)
2967         return DDERR_INVALIDPARAMS;
2968
2969     /* Mipmap count fixes */
2970     if(desc2.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
2971     {
2972         if(desc2.ddsCaps.dwCaps & DDSCAPS_COMPLEX)
2973         {
2974             if(desc2.dwFlags & DDSD_MIPMAPCOUNT)
2975             {
2976                 /* Mipmap count is given, should not be 0 */
2977                 if( desc2.u2.dwMipMapCount == 0 )
2978                     return DDERR_INVALIDPARAMS;
2979             }
2980             else
2981             {
2982                 /* Undocumented feature: Create sublevels until
2983                  * either the width or the height is 1
2984                  */
2985                 DWORD min = desc2.dwWidth < desc2.dwHeight ?
2986                             desc2.dwWidth : desc2.dwHeight;
2987                 desc2.u2.dwMipMapCount = 0;
2988                 while( min )
2989                 {
2990                     desc2.u2.dwMipMapCount += 1;
2991                     min >>= 1;
2992                 }
2993             }
2994         }
2995         else
2996         {
2997             /* Not-complex mipmap -> Mipmapcount = 1 */
2998             desc2.u2.dwMipMapCount = 1;
2999         }
3000         extra_surfaces = desc2.u2.dwMipMapCount - 1;
3001
3002         /* There's a mipmap count in the created surface in any case */
3003         desc2.dwFlags |= DDSD_MIPMAPCOUNT;
3004     }
3005     /* If no mipmap is given, the texture has only one level */
3006
3007     /* The first surface is a front buffer, the back buffer is created afterwards */
3008     if( (desc2.dwFlags & DDSD_CAPS) && (desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) )
3009     {
3010         desc2.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
3011     }
3012
3013     /* The root surface in a cube map is positive x */
3014     if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
3015     {
3016         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
3017         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEX;
3018     }
3019
3020     if ((desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) && (ddraw->cooperative_level & DDSCL_EXCLUSIVE))
3021     {
3022         struct wined3d_swapchain_desc swapchain_desc;
3023
3024         hr = wined3d_swapchain_get_desc(ddraw->wined3d_swapchain, &swapchain_desc);
3025         if (FAILED(hr))
3026         {
3027             ERR("Failed to get present parameters.\n");
3028             return hr;
3029         }
3030
3031         swapchain_desc.backbuffer_width = mode.width;
3032         swapchain_desc.backbuffer_height = mode.height;
3033         swapchain_desc.backbuffer_format = mode.format_id;
3034
3035         hr = wined3d_device_reset(ddraw->wined3d_device,
3036                 &swapchain_desc, ddraw_reset_enum_callback);
3037         if (FAILED(hr))
3038         {
3039             ERR("Failed to reset device.\n");
3040             return hr;
3041         }
3042     }
3043
3044     /* Create the first surface */
3045     hr = ddraw_create_surface(ddraw, &desc2, &object, 0, version);
3046     if (FAILED(hr))
3047     {
3048         WARN("ddraw_create_surface failed, hr %#x.\n", hr);
3049         return hr;
3050     }
3051     object->is_complex_root = TRUE;
3052
3053     *Surf = object;
3054
3055     /* Create Additional surfaces if necessary
3056      * This applies to Primary surfaces which have a back buffer count
3057      * set, but not to mipmap textures. In case of Mipmap textures,
3058      * wineD3D takes care of the creation of additional surfaces
3059      */
3060     if(DDSD->dwFlags & DDSD_BACKBUFFERCOUNT)
3061     {
3062         extra_surfaces = DDSD->dwBackBufferCount;
3063         desc2.ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER; /* It's not a front buffer */
3064         desc2.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
3065         desc2.dwBackBufferCount = 0;
3066     }
3067
3068     hr = DD_OK;
3069     if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
3070     {
3071         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
3072         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEZ;
3073         hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3074         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEZ;
3075         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEZ;
3076         hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3077         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEZ;
3078         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEY;
3079         hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3080         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEY;
3081         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEY;
3082         hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3083         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEY;
3084         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEX;
3085         hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3086         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEX;
3087         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEX;
3088     }
3089
3090     hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces, desc2, FALSE, version);
3091     if(hr != DD_OK)
3092     {
3093         /* This destroys and possibly created surfaces too */
3094         if (version == 7)
3095             IDirectDrawSurface7_Release(&object->IDirectDrawSurface7_iface);
3096         else if (version == 4)
3097             IDirectDrawSurface4_Release(&object->IDirectDrawSurface4_iface);
3098         else
3099             IDirectDrawSurface_Release(&object->IDirectDrawSurface_iface);
3100
3101         return hr;
3102     }
3103
3104     if (desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
3105         ddraw->primary = object;
3106
3107     /* Create a WineD3DTexture if a texture was requested */
3108     if (desc2.ddsCaps.dwCaps & DDSCAPS_TEXTURE)
3109     {
3110         ddraw->tex_root = object;
3111         ddraw_surface_create_texture(object);
3112         ddraw->tex_root = NULL;
3113     }
3114
3115     return hr;
3116 }
3117
3118 static HRESULT WINAPI ddraw7_CreateSurface(IDirectDraw7 *iface, DDSURFACEDESC2 *surface_desc,
3119         IDirectDrawSurface7 **surface, IUnknown *outer_unknown)
3120 {
3121     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
3122     IDirectDrawSurfaceImpl *impl;
3123     HRESULT hr;
3124
3125     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3126             iface, surface_desc, surface, outer_unknown);
3127
3128     wined3d_mutex_lock();
3129
3130     if (!(This->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3131     {
3132         WARN("Cooperative level not set.\n");
3133         wined3d_mutex_unlock();
3134         return DDERR_NOCOOPERATIVELEVELSET;
3135     }
3136
3137     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
3138     {
3139         WARN("Application supplied invalid surface descriptor\n");
3140         wined3d_mutex_unlock();
3141         return DDERR_INVALIDPARAMS;
3142     }
3143
3144     if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3145     {
3146         if (TRACE_ON(ddraw))
3147         {
3148             TRACE(" (%p) Requesting surface desc :\n", iface);
3149             DDRAW_dump_surface_desc(surface_desc);
3150         }
3151
3152         WARN("Application tried to create an explicit front or back buffer\n");
3153         wined3d_mutex_unlock();
3154         return DDERR_INVALIDCAPS;
3155     }
3156
3157     hr = CreateSurface(This, surface_desc, &impl, outer_unknown, 7);
3158     wined3d_mutex_unlock();
3159     if (FAILED(hr))
3160     {
3161         *surface = NULL;
3162         return hr;
3163     }
3164
3165     *surface = &impl->IDirectDrawSurface7_iface;
3166     IDirectDraw7_AddRef(iface);
3167     impl->ifaceToRelease = (IUnknown *)iface;
3168
3169     return hr;
3170 }
3171
3172 static HRESULT WINAPI ddraw4_CreateSurface(IDirectDraw4 *iface,
3173         DDSURFACEDESC2 *surface_desc, IDirectDrawSurface4 **surface, IUnknown *outer_unknown)
3174 {
3175     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
3176     IDirectDrawSurfaceImpl *impl;
3177     HRESULT hr;
3178
3179     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3180             iface, surface_desc, surface, outer_unknown);
3181
3182     wined3d_mutex_lock();
3183
3184     if (!(This->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3185     {
3186         WARN("Cooperative level not set.\n");
3187         wined3d_mutex_unlock();
3188         return DDERR_NOCOOPERATIVELEVELSET;
3189     }
3190
3191     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
3192     {
3193         WARN("Application supplied invalid surface descriptor\n");
3194         wined3d_mutex_unlock();
3195         return DDERR_INVALIDPARAMS;
3196     }
3197
3198     if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3199     {
3200         if (TRACE_ON(ddraw))
3201         {
3202             TRACE(" (%p) Requesting surface desc :\n", iface);
3203             DDRAW_dump_surface_desc(surface_desc);
3204         }
3205
3206         WARN("Application tried to create an explicit front or back buffer\n");
3207         wined3d_mutex_unlock();
3208         return DDERR_INVALIDCAPS;
3209     }
3210
3211     hr = CreateSurface(This, surface_desc, &impl, outer_unknown, 4);
3212     wined3d_mutex_unlock();
3213     if (FAILED(hr))
3214     {
3215         *surface = NULL;
3216         return hr;
3217     }
3218
3219     *surface = &impl->IDirectDrawSurface4_iface;
3220     IDirectDraw4_AddRef(iface);
3221     impl->ifaceToRelease = (IUnknown *)iface;
3222
3223     return hr;
3224 }
3225
3226 static HRESULT WINAPI ddraw2_CreateSurface(IDirectDraw2 *iface,
3227         DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
3228 {
3229     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
3230     IDirectDrawSurfaceImpl *impl;
3231     HRESULT hr;
3232     DDSURFACEDESC2 surface_desc2;
3233
3234     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3235             iface, surface_desc, surface, outer_unknown);
3236
3237     wined3d_mutex_lock();
3238
3239     if (!(This->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3240     {
3241         WARN("Cooperative level not set.\n");
3242         wined3d_mutex_unlock();
3243         return DDERR_NOCOOPERATIVELEVELSET;
3244     }
3245
3246     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3247     {
3248         WARN("Application supplied invalid surface descriptor\n");
3249         wined3d_mutex_unlock();
3250         return DDERR_INVALIDPARAMS;
3251     }
3252
3253     DDSD_to_DDSD2(surface_desc, &surface_desc2);
3254     if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3255     {
3256         if (TRACE_ON(ddraw))
3257         {
3258             TRACE(" (%p) Requesting surface desc :\n", iface);
3259             DDRAW_dump_surface_desc((LPDDSURFACEDESC2)surface_desc);
3260         }
3261
3262         WARN("Application tried to create an explicit front or back buffer\n");
3263         wined3d_mutex_unlock();
3264         return DDERR_INVALIDCAPS;
3265     }
3266
3267     hr = CreateSurface(This, &surface_desc2, &impl, outer_unknown, 2);
3268     wined3d_mutex_unlock();
3269     if (FAILED(hr))
3270     {
3271         *surface = NULL;
3272         return hr;
3273     }
3274
3275     *surface = &impl->IDirectDrawSurface_iface;
3276     impl->ifaceToRelease = NULL;
3277
3278     return hr;
3279 }
3280
3281 static HRESULT WINAPI ddraw1_CreateSurface(IDirectDraw *iface,
3282         DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
3283 {
3284     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
3285     IDirectDrawSurfaceImpl *impl;
3286     HRESULT hr;
3287     DDSURFACEDESC2 surface_desc2;
3288
3289     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3290             iface, surface_desc, surface, outer_unknown);
3291
3292     wined3d_mutex_lock();
3293
3294     if (!(This->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3295     {
3296         WARN("Cooperative level not set.\n");
3297         wined3d_mutex_unlock();
3298         return DDERR_NOCOOPERATIVELEVELSET;
3299     }
3300
3301     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3302     {
3303         WARN("Application supplied invalid surface descriptor\n");
3304         wined3d_mutex_unlock();
3305         return DDERR_INVALIDPARAMS;
3306     }
3307
3308     /* Remove front buffer flag, this causes failure in v7, and its added to normal
3309      * primaries anyway. */
3310     surface_desc->ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER;
3311     DDSD_to_DDSD2(surface_desc, &surface_desc2);
3312     hr = CreateSurface(This, &surface_desc2, &impl, outer_unknown, 1);
3313     wined3d_mutex_unlock();
3314     if (FAILED(hr))
3315     {
3316         *surface = NULL;
3317         return hr;
3318     }
3319
3320     *surface = &impl->IDirectDrawSurface_iface;
3321     impl->ifaceToRelease = NULL;
3322
3323     return hr;
3324 }
3325
3326 #define DDENUMSURFACES_SEARCHTYPE (DDENUMSURFACES_CANBECREATED|DDENUMSURFACES_DOESEXIST)
3327 #define DDENUMSURFACES_MATCHTYPE (DDENUMSURFACES_ALL|DDENUMSURFACES_MATCH|DDENUMSURFACES_NOMATCH)
3328
3329 static BOOL
3330 Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
3331                                     const DDPIXELFORMAT *provided)
3332 {
3333     /* Some flags must be present in both or neither for a match. */
3334     static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
3335         | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
3336         | DDPF_ZBUFFER | DDPF_STENCILBUFFER;
3337
3338     if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3339         return FALSE;
3340
3341     if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
3342         return FALSE;
3343
3344     if (requested->dwFlags & DDPF_FOURCC)
3345         if (requested->dwFourCC != provided->dwFourCC)
3346             return FALSE;
3347
3348     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
3349                               |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3350         if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
3351             return FALSE;
3352
3353     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3354                               |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3355         if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
3356             return FALSE;
3357
3358     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
3359         if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
3360             return FALSE;
3361
3362     /* I could be wrong about the bumpmapping. MSDN docs are vague. */
3363     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3364                               |DDPF_BUMPDUDV))
3365         if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
3366             return FALSE;
3367
3368     if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
3369         if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
3370             return FALSE;
3371
3372     return TRUE;
3373 }
3374
3375 static BOOL ddraw_match_surface_desc(const DDSURFACEDESC2 *requested, const DDSURFACEDESC2 *provided)
3376 {
3377     struct compare_info
3378     {
3379         DWORD flag;
3380         ptrdiff_t offset;
3381         size_t size;
3382     };
3383
3384 #define CMP(FLAG, FIELD)                                \
3385         { DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
3386           sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
3387
3388     static const struct compare_info compare[] =
3389     {
3390         CMP(ALPHABITDEPTH, dwAlphaBitDepth),
3391         CMP(BACKBUFFERCOUNT, dwBackBufferCount),
3392         CMP(CAPS, ddsCaps),
3393         CMP(CKDESTBLT, ddckCKDestBlt),
3394         CMP(CKDESTOVERLAY, u3 /* ddckCKDestOverlay */),
3395         CMP(CKSRCBLT, ddckCKSrcBlt),
3396         CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
3397         CMP(HEIGHT, dwHeight),
3398         CMP(LINEARSIZE, u1 /* dwLinearSize */),
3399         CMP(LPSURFACE, lpSurface),
3400         CMP(MIPMAPCOUNT, u2 /* dwMipMapCount */),
3401         CMP(PITCH, u1 /* lPitch */),
3402         /* PIXELFORMAT: manual */
3403         CMP(REFRESHRATE, u2 /* dwRefreshRate */),
3404         CMP(TEXTURESTAGE, dwTextureStage),
3405         CMP(WIDTH, dwWidth),
3406         /* ZBUFFERBITDEPTH: "obsolete" */
3407     };
3408
3409 #undef CMP
3410
3411     unsigned int i;
3412
3413     if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3414         return FALSE;
3415
3416     for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
3417     {
3418         if (requested->dwFlags & compare[i].flag
3419             && memcmp((const char *)provided + compare[i].offset,
3420                       (const char *)requested + compare[i].offset,
3421                       compare[i].size) != 0)
3422             return FALSE;
3423     }
3424
3425     if (requested->dwFlags & DDSD_PIXELFORMAT)
3426     {
3427         if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
3428                                                 &provided->u4.ddpfPixelFormat))
3429             return FALSE;
3430     }
3431
3432     return TRUE;
3433 }
3434
3435 #undef DDENUMSURFACES_SEARCHTYPE
3436 #undef DDENUMSURFACES_MATCHTYPE
3437
3438 struct surfacescallback2_context
3439 {
3440     LPDDENUMSURFACESCALLBACK2 func;
3441     void *context;
3442 };
3443
3444 struct surfacescallback_context
3445 {
3446     LPDDENUMSURFACESCALLBACK func;
3447     void *context;
3448 };
3449
3450 static HRESULT CALLBACK EnumSurfacesCallback2Thunk(IDirectDrawSurface7 *surface,
3451         DDSURFACEDESC2 *surface_desc, void *context)
3452 {
3453     IDirectDrawSurfaceImpl *surface_impl = impl_from_IDirectDrawSurface7(surface);
3454     struct surfacescallback2_context *cbcontext = context;
3455
3456     IDirectDrawSurface4_AddRef(&surface_impl->IDirectDrawSurface4_iface);
3457     IDirectDrawSurface7_Release(surface);
3458
3459     return cbcontext->func(&surface_impl->IDirectDrawSurface4_iface,
3460             surface_desc, cbcontext->context);
3461 }
3462
3463 static HRESULT CALLBACK EnumSurfacesCallbackThunk(IDirectDrawSurface7 *surface,
3464         DDSURFACEDESC2 *surface_desc, void *context)
3465 {
3466     IDirectDrawSurfaceImpl *surface_impl = impl_from_IDirectDrawSurface7(surface);
3467     struct surfacescallback_context *cbcontext = context;
3468
3469     IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
3470     IDirectDrawSurface7_Release(surface);
3471
3472     return cbcontext->func(&surface_impl->IDirectDrawSurface_iface,
3473             (DDSURFACEDESC *)surface_desc, cbcontext->context);
3474 }
3475
3476 /*****************************************************************************
3477  * IDirectDraw7::EnumSurfaces
3478  *
3479  * Loops through all surfaces attached to this device and calls the
3480  * application callback. This can't be relayed to WineD3DDevice,
3481  * because some WineD3DSurfaces' parents are IParent objects
3482  *
3483  * Params:
3484  *  Flags: Some filtering flags. See IDirectDrawImpl_EnumSurfacesCallback
3485  *  DDSD: Description to filter for
3486  *  Context: Application-provided pointer, it's passed unmodified to the
3487  *           Callback function
3488  *  Callback: Address to call for each surface
3489  *
3490  * Returns:
3491  *  DDERR_INVALIDPARAMS if the callback is NULL
3492  *  DD_OK on success
3493  *
3494  *****************************************************************************/
3495 static HRESULT WINAPI ddraw7_EnumSurfaces(IDirectDraw7 *iface, DWORD Flags,
3496         DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMSURFACESCALLBACK7 Callback)
3497 {
3498     /* The surface enumeration is handled by WineDDraw,
3499      * because it keeps track of all surfaces attached to
3500      * it. The filtering is done by our callback function,
3501      * because WineDDraw doesn't handle ddraw-like surface
3502      * caps structures
3503      */
3504     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
3505     IDirectDrawSurfaceImpl *surf;
3506     BOOL all, nomatch;
3507     DDSURFACEDESC2 desc;
3508     struct list *entry, *entry2;
3509
3510     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3511             iface, Flags, DDSD, Context, Callback);
3512
3513     all = Flags & DDENUMSURFACES_ALL;
3514     nomatch = Flags & DDENUMSURFACES_NOMATCH;
3515
3516     if (!Callback)
3517         return DDERR_INVALIDPARAMS;
3518
3519     wined3d_mutex_lock();
3520
3521     /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
3522     LIST_FOR_EACH_SAFE(entry, entry2, &This->surface_list)
3523     {
3524         surf = LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
3525
3526         if (!surf->iface_count)
3527         {
3528             WARN("Not enumerating surface %p because it doesn't have any references.\n", surf);
3529             continue;
3530         }
3531
3532         if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
3533         {
3534             TRACE("Enumerating surface %p.\n", surf);
3535             desc = surf->surface_desc;
3536             IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface);
3537             if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK)
3538             {
3539                 wined3d_mutex_unlock();
3540                 return DD_OK;
3541             }
3542         }
3543     }
3544
3545     wined3d_mutex_unlock();
3546
3547     return DD_OK;
3548 }
3549
3550 static HRESULT WINAPI ddraw4_EnumSurfaces(IDirectDraw4 *iface, DWORD flags,
3551         DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMSURFACESCALLBACK2 callback)
3552 {
3553     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
3554     struct surfacescallback2_context cbcontext;
3555
3556     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3557             iface, flags, surface_desc, context, callback);
3558
3559     cbcontext.func = callback;
3560     cbcontext.context = context;
3561
3562     return ddraw7_EnumSurfaces(&This->IDirectDraw7_iface, flags, surface_desc,
3563             &cbcontext, EnumSurfacesCallback2Thunk);
3564 }
3565
3566 static HRESULT WINAPI ddraw2_EnumSurfaces(IDirectDraw2 *iface, DWORD flags,
3567         DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3568 {
3569     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
3570     struct surfacescallback_context cbcontext;
3571     DDSURFACEDESC2 surface_desc2;
3572
3573     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3574             iface, flags, surface_desc, context, callback);
3575
3576     cbcontext.func = callback;
3577     cbcontext.context = context;
3578
3579     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3580     return ddraw7_EnumSurfaces(&This->IDirectDraw7_iface, flags,
3581             surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3582 }
3583
3584 static HRESULT WINAPI ddraw1_EnumSurfaces(IDirectDraw *iface, DWORD flags,
3585         DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3586 {
3587     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
3588     struct surfacescallback_context cbcontext;
3589     DDSURFACEDESC2 surface_desc2;
3590
3591     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3592             iface, flags, surface_desc, context, callback);
3593
3594     cbcontext.func = callback;
3595     cbcontext.context = context;
3596
3597     if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3598     return ddraw7_EnumSurfaces(&This->IDirectDraw7_iface, flags,
3599             surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3600 }
3601
3602 /*****************************************************************************
3603  * DirectDrawCreateClipper (DDRAW.@)
3604  *
3605  * Creates a new IDirectDrawClipper object.
3606  *
3607  * Params:
3608  *  Clipper: Address to write the interface pointer to
3609  *  UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3610  *            NULL
3611  *
3612  * Returns:
3613  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
3614  *  E_OUTOFMEMORY if allocating the object failed
3615  *
3616  *****************************************************************************/
3617 HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3618 {
3619     struct ddraw_clipper *object;
3620     HRESULT hr;
3621
3622     TRACE("flags %#x, clipper %p, outer_unknown %p.\n",
3623             flags, clipper, outer_unknown);
3624
3625     if (outer_unknown)
3626         return CLASS_E_NOAGGREGATION;
3627
3628     wined3d_mutex_lock();
3629
3630     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3631     if (!object)
3632     {
3633         wined3d_mutex_unlock();
3634         return E_OUTOFMEMORY;
3635     }
3636
3637     hr = ddraw_clipper_init(object);
3638     if (FAILED(hr))
3639     {
3640         WARN("Failed to initialize clipper, hr %#x.\n", hr);
3641         HeapFree(GetProcessHeap(), 0, object);
3642         wined3d_mutex_unlock();
3643         return hr;
3644     }
3645
3646     TRACE("Created clipper %p.\n", object);
3647     *clipper = &object->IDirectDrawClipper_iface;
3648     wined3d_mutex_unlock();
3649
3650     return DD_OK;
3651 }
3652
3653 /*****************************************************************************
3654  * IDirectDraw7::CreateClipper
3655  *
3656  * Creates a DDraw clipper. See DirectDrawCreateClipper for details
3657  *
3658  *****************************************************************************/
3659 static HRESULT WINAPI ddraw7_CreateClipper(IDirectDraw7 *iface, DWORD Flags,
3660         IDirectDrawClipper **Clipper, IUnknown *UnkOuter)
3661 {
3662     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3663             iface, Flags, Clipper, UnkOuter);
3664
3665     return DirectDrawCreateClipper(Flags, Clipper, UnkOuter);
3666 }
3667
3668 static HRESULT WINAPI ddraw4_CreateClipper(IDirectDraw4 *iface, DWORD flags,
3669         IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3670 {
3671     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
3672
3673     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3674             iface, flags, clipper, outer_unknown);
3675
3676     return ddraw7_CreateClipper(&This->IDirectDraw7_iface, flags, clipper, outer_unknown);
3677 }
3678
3679 static HRESULT WINAPI ddraw2_CreateClipper(IDirectDraw2 *iface,
3680         DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3681 {
3682     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
3683
3684     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3685             iface, flags, clipper, outer_unknown);
3686
3687     return ddraw7_CreateClipper(&This->IDirectDraw7_iface, flags, clipper, outer_unknown);
3688 }
3689
3690 static HRESULT WINAPI ddraw1_CreateClipper(IDirectDraw *iface,
3691         DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3692 {
3693     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
3694
3695     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3696             iface, flags, clipper, outer_unknown);
3697
3698     return ddraw7_CreateClipper(&This->IDirectDraw7_iface, flags, clipper, outer_unknown);
3699 }
3700
3701 /*****************************************************************************
3702  * IDirectDraw7::CreatePalette
3703  *
3704  * Creates a new IDirectDrawPalette object
3705  *
3706  * Params:
3707  *  Flags: The flags for the new clipper
3708  *  ColorTable: Color table to assign to the new clipper
3709  *  Palette: Address to write the interface pointer to
3710  *  UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3711  *            NULL
3712  *
3713  * Returns:
3714  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
3715  *  E_OUTOFMEMORY if allocating the object failed
3716  *
3717  *****************************************************************************/
3718 static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
3719         PALETTEENTRY *ColorTable, IDirectDrawPalette **Palette, IUnknown *pUnkOuter)
3720 {
3721     IDirectDrawImpl *This = impl_from_IDirectDraw7(iface);
3722     IDirectDrawPaletteImpl *object;
3723     HRESULT hr;
3724
3725     TRACE("iface %p, flags %#x, color_table %p, palette %p, outer_unknown %p.\n",
3726             iface, Flags, ColorTable, Palette, pUnkOuter);
3727
3728     if (pUnkOuter)
3729         return CLASS_E_NOAGGREGATION;
3730
3731     wined3d_mutex_lock();
3732
3733     /* The refcount test shows that a cooplevel is required for this */
3734     if(!This->cooperative_level)
3735     {
3736         WARN("No cooperative level set, returning DDERR_NOCOOPERATIVELEVELSET\n");
3737         wined3d_mutex_unlock();
3738         return DDERR_NOCOOPERATIVELEVELSET;
3739     }
3740
3741     object = HeapAlloc(GetProcessHeap(), 0, sizeof(IDirectDrawPaletteImpl));
3742     if(!object)
3743     {
3744         ERR("Out of memory when allocating memory for a palette implementation\n");
3745         wined3d_mutex_unlock();
3746         return E_OUTOFMEMORY;
3747     }
3748
3749     hr = ddraw_palette_init(object, This, Flags, ColorTable);
3750     if (FAILED(hr))
3751     {
3752         WARN("Failed to initialize palette, hr %#x.\n", hr);
3753         HeapFree(GetProcessHeap(), 0, object);
3754         wined3d_mutex_unlock();
3755         return hr;
3756     }
3757
3758     TRACE("Created palette %p.\n", object);
3759     *Palette = &object->IDirectDrawPalette_iface;
3760     wined3d_mutex_unlock();
3761
3762     return DD_OK;
3763 }
3764
3765 static HRESULT WINAPI ddraw4_CreatePalette(IDirectDraw4 *iface, DWORD flags, PALETTEENTRY *entries,
3766         IDirectDrawPalette **palette, IUnknown *outer_unknown)
3767 {
3768     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
3769     HRESULT hr;
3770
3771     TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3772             iface, flags, entries, palette, outer_unknown);
3773
3774     hr = ddraw7_CreatePalette(&This->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3775     if (SUCCEEDED(hr) && *palette)
3776     {
3777         IDirectDrawPaletteImpl *impl = impl_from_IDirectDrawPalette(*palette);
3778         IDirectDraw7_Release(&This->IDirectDraw7_iface);
3779         IDirectDraw4_AddRef(iface);
3780         impl->ifaceToRelease = (IUnknown *)iface;
3781     }
3782     return hr;
3783 }
3784
3785 static HRESULT WINAPI ddraw2_CreatePalette(IDirectDraw2 *iface, DWORD flags,
3786         PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3787 {
3788     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
3789     HRESULT hr;
3790
3791     TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3792             iface, flags, entries, palette, outer_unknown);
3793
3794     hr = ddraw7_CreatePalette(&This->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3795     if (SUCCEEDED(hr) && *palette)
3796     {
3797         IDirectDrawPaletteImpl *impl = impl_from_IDirectDrawPalette(*palette);
3798         IDirectDraw7_Release(&This->IDirectDraw7_iface);
3799         impl->ifaceToRelease = NULL;
3800     }
3801
3802     return hr;
3803 }
3804
3805 static HRESULT WINAPI ddraw1_CreatePalette(IDirectDraw *iface, DWORD flags,
3806         PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3807 {
3808     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
3809     HRESULT hr;
3810
3811     TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3812             iface, flags, entries, palette, outer_unknown);
3813
3814     hr = ddraw7_CreatePalette(&This->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3815     if (SUCCEEDED(hr) && *palette)
3816     {
3817         IDirectDrawPaletteImpl *impl = impl_from_IDirectDrawPalette(*palette);
3818         IDirectDraw7_Release(&This->IDirectDraw7_iface);
3819         impl->ifaceToRelease = NULL;
3820     }
3821
3822     return hr;
3823 }
3824
3825 /*****************************************************************************
3826  * IDirectDraw7::DuplicateSurface
3827  *
3828  * Duplicates a surface. The surface memory points to the same memory as
3829  * the original surface, and it's released when the last surface referencing
3830  * it is released. I guess that's beyond Wine's surface management right now
3831  * (Idea: create a new DDraw surface with the same WineD3DSurface. I need a
3832  * test application to implement this)
3833  *
3834  * Params:
3835  *  Src: Address of the source surface
3836  *  Dest: Address to write the new surface pointer to
3837  *
3838  * Returns:
3839  *  See IDirectDraw7::CreateSurface
3840  *
3841  *****************************************************************************/
3842 static HRESULT WINAPI ddraw7_DuplicateSurface(IDirectDraw7 *iface,
3843         IDirectDrawSurface7 *Src, IDirectDrawSurface7 **Dest)
3844 {
3845     IDirectDrawSurfaceImpl *Surf = unsafe_impl_from_IDirectDrawSurface7(Src);
3846
3847     FIXME("iface %p, src %p, dst %p partial stub!\n", iface, Src, Dest);
3848
3849     /* For now, simply create a new, independent surface */
3850     return IDirectDraw7_CreateSurface(iface,
3851                                       &Surf->surface_desc,
3852                                       Dest,
3853                                       NULL);
3854 }
3855
3856 static HRESULT WINAPI ddraw4_DuplicateSurface(IDirectDraw4 *iface, IDirectDrawSurface4 *src,
3857         IDirectDrawSurface4 **dst)
3858 {
3859     IDirectDrawImpl *This = impl_from_IDirectDraw4(iface);
3860     IDirectDrawSurfaceImpl *src_impl = unsafe_impl_from_IDirectDrawSurface4(src);
3861     IDirectDrawSurface7 *dst7;
3862     IDirectDrawSurfaceImpl *dst_impl;
3863     HRESULT hr;
3864
3865     TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3866     hr = ddraw7_DuplicateSurface(&This->IDirectDraw7_iface,
3867             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3868     if (FAILED(hr))
3869     {
3870         *dst = NULL;
3871         return hr;
3872     }
3873     dst_impl = impl_from_IDirectDrawSurface7(dst7);
3874     *dst = &dst_impl->IDirectDrawSurface4_iface;
3875     IDirectDrawSurface4_AddRef(*dst);
3876     IDirectDrawSurface7_Release(dst7);
3877
3878     return hr;
3879 }
3880
3881 static HRESULT WINAPI ddraw2_DuplicateSurface(IDirectDraw2 *iface,
3882         IDirectDrawSurface *src, IDirectDrawSurface **dst)
3883 {
3884     IDirectDrawImpl *This = impl_from_IDirectDraw2(iface);
3885     IDirectDrawSurfaceImpl *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3886     IDirectDrawSurface7 *dst7;
3887     IDirectDrawSurfaceImpl *dst_impl;
3888     HRESULT hr;
3889
3890     TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3891     hr = ddraw7_DuplicateSurface(&This->IDirectDraw7_iface,
3892             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3893     if (FAILED(hr))
3894         return hr;
3895     dst_impl = impl_from_IDirectDrawSurface7(dst7);
3896     *dst = &dst_impl->IDirectDrawSurface_iface;
3897     IDirectDrawSurface_AddRef(*dst);
3898     IDirectDrawSurface7_Release(dst7);
3899
3900     return hr;
3901 }
3902
3903 static HRESULT WINAPI ddraw1_DuplicateSurface(IDirectDraw *iface, IDirectDrawSurface *src,
3904         IDirectDrawSurface **dst)
3905 {
3906     IDirectDrawImpl *This = impl_from_IDirectDraw(iface);
3907     IDirectDrawSurfaceImpl *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3908     IDirectDrawSurface7 *dst7;
3909     IDirectDrawSurfaceImpl *dst_impl;
3910     HRESULT hr;
3911
3912     TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3913     hr = ddraw7_DuplicateSurface(&This->IDirectDraw7_iface,
3914             src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3915     if (FAILED(hr))
3916         return hr;
3917     dst_impl = impl_from_IDirectDrawSurface7(dst7);
3918     *dst = &dst_impl->IDirectDrawSurface_iface;
3919     IDirectDrawSurface_AddRef(*dst);
3920     IDirectDrawSurface7_Release(dst7);
3921
3922     return hr;
3923 }
3924
3925 /*****************************************************************************
3926  * IDirect3D7::EnumDevices
3927  *
3928  * The EnumDevices method for IDirect3D7. It enumerates all supported
3929  * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated.
3930  *
3931  * Params:
3932  *  callback: Function to call for each enumerated device
3933  *  context: Pointer to pass back to the app
3934  *
3935  * Returns:
3936  *  D3D_OK, or the return value of the GetCaps call
3937  *
3938  *****************************************************************************/
3939 static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBACK7 callback, void *context)
3940 {
3941     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
3942     D3DDEVICEDESC7 device_desc7;
3943     D3DDEVICEDESC device_desc1;
3944     HRESULT hr;
3945     size_t i;
3946
3947     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3948
3949     if (!callback)
3950         return DDERR_INVALIDPARAMS;
3951
3952     wined3d_mutex_lock();
3953
3954     hr = IDirect3DImpl_GetCaps(This->wined3d, &device_desc1, &device_desc7);
3955     if (hr != D3D_OK)
3956     {
3957         wined3d_mutex_unlock();
3958         return hr;
3959     }
3960
3961     for (i = 0; i < sizeof(device_list7)/sizeof(device_list7[0]); i++)
3962     {
3963         HRESULT ret;
3964
3965         device_desc7.deviceGUID = *device_list7[i].device_guid;
3966         ret = callback(device_list7[i].interface_name, device_list7[i].device_name, &device_desc7, context);
3967         if (ret != DDENUMRET_OK)
3968         {
3969             TRACE("Application cancelled the enumeration.\n");
3970             wined3d_mutex_unlock();
3971             return D3D_OK;
3972         }
3973     }
3974
3975     TRACE("End of enumeration.\n");
3976
3977     wined3d_mutex_unlock();
3978
3979     return D3D_OK;
3980 }
3981
3982 /*****************************************************************************
3983  * IDirect3D3::EnumDevices
3984  *
3985  * Enumerates all supported Direct3DDevice interfaces. This is the
3986  * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own.
3987  *
3988  * Version 1, 2 and 3
3989  *
3990  * Params:
3991  *  callback: Application-provided routine to call for each enumerated device
3992  *  Context: Pointer to pass to the callback
3993  *
3994  * Returns:
3995  *  D3D_OK on success,
3996  *  The result of IDirect3DImpl_GetCaps if it failed
3997  *
3998  *****************************************************************************/
3999 static HRESULT WINAPI d3d3_EnumDevices(IDirect3D3 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4000 {
4001     static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL";
4002
4003     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4004     D3DDEVICEDESC device_desc1, hal_desc, hel_desc;
4005     D3DDEVICEDESC7 device_desc7;
4006     HRESULT hr;
4007
4008     /* Some games (Motoracer 2 demo) have the bad idea to modify the device
4009      * name string. Let's put the string in a sufficiently sized array in
4010      * writable memory. */
4011     char device_name[50];
4012     strcpy(device_name,"Direct3D HEL");
4013
4014     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4015
4016     if (!callback)
4017         return DDERR_INVALIDPARAMS;
4018
4019     wined3d_mutex_lock();
4020
4021     hr = IDirect3DImpl_GetCaps(This->wined3d, &device_desc1, &device_desc7);
4022     if (hr != D3D_OK)
4023     {
4024         wined3d_mutex_unlock();
4025         return hr;
4026     }
4027
4028     /* Do I have to enumerate the reference id? Note from old d3d7:
4029      * "It seems that enumerating the reference IID on Direct3D 1 games
4030      * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1
4031      *
4032      * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers,
4033      * EnumReference which enables / disables enumerating the reference
4034      * rasterizer. It's a DWORD, 0 means disabled, 2 means enabled. The
4035      * enablerefrast.reg and disablerefrast.reg files in the DirectX 7.0 sdk
4036      * demo directory suggest this.
4037      *
4038      * Some games(GTA 2) seem to use the second enumerated device, so I have
4039      * to enumerate at least 2 devices. So enumerate the reference device to
4040      * have 2 devices.
4041      *
4042      * Other games (Rollcage) tell emulation and hal device apart by certain
4043      * flags. Rollcage expects D3DPTEXTURECAPS_POW2 to be set (yeah, it is a
4044      * limitation flag), and it refuses all devices that have the perspective
4045      * flag set. This way it refuses the emulation device, and HAL devices
4046      * never have POW2 unset in d3d7 on windows. */
4047     if (This->d3dversion != 1)
4048     {
4049         static CHAR reference_description[] = "RGB Direct3D emulation";
4050
4051         TRACE("Enumerating WineD3D D3DDevice interface.\n");
4052         hal_desc = device_desc1;
4053         hel_desc = device_desc1;
4054         /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps. */
4055         hal_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4056                 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4057         hal_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4058                 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4059         /* RGB, RAMP and MMX devices have a HAL dcmColorModel of 0 */
4060         hal_desc.dcmColorModel = 0;
4061
4062         hr = callback((GUID *)&IID_IDirect3DRGBDevice, reference_description,
4063                 device_name, &hal_desc, &hel_desc, context);
4064         if (hr != D3DENUMRET_OK)
4065         {
4066             TRACE("Application cancelled the enumeration.\n");
4067             wined3d_mutex_unlock();
4068             return D3D_OK;
4069         }
4070     }
4071
4072     strcpy(device_name,"Direct3D HAL");
4073
4074     TRACE("Enumerating HAL Direct3D device.\n");
4075     hal_desc = device_desc1;
4076     hel_desc = device_desc1;
4077
4078     /* The hal device does not have the pow2 flag set in hel, but in hal. */
4079     hel_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4080             | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4081     hel_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4082             | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4083     /* HAL devices have a HEL dcmColorModel of 0 */
4084     hel_desc.dcmColorModel = 0;
4085
4086     hr = callback((GUID *)&IID_IDirect3DHALDevice, wined3d_description,
4087             device_name, &hal_desc, &hel_desc, context);
4088     if (hr != D3DENUMRET_OK)
4089     {
4090         TRACE("Application cancelled the enumeration.\n");
4091         wined3d_mutex_unlock();
4092         return D3D_OK;
4093     }
4094
4095     TRACE("End of enumeration.\n");
4096
4097     wined3d_mutex_unlock();
4098
4099     return D3D_OK;
4100 }
4101
4102 static HRESULT WINAPI d3d2_EnumDevices(IDirect3D2 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4103 {
4104     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
4105
4106     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4107
4108     return d3d3_EnumDevices(&This->IDirect3D3_iface, callback, context);
4109 }
4110
4111 static HRESULT WINAPI d3d1_EnumDevices(IDirect3D *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4112 {
4113     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
4114
4115     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4116
4117     return d3d3_EnumDevices(&This->IDirect3D3_iface, callback, context);
4118 }
4119
4120 /*****************************************************************************
4121  * IDirect3D3::CreateLight
4122  *
4123  * Creates an IDirect3DLight interface. This interface is used in
4124  * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced
4125  * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation
4126  * uses the IDirect3DDevice7 interface with D3D7 lights.
4127  *
4128  * Version 1, 2 and 3
4129  *
4130  * Params:
4131  *  light: Address to store the new interface pointer
4132  *  outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4133  *                 Must be NULL
4134  *
4135  * Returns:
4136  *  D3D_OK on success
4137  *  DDERR_OUTOFMEMORY if memory allocation failed
4138  *  CLASS_E_NOAGGREGATION if outer_unknown != NULL
4139  *
4140  *****************************************************************************/
4141 static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light,
4142         IUnknown *outer_unknown)
4143 {
4144     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4145     IDirect3DLightImpl *object;
4146
4147     TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4148
4149     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4150
4151     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4152     if (!object)
4153     {
4154         ERR("Failed to allocate light memory.\n");
4155         return DDERR_OUTOFMEMORY;
4156     }
4157
4158     d3d_light_init(object, This);
4159
4160     TRACE("Created light %p.\n", object);
4161     *light = &object->IDirect3DLight_iface;
4162
4163     return D3D_OK;
4164 }
4165
4166 static HRESULT WINAPI d3d2_CreateLight(IDirect3D2 *iface, IDirect3DLight **light, IUnknown *outer_unknown)
4167 {
4168     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
4169
4170     TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4171
4172     return d3d3_CreateLight(&This->IDirect3D3_iface, light, outer_unknown);
4173 }
4174
4175 static HRESULT WINAPI d3d1_CreateLight(IDirect3D *iface, IDirect3DLight **light, IUnknown *outer_unknown)
4176 {
4177     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
4178
4179     TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4180
4181     return d3d3_CreateLight(&This->IDirect3D3_iface, light, outer_unknown);
4182 }
4183
4184 /*****************************************************************************
4185  * IDirect3D3::CreateMaterial
4186  *
4187  * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3
4188  * and older versions. The IDirect3DMaterial implementation wraps its
4189  * functionality to IDirect3DDevice7::SetMaterial and friends.
4190  *
4191  * Version 1, 2 and 3
4192  *
4193  * Params:
4194  *  material: Address to store the new interface's pointer to
4195  *  outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4196  *                 Must be NULL
4197  *
4198  * Returns:
4199  *  D3D_OK on success
4200  *  DDERR_OUTOFMEMORY if memory allocation failed
4201  *  CLASS_E_NOAGGREGATION if outer_unknown != NULL
4202  *
4203  *****************************************************************************/
4204 static HRESULT WINAPI d3d3_CreateMaterial(IDirect3D3 *iface, IDirect3DMaterial3 **material,
4205         IUnknown *outer_unknown)
4206 {
4207     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4208     IDirect3DMaterialImpl *object;
4209
4210     TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4211
4212     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4213
4214     object = d3d_material_create(This);
4215     if (!object)
4216     {
4217         ERR("Failed to allocate material memory.\n");
4218         return DDERR_OUTOFMEMORY;
4219     }
4220
4221     TRACE("Created material %p.\n", object);
4222     *material = &object->IDirect3DMaterial3_iface;
4223
4224     return D3D_OK;
4225 }
4226
4227 static HRESULT WINAPI d3d2_CreateMaterial(IDirect3D2 *iface, IDirect3DMaterial2 **material,
4228         IUnknown *outer_unknown)
4229 {
4230     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
4231     IDirect3DMaterialImpl *object;
4232
4233     TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4234
4235     object = d3d_material_create(This);
4236     if (!object)
4237     {
4238         ERR("Failed to allocate material memory.\n");
4239         return DDERR_OUTOFMEMORY;
4240     }
4241
4242     TRACE("Created material %p.\n", object);
4243     *material = &object->IDirect3DMaterial2_iface;
4244
4245     return D3D_OK;
4246 }
4247
4248 static HRESULT WINAPI d3d1_CreateMaterial(IDirect3D *iface, IDirect3DMaterial **material,
4249         IUnknown *outer_unknown)
4250 {
4251     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
4252     IDirect3DMaterialImpl *object;
4253
4254     TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4255
4256     object = d3d_material_create(This);
4257     if (!object)
4258     {
4259         ERR("Failed to allocate material memory.\n");
4260         return DDERR_OUTOFMEMORY;
4261     }
4262
4263     TRACE("Created material %p.\n", object);
4264     *material = &object->IDirect3DMaterial_iface;
4265
4266     return D3D_OK;
4267 }
4268
4269 /*****************************************************************************
4270  * IDirect3D3::CreateViewport
4271  *
4272  * Creates an IDirect3DViewport interface. This interface is used
4273  * by Direct3D and earlier versions for Viewport management. In Direct3D7
4274  * it has been replaced by a viewport structure and
4275  * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation
4276  * uses the IDirect3DDevice7 methods for its functionality
4277  *
4278  * Params:
4279  *  Viewport: Address to store the new interface pointer
4280  *  outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4281  *                 Must be NULL
4282  *
4283  * Returns:
4284  *  D3D_OK on success
4285  *  DDERR_OUTOFMEMORY if memory allocation failed
4286  *  CLASS_E_NOAGGREGATION if outer_unknown != NULL
4287  *
4288  *****************************************************************************/
4289 static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3 **viewport,
4290         IUnknown *outer_unknown)
4291 {
4292     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4293     IDirect3DViewportImpl *object;
4294
4295     TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4296
4297     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4298
4299     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4300     if (!object)
4301     {
4302         ERR("Failed to allocate viewport memory.\n");
4303         return DDERR_OUTOFMEMORY;
4304     }
4305
4306     d3d_viewport_init(object, This);
4307
4308     TRACE("Created viewport %p.\n", object);
4309     *viewport = &object->IDirect3DViewport3_iface;
4310
4311     return D3D_OK;
4312 }
4313
4314 static HRESULT WINAPI d3d2_CreateViewport(IDirect3D2 *iface, IDirect3DViewport2 **viewport, IUnknown *outer_unknown)
4315 {
4316     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
4317
4318     TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4319
4320     return d3d3_CreateViewport(&This->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4321             outer_unknown);
4322 }
4323
4324 static HRESULT WINAPI d3d1_CreateViewport(IDirect3D *iface, IDirect3DViewport **viewport, IUnknown *outer_unknown)
4325 {
4326     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
4327
4328     TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4329
4330     return d3d3_CreateViewport(&This->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4331             outer_unknown);
4332 }
4333
4334 /*****************************************************************************
4335  * IDirect3D3::FindDevice
4336  *
4337  * This method finds a device with the requested properties and returns a
4338  * device description
4339  *
4340  * Verion 1, 2 and 3
4341  * Params:
4342  *  fds: Describes the requested device characteristics
4343  *  fdr: Returns the device description
4344  *
4345  * Returns:
4346  *  D3D_OK on success
4347  *  DDERR_INVALIDPARAMS if no device was found
4348  *
4349  *****************************************************************************/
4350 static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4351 {
4352     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4353     D3DDEVICEDESC7 desc7;
4354     D3DDEVICEDESC desc1;
4355     HRESULT hr;
4356
4357     TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4358
4359     if (!fds || !fdr) return DDERR_INVALIDPARAMS;
4360
4361     if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH)
4362             || fdr->dwSize != sizeof(D3DFINDDEVICERESULT))
4363         return DDERR_INVALIDPARAMS;
4364
4365     if ((fds->dwFlags & D3DFDS_COLORMODEL)
4366             && fds->dcmColorModel != D3DCOLOR_RGB)
4367     {
4368         WARN("Trying to request a non-RGB D3D color model. Not supported.\n");
4369         return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
4370     }
4371
4372     if (fds->dwFlags & D3DFDS_GUID)
4373     {
4374         TRACE("Trying to match guid %s.\n", debugstr_guid(&(fds->guid)));
4375         if (!IsEqualGUID(&IID_D3DDEVICE_WineD3D, &fds->guid)
4376                 && !IsEqualGUID(&IID_IDirect3DHALDevice, &fds->guid)
4377                 && !IsEqualGUID(&IID_IDirect3DRGBDevice, &fds->guid))
4378         {
4379             WARN("No match for this GUID.\n");
4380             return DDERR_NOTFOUND;
4381         }
4382     }
4383
4384     /* Get the caps */
4385     hr = IDirect3DImpl_GetCaps(This->wined3d, &desc1, &desc7);
4386     if (hr != D3D_OK) return hr;
4387
4388     /* Now return our own GUID */
4389     fdr->guid = IID_D3DDEVICE_WineD3D;
4390     fdr->ddHwDesc = desc1;
4391     fdr->ddSwDesc = desc1;
4392
4393     TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
4394
4395     return D3D_OK;
4396 }
4397
4398 static HRESULT WINAPI d3d2_FindDevice(IDirect3D2 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4399 {
4400     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
4401
4402     TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4403
4404     return d3d3_FindDevice(&This->IDirect3D3_iface, fds, fdr);
4405 }
4406
4407 static HRESULT WINAPI d3d1_FindDevice(IDirect3D *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4408 {
4409     IDirectDrawImpl *This = impl_from_IDirect3D(iface);
4410
4411     TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4412
4413     return d3d3_FindDevice(&This->IDirect3D3_iface, fds, fdr);
4414 }
4415
4416 /*****************************************************************************
4417  * IDirect3D7::CreateDevice
4418  *
4419  * Creates an IDirect3DDevice7 interface.
4420  *
4421  * Version 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to
4422  * DirectDraw surfaces and are created with
4423  * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to
4424  * create the device object and QueryInterfaces for IDirect3DDevice
4425  *
4426  * Params:
4427  *  refiid: IID of the device to create
4428  *  Surface: Initial rendertarget
4429  *  Device: Address to return the interface pointer
4430  *
4431  * Returns:
4432  *  D3D_OK on success
4433  *  DDERR_OUTOFMEMORY if memory allocation failed
4434  *  DDERR_INVALIDPARAMS if a device exists already
4435  *
4436  *****************************************************************************/
4437 static HRESULT WINAPI d3d7_CreateDevice(IDirect3D7 *iface, REFCLSID riid,
4438         IDirectDrawSurface7 *surface, IDirect3DDevice7 **device)
4439 {
4440     IDirectDrawSurfaceImpl *target = unsafe_impl_from_IDirectDrawSurface7(surface);
4441     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
4442     IDirect3DDeviceImpl *object;
4443     HRESULT hr;
4444
4445     TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
4446
4447     wined3d_mutex_lock();
4448     *device = NULL;
4449
4450     /* Fail device creation if non-opengl surfaces are used. */
4451     if (DefaultSurfaceType != WINED3D_SURFACE_TYPE_OPENGL)
4452     {
4453         ERR("The application wants to create a Direct3D device, but non-opengl surfaces are set in the registry.\n");
4454         ERR("Please set the surface implementation to opengl or autodetection to allow 3D rendering.\n");
4455
4456         /* We only hit this path if a default surface is set in the registry. Incorrect autodetection
4457          * is caught in CreateSurface or QueryInterface. */
4458         wined3d_mutex_unlock();
4459         return DDERR_NO3D;
4460     }
4461
4462     if (This->d3ddevice)
4463     {
4464         FIXME("Only one Direct3D device per DirectDraw object supported.\n");
4465         wined3d_mutex_unlock();
4466         return DDERR_INVALIDPARAMS;
4467     }
4468
4469     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4470     if (!object)
4471     {
4472         ERR("Failed to allocate device memory.\n");
4473         wined3d_mutex_unlock();
4474         return DDERR_OUTOFMEMORY;
4475     }
4476
4477     hr = d3d_device_init(object, This, target);
4478     if (FAILED(hr))
4479     {
4480         WARN("Failed to initialize device, hr %#x.\n", hr);
4481         HeapFree(GetProcessHeap(), 0, object);
4482         wined3d_mutex_unlock();
4483         return hr;
4484     }
4485
4486     TRACE("Created device %p.\n", object);
4487     *device = &object->IDirect3DDevice7_iface;
4488
4489     wined3d_mutex_unlock();
4490
4491     return D3D_OK;
4492 }
4493
4494 static HRESULT WINAPI d3d3_CreateDevice(IDirect3D3 *iface, REFCLSID riid,
4495         IDirectDrawSurface4 *surface, IDirect3DDevice3 **device, IUnknown *outer_unknown)
4496 {
4497     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4498     IDirectDrawSurfaceImpl *surface_impl = unsafe_impl_from_IDirectDrawSurface4(surface);
4499     IDirect3DDevice7 *device7;
4500     IDirect3DDeviceImpl *device_impl;
4501     HRESULT hr;
4502
4503     TRACE("iface %p, riid %s, surface %p, device %p, outer_unknown %p.\n",
4504             iface, debugstr_guid(riid), surface, device, outer_unknown);
4505
4506     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4507
4508     hr = d3d7_CreateDevice(&This->IDirect3D7_iface, riid,
4509             surface_impl ? &surface_impl->IDirectDrawSurface7_iface : NULL, device ? &device7 : NULL);
4510     if (SUCCEEDED(hr))
4511     {
4512         device_impl = impl_from_IDirect3DDevice7(device7);
4513         *device = &device_impl->IDirect3DDevice3_iface;
4514     }
4515
4516     return hr;
4517 }
4518
4519 static HRESULT WINAPI d3d2_CreateDevice(IDirect3D2 *iface, REFCLSID riid,
4520         IDirectDrawSurface *surface, IDirect3DDevice2 **device)
4521 {
4522     IDirectDrawImpl *This = impl_from_IDirect3D2(iface);
4523     IDirectDrawSurfaceImpl *surface_impl = unsafe_impl_from_IDirectDrawSurface(surface);
4524     IDirect3DDevice7 *device7;
4525     IDirect3DDeviceImpl *device_impl;
4526     HRESULT hr;
4527
4528     TRACE("iface %p, riid %s, surface %p, device %p.\n",
4529             iface, debugstr_guid(riid), surface, device);
4530
4531     hr = d3d7_CreateDevice(&This->IDirect3D7_iface, riid,
4532             surface_impl ? &surface_impl->IDirectDrawSurface7_iface : NULL, device ? &device7 : NULL);
4533     if (SUCCEEDED(hr))
4534     {
4535         device_impl = impl_from_IDirect3DDevice7(device7);
4536         *device = &device_impl->IDirect3DDevice2_iface;
4537     }
4538
4539     return hr;
4540 }
4541
4542 /*****************************************************************************
4543  * IDirect3D7::CreateVertexBuffer
4544  *
4545  * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7
4546  * interface.
4547  *
4548  * Version 3 and 7
4549  *
4550  * Params:
4551  *  desc: Requested Vertex buffer properties
4552  *  vertex_buffer: Address to return the interface pointer at
4553  *  flags: Some flags, should be 0
4554  *
4555  * Returns
4556  *  D3D_OK on success
4557  *  DDERR_OUTOFMEMORY if memory allocation failed
4558  *  The return value of IWineD3DDevice::CreateVertexBuffer if this call fails
4559  *  DDERR_INVALIDPARAMS if desc or vertex_buffer are NULL
4560  *
4561  *****************************************************************************/
4562 static HRESULT WINAPI d3d7_CreateVertexBuffer(IDirect3D7 *iface, D3DVERTEXBUFFERDESC *desc,
4563         IDirect3DVertexBuffer7 **vertex_buffer, DWORD flags)
4564 {
4565     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
4566     IDirect3DVertexBufferImpl *object;
4567     HRESULT hr;
4568
4569     TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x.\n",
4570             iface, desc, vertex_buffer, flags);
4571
4572     if (!vertex_buffer || !desc) return DDERR_INVALIDPARAMS;
4573
4574     hr = d3d_vertex_buffer_create(&object, This, desc);
4575     if (hr == D3D_OK)
4576     {
4577         TRACE("Created vertex buffer %p.\n", object);
4578         *vertex_buffer = &object->IDirect3DVertexBuffer7_iface;
4579     }
4580     else
4581         WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4582
4583     return hr;
4584 }
4585
4586 static HRESULT WINAPI d3d3_CreateVertexBuffer(IDirect3D3 *iface, D3DVERTEXBUFFERDESC *desc,
4587         IDirect3DVertexBuffer **vertex_buffer, DWORD flags, IUnknown *outer_unknown)
4588 {
4589     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4590     IDirect3DVertexBufferImpl *object;
4591     HRESULT hr;
4592
4593     TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x, outer_unknown %p.\n",
4594             iface, desc, vertex_buffer, flags, outer_unknown);
4595
4596     if (outer_unknown)
4597         return CLASS_E_NOAGGREGATION;
4598     if (!vertex_buffer || !desc)
4599         return DDERR_INVALIDPARAMS;
4600
4601     hr = d3d_vertex_buffer_create(&object, This, desc);
4602     if (hr == D3D_OK)
4603     {
4604         TRACE("Created vertex buffer %p.\n", object);
4605         *vertex_buffer = &object->IDirect3DVertexBuffer_iface;
4606     }
4607     else
4608         WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4609
4610     return hr;
4611 }
4612
4613 /*****************************************************************************
4614  * IDirect3D7::EnumZBufferFormats
4615  *
4616  * Enumerates all supported Z buffer pixel formats
4617  *
4618  * Version 3 and 7
4619  *
4620  * Params:
4621  *  device_iid:
4622  *  callback: callback to call for each pixel format
4623  *  context: Pointer to pass back to the callback
4624  *
4625  * Returns:
4626  *  D3D_OK on success
4627  *  DDERR_INVALIDPARAMS if callback is NULL
4628  *  For details, see IWineD3DDevice::EnumZBufferFormats
4629  *
4630  *****************************************************************************/
4631 static HRESULT WINAPI d3d7_EnumZBufferFormats(IDirect3D7 *iface, REFCLSID device_iid,
4632         LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4633 {
4634     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
4635     struct wined3d_display_mode mode;
4636     enum wined3d_device_type type;
4637     unsigned int i;
4638     HRESULT hr;
4639
4640     /* Order matters. Specifically, BattleZone II (full version) expects the
4641      * 16-bit depth formats to be listed before the 24 and 32 ones. */
4642     static const enum wined3d_format_id formats[] =
4643     {
4644         WINED3DFMT_S1_UINT_D15_UNORM,
4645         WINED3DFMT_D16_UNORM,
4646         WINED3DFMT_X8D24_UNORM,
4647         WINED3DFMT_S4X4_UINT_D24_UNORM,
4648         WINED3DFMT_D24_UNORM_S8_UINT,
4649         WINED3DFMT_D32_UNORM,
4650     };
4651
4652     TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4653             iface, debugstr_guid(device_iid), callback, context);
4654
4655     if (!callback) return DDERR_INVALIDPARAMS;
4656
4657     if (IsEqualGUID(device_iid, &IID_IDirect3DHALDevice)
4658             || IsEqualGUID(device_iid, &IID_IDirect3DTnLHalDevice)
4659             || IsEqualGUID(device_iid, &IID_D3DDEVICE_WineD3D))
4660     {
4661         TRACE("Asked for HAL device.\n");
4662         type = WINED3D_DEVICE_TYPE_HAL;
4663     }
4664     else if (IsEqualGUID(device_iid, &IID_IDirect3DRGBDevice)
4665             || IsEqualGUID(device_iid, &IID_IDirect3DMMXDevice))
4666     {
4667         TRACE("Asked for SW device.\n");
4668         type = WINED3D_DEVICE_TYPE_SW;
4669     }
4670     else if (IsEqualGUID(device_iid, &IID_IDirect3DRefDevice))
4671     {
4672         TRACE("Asked for REF device.\n");
4673         type = WINED3D_DEVICE_TYPE_REF;
4674     }
4675     else if (IsEqualGUID(device_iid, &IID_IDirect3DNullDevice))
4676     {
4677         TRACE("Asked for NULLREF device.\n");
4678         type = WINED3D_DEVICE_TYPE_NULLREF;
4679     }
4680     else
4681     {
4682         FIXME("Unexpected device GUID %s.\n", debugstr_guid(device_iid));
4683         type = WINED3D_DEVICE_TYPE_HAL;
4684     }
4685
4686     wined3d_mutex_lock();
4687     /* We need an adapter format from somewhere to please wined3d and WGL.
4688      * Use the current display mode. So far all cards offer the same depth
4689      * stencil format for all modes, but if some do not and applications do
4690      * not like that we'll have to find some workaround, like iterating over
4691      * all imaginable formats and collecting all the depth stencil formats we
4692      * can get. */
4693     hr = wined3d_device_get_display_mode(This->wined3d_device, 0, &mode);
4694
4695     for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i)
4696     {
4697         hr = wined3d_check_device_format(This->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4698                 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_SURFACE, formats[i], WINED3D_SURFACE_TYPE_OPENGL);
4699         if (SUCCEEDED(hr))
4700         {
4701             DDPIXELFORMAT pformat;
4702
4703             memset(&pformat, 0, sizeof(pformat));
4704             pformat.dwSize = sizeof(pformat);
4705             PixelFormat_WineD3DtoDD(&pformat, formats[i]);
4706
4707             TRACE("Enumerating wined3d format %#x.\n", formats[i]);
4708             hr = callback(&pformat, context);
4709             if (hr != DDENUMRET_OK)
4710             {
4711                 TRACE("Format enumeration cancelled by application.\n");
4712                 wined3d_mutex_unlock();
4713                 return D3D_OK;
4714             }
4715         }
4716     }
4717
4718     /* Historically some windows drivers used dwZBufferBitDepth=24 for WINED3DFMT_X8D24_UNORM,
4719      * while others used dwZBufferBitDepth=32. In either case the pitch matches a 32 bits per
4720      * pixel format, so we use dwZBufferBitDepth=32. Some games expect 24. Windows Vista and
4721      * newer enumerate both versions, so we do the same(bug 22434) */
4722     hr = wined3d_check_device_format(This->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4723             WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_SURFACE, WINED3DFMT_X8D24_UNORM, WINED3D_SURFACE_TYPE_OPENGL);
4724     if (SUCCEEDED(hr))
4725     {
4726         DDPIXELFORMAT x8d24 =
4727         {
4728             sizeof(x8d24), DDPF_ZBUFFER, 0,
4729             {24}, {0x00000000}, {0x00ffffff}, {0x00000000}
4730         };
4731         TRACE("Enumerating WINED3DFMT_X8D24_UNORM, dwZBufferBitDepth=24 version\n");
4732         callback(&x8d24, context);
4733     }
4734
4735     TRACE("End of enumeration.\n");
4736
4737     wined3d_mutex_unlock();
4738
4739     return D3D_OK;
4740 }
4741
4742 static HRESULT WINAPI d3d3_EnumZBufferFormats(IDirect3D3 *iface, REFCLSID device_iid,
4743         LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4744 {
4745     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4746
4747     TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4748             iface, debugstr_guid(device_iid), callback, context);
4749
4750     return d3d7_EnumZBufferFormats(&This->IDirect3D7_iface, device_iid, callback, context);
4751 }
4752
4753 /*****************************************************************************
4754  * IDirect3D7::EvictManagedTextures
4755  *
4756  * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or
4757  * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory.
4758  *
4759  * Version 3 and 7
4760  *
4761  * Returns:
4762  *  D3D_OK, because it's a stub
4763  *
4764  *****************************************************************************/
4765 static HRESULT WINAPI d3d7_EvictManagedTextures(IDirect3D7 *iface)
4766 {
4767     IDirectDrawImpl *This = impl_from_IDirect3D7(iface);
4768
4769     TRACE("iface %p!\n", iface);
4770
4771     wined3d_mutex_lock();
4772     if (This->d3d_initialized)
4773         wined3d_device_evict_managed_resources(This->wined3d_device);
4774     wined3d_mutex_unlock();
4775
4776     return D3D_OK;
4777 }
4778
4779 static HRESULT WINAPI d3d3_EvictManagedTextures(IDirect3D3 *iface)
4780 {
4781     IDirectDrawImpl *This = impl_from_IDirect3D3(iface);
4782
4783     TRACE("iface %p.\n", iface);
4784
4785     return d3d7_EvictManagedTextures(&This->IDirect3D7_iface);
4786 }
4787
4788 /*****************************************************************************
4789  * IDirect3DImpl_GetCaps
4790  *
4791  * This function retrieves the device caps from wined3d
4792  * and converts it into a D3D7 and D3D - D3D3 structure
4793  * This is a helper function called from various places in ddraw
4794  *
4795  * Params:
4796  *  wined3d: The interface to get the caps from
4797  *  desc1: Old D3D <3 structure to fill (needed)
4798  *  desc7: D3D7 device desc structure to fill (needed)
4799  *
4800  * Returns
4801  *  D3D_OK on success, or the return value of IWineD3D::GetCaps
4802  *
4803  *****************************************************************************/
4804 HRESULT IDirect3DImpl_GetCaps(const struct wined3d *wined3d, D3DDEVICEDESC *desc1, D3DDEVICEDESC7 *desc7)
4805 {
4806     WINED3DCAPS wined3d_caps;
4807     HRESULT hr;
4808
4809     TRACE("wined3d %p, desc1 %p, desc7 %p.\n", wined3d, desc1, desc7);
4810
4811     memset(&wined3d_caps, 0, sizeof(wined3d_caps));
4812
4813     wined3d_mutex_lock();
4814     hr = wined3d_get_device_caps(wined3d, 0, WINED3D_DEVICE_TYPE_HAL, &wined3d_caps);
4815     wined3d_mutex_unlock();
4816     if (FAILED(hr))
4817     {
4818         WARN("Failed to get device caps, hr %#x.\n", hr);
4819         return hr;
4820     }
4821
4822     /* Copy the results into the d3d7 and d3d3 structures */
4823     desc7->dwDevCaps = wined3d_caps.DevCaps;
4824     desc7->dpcLineCaps.dwMiscCaps = wined3d_caps.PrimitiveMiscCaps;
4825     desc7->dpcLineCaps.dwRasterCaps = wined3d_caps.RasterCaps;
4826     desc7->dpcLineCaps.dwZCmpCaps = wined3d_caps.ZCmpCaps;
4827     desc7->dpcLineCaps.dwSrcBlendCaps = wined3d_caps.SrcBlendCaps;
4828     desc7->dpcLineCaps.dwDestBlendCaps = wined3d_caps.DestBlendCaps;
4829     desc7->dpcLineCaps.dwAlphaCmpCaps = wined3d_caps.AlphaCmpCaps;
4830     desc7->dpcLineCaps.dwShadeCaps = wined3d_caps.ShadeCaps;
4831     desc7->dpcLineCaps.dwTextureCaps = wined3d_caps.TextureCaps;
4832     desc7->dpcLineCaps.dwTextureFilterCaps = wined3d_caps.TextureFilterCaps;
4833     desc7->dpcLineCaps.dwTextureAddressCaps = wined3d_caps.TextureAddressCaps;
4834
4835     desc7->dwMaxTextureWidth = wined3d_caps.MaxTextureWidth;
4836     desc7->dwMaxTextureHeight = wined3d_caps.MaxTextureHeight;
4837
4838     desc7->dwMaxTextureRepeat = wined3d_caps.MaxTextureRepeat;
4839     desc7->dwMaxTextureAspectRatio = wined3d_caps.MaxTextureAspectRatio;
4840     desc7->dwMaxAnisotropy = wined3d_caps.MaxAnisotropy;
4841     desc7->dvMaxVertexW = wined3d_caps.MaxVertexW;
4842
4843     desc7->dvGuardBandLeft = wined3d_caps.GuardBandLeft;
4844     desc7->dvGuardBandTop = wined3d_caps.GuardBandTop;
4845     desc7->dvGuardBandRight = wined3d_caps.GuardBandRight;
4846     desc7->dvGuardBandBottom = wined3d_caps.GuardBandBottom;
4847
4848     desc7->dvExtentsAdjust = wined3d_caps.ExtentsAdjust;
4849     desc7->dwStencilCaps = wined3d_caps.StencilCaps;
4850
4851     desc7->dwFVFCaps = wined3d_caps.FVFCaps;
4852     desc7->dwTextureOpCaps = wined3d_caps.TextureOpCaps;
4853
4854     desc7->dwVertexProcessingCaps = wined3d_caps.VertexProcessingCaps;
4855     desc7->dwMaxActiveLights = wined3d_caps.MaxActiveLights;
4856
4857     /* Remove all non-d3d7 caps */
4858     desc7->dwDevCaps &= (
4859         D3DDEVCAPS_FLOATTLVERTEX         | D3DDEVCAPS_SORTINCREASINGZ          | D3DDEVCAPS_SORTDECREASINGZ          |
4860         D3DDEVCAPS_SORTEXACT             | D3DDEVCAPS_EXECUTESYSTEMMEMORY      | D3DDEVCAPS_EXECUTEVIDEOMEMORY       |
4861         D3DDEVCAPS_TLVERTEXSYSTEMMEMORY  | D3DDEVCAPS_TLVERTEXVIDEOMEMORY      | D3DDEVCAPS_TEXTURESYSTEMMEMORY      |
4862         D3DDEVCAPS_TEXTUREVIDEOMEMORY    | D3DDEVCAPS_DRAWPRIMTLVERTEX         | D3DDEVCAPS_CANRENDERAFTERFLIP       |
4863         D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2          | D3DDEVCAPS_SEPARATETEXTUREMEMORIES  |
4864         D3DDEVCAPS_DRAWPRIMITIVES2EX     | D3DDEVCAPS_HWTRANSFORMANDLIGHT      | D3DDEVCAPS_CANBLTSYSTONONLOCAL      |
4865         D3DDEVCAPS_HWRASTERIZATION);
4866
4867     desc7->dwStencilCaps &= (
4868         D3DSTENCILCAPS_KEEP              | D3DSTENCILCAPS_ZERO                 | D3DSTENCILCAPS_REPLACE              |
4869         D3DSTENCILCAPS_INCRSAT           | D3DSTENCILCAPS_DECRSAT              | D3DSTENCILCAPS_INVERT               |
4870         D3DSTENCILCAPS_INCR              | D3DSTENCILCAPS_DECR);
4871
4872     /* FVF caps ?*/
4873
4874     desc7->dwTextureOpCaps &= (
4875         D3DTEXOPCAPS_DISABLE             | D3DTEXOPCAPS_SELECTARG1             | D3DTEXOPCAPS_SELECTARG2             |
4876         D3DTEXOPCAPS_MODULATE            | D3DTEXOPCAPS_MODULATE2X             | D3DTEXOPCAPS_MODULATE4X             |
4877         D3DTEXOPCAPS_ADD                 | D3DTEXOPCAPS_ADDSIGNED              | D3DTEXOPCAPS_ADDSIGNED2X            |
4878         D3DTEXOPCAPS_SUBTRACT            | D3DTEXOPCAPS_ADDSMOOTH              | D3DTEXOPCAPS_BLENDTEXTUREALPHA      |
4879         D3DTEXOPCAPS_BLENDFACTORALPHA    | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM    | D3DTEXOPCAPS_BLENDCURRENTALPHA      |
4880         D3DTEXOPCAPS_PREMODULATE         | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
4881         D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP    |
4882         D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3);
4883
4884     desc7->dwVertexProcessingCaps &= (
4885         D3DVTXPCAPS_TEXGEN               | D3DVTXPCAPS_MATERIALSOURCE7         | D3DVTXPCAPS_VERTEXFOG               |
4886         D3DVTXPCAPS_DIRECTIONALLIGHTS    | D3DVTXPCAPS_POSITIONALLIGHTS        | D3DVTXPCAPS_LOCALVIEWER);
4887
4888     desc7->dpcLineCaps.dwMiscCaps &= (
4889         D3DPMISCCAPS_MASKPLANES          | D3DPMISCCAPS_MASKZ                  | D3DPMISCCAPS_LINEPATTERNREP         |
4890         D3DPMISCCAPS_CONFORMANT          | D3DPMISCCAPS_CULLNONE               | D3DPMISCCAPS_CULLCW                 |
4891         D3DPMISCCAPS_CULLCCW);
4892
4893     desc7->dpcLineCaps.dwRasterCaps &= (
4894         D3DPRASTERCAPS_DITHER            | D3DPRASTERCAPS_ROP2                 | D3DPRASTERCAPS_XOR                  |
4895         D3DPRASTERCAPS_PAT               | D3DPRASTERCAPS_ZTEST                | D3DPRASTERCAPS_SUBPIXEL             |
4896         D3DPRASTERCAPS_SUBPIXELX         | D3DPRASTERCAPS_FOGVERTEX            | D3DPRASTERCAPS_FOGTABLE             |
4897         D3DPRASTERCAPS_STIPPLE           | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
4898         D3DPRASTERCAPS_ANTIALIASEDGES    | D3DPRASTERCAPS_MIPMAPLODBIAS        | D3DPRASTERCAPS_ZBIAS                |
4899         D3DPRASTERCAPS_ZBUFFERLESSHSR    | D3DPRASTERCAPS_FOGRANGE             | D3DPRASTERCAPS_ANISOTROPY           |
4900         D3DPRASTERCAPS_WBUFFER           | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG           |
4901         D3DPRASTERCAPS_ZFOG);
4902
4903     desc7->dpcLineCaps.dwZCmpCaps &= (
4904         D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
4905         D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
4906         D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
4907
4908     desc7->dpcLineCaps.dwSrcBlendCaps &= (
4909         D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
4910         D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
4911         D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
4912         D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
4913         D3DPBLENDCAPS_BOTHINVSRCALPHA);
4914
4915     desc7->dpcLineCaps.dwDestBlendCaps &= (
4916         D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
4917         D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
4918         D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
4919         D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
4920         D3DPBLENDCAPS_BOTHINVSRCALPHA);
4921
4922     desc7->dpcLineCaps.dwAlphaCmpCaps &= (
4923         D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
4924         D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
4925         D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
4926
4927     desc7->dpcLineCaps.dwShadeCaps &= (
4928         D3DPSHADECAPS_COLORFLATMONO      | D3DPSHADECAPS_COLORFLATRGB          | D3DPSHADECAPS_COLORGOURAUDMONO      |
4929         D3DPSHADECAPS_COLORGOURAUDRGB    | D3DPSHADECAPS_COLORPHONGMONO        | D3DPSHADECAPS_COLORPHONGRGB         |
4930         D3DPSHADECAPS_SPECULARFLATMONO   | D3DPSHADECAPS_SPECULARFLATRGB       | D3DPSHADECAPS_SPECULARGOURAUDMONO   |
4931         D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO     | D3DPSHADECAPS_SPECULARPHONGRGB      |
4932         D3DPSHADECAPS_ALPHAFLATBLEND     | D3DPSHADECAPS_ALPHAFLATSTIPPLED     | D3DPSHADECAPS_ALPHAGOURAUDBLEND     |
4933         D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND     | D3DPSHADECAPS_ALPHAPHONGSTIPPLED    |
4934         D3DPSHADECAPS_FOGFLAT            | D3DPSHADECAPS_FOGGOURAUD            | D3DPSHADECAPS_FOGPHONG);
4935
4936     desc7->dpcLineCaps.dwTextureCaps &= (
4937         D3DPTEXTURECAPS_PERSPECTIVE      | D3DPTEXTURECAPS_POW2                | D3DPTEXTURECAPS_ALPHA               |
4938         D3DPTEXTURECAPS_TRANSPARENCY     | D3DPTEXTURECAPS_BORDER              | D3DPTEXTURECAPS_SQUAREONLY          |
4939         D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL  |
4940         D3DPTEXTURECAPS_PROJECTED        | D3DPTEXTURECAPS_CUBEMAP             | D3DPTEXTURECAPS_COLORKEYBLEND);
4941
4942     desc7->dpcLineCaps.dwTextureFilterCaps &= (
4943         D3DPTFILTERCAPS_NEAREST          | D3DPTFILTERCAPS_LINEAR              | D3DPTFILTERCAPS_MIPNEAREST          |
4944         D3DPTFILTERCAPS_MIPLINEAR        | D3DPTFILTERCAPS_LINEARMIPNEAREST    | D3DPTFILTERCAPS_LINEARMIPLINEAR     |
4945         D3DPTFILTERCAPS_MINFPOINT        | D3DPTFILTERCAPS_MINFLINEAR          | D3DPTFILTERCAPS_MINFANISOTROPIC     |
4946         D3DPTFILTERCAPS_MIPFPOINT        | D3DPTFILTERCAPS_MIPFLINEAR          | D3DPTFILTERCAPS_MAGFPOINT           |
4947         D3DPTFILTERCAPS_MAGFLINEAR       | D3DPTFILTERCAPS_MAGFANISOTROPIC     | D3DPTFILTERCAPS_MAGFAFLATCUBIC      |
4948         D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
4949
4950     desc7->dpcLineCaps.dwTextureBlendCaps &= (
4951         D3DPTBLENDCAPS_DECAL             | D3DPTBLENDCAPS_MODULATE             | D3DPTBLENDCAPS_DECALALPHA           |
4952         D3DPTBLENDCAPS_MODULATEALPHA     | D3DPTBLENDCAPS_DECALMASK            | D3DPTBLENDCAPS_MODULATEMASK         |
4953         D3DPTBLENDCAPS_COPY              | D3DPTBLENDCAPS_ADD);
4954
4955     desc7->dpcLineCaps.dwTextureAddressCaps &= (
4956         D3DPTADDRESSCAPS_WRAP            | D3DPTADDRESSCAPS_MIRROR             | D3DPTADDRESSCAPS_CLAMP              |
4957         D3DPTADDRESSCAPS_BORDER          | D3DPTADDRESSCAPS_INDEPENDENTUV);
4958
4959     if (!(desc7->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2))
4960     {
4961         /* DirectX7 always has the np2 flag set, no matter what the card
4962          * supports. Some old games (Rollcage) check the caps incorrectly.
4963          * If wined3d supports nonpow2 textures it also has np2 conditional
4964          * support. */
4965         desc7->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4966     }
4967
4968     /* Fill the missing members, and do some fixup */
4969     desc7->dpcLineCaps.dwSize = sizeof(desc7->dpcLineCaps);
4970     desc7->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD | D3DPTBLENDCAPS_MODULATEMASK |
4971                                             D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_DECAL |
4972                                             D3DPTBLENDCAPS_DECALALPHA | D3DPTBLENDCAPS_DECALMASK |
4973                                             D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_MODULATEALPHA;
4974     desc7->dpcLineCaps.dwStippleWidth = 32;
4975     desc7->dpcLineCaps.dwStippleHeight = 32;
4976     /* Use the same for the TriCaps */
4977     desc7->dpcTriCaps = desc7->dpcLineCaps;
4978
4979     desc7->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
4980     desc7->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24;
4981     desc7->dwMinTextureWidth = 1;
4982     desc7->dwMinTextureHeight = 1;
4983
4984     /* Convert DWORDs safely to WORDs */
4985     if (wined3d_caps.MaxTextureBlendStages > 0xffff) desc7->wMaxTextureBlendStages = 0xffff;
4986     else desc7->wMaxTextureBlendStages = (WORD)wined3d_caps.MaxTextureBlendStages;
4987     if (wined3d_caps.MaxSimultaneousTextures > 0xffff) desc7->wMaxSimultaneousTextures = 0xffff;
4988     else desc7->wMaxSimultaneousTextures = (WORD)wined3d_caps.MaxSimultaneousTextures;
4989
4990     if (wined3d_caps.MaxUserClipPlanes > 0xffff) desc7->wMaxUserClipPlanes = 0xffff;
4991     else desc7->wMaxUserClipPlanes = (WORD)wined3d_caps.MaxUserClipPlanes;
4992     if (wined3d_caps.MaxVertexBlendMatrices > 0xffff) desc7->wMaxVertexBlendMatrices = 0xffff;
4993     else desc7->wMaxVertexBlendMatrices = (WORD)wined3d_caps.MaxVertexBlendMatrices;
4994
4995     desc7->deviceGUID = IID_IDirect3DTnLHalDevice;
4996
4997     desc7->dwReserved1 = 0;
4998     desc7->dwReserved2 = 0;
4999     desc7->dwReserved3 = 0;
5000     desc7->dwReserved4 = 0;
5001
5002     /* Fill the old structure */
5003     memset(desc1, 0, sizeof(*desc1));
5004     desc1->dwSize = sizeof(D3DDEVICEDESC);
5005     desc1->dwFlags = D3DDD_COLORMODEL
5006             | D3DDD_DEVCAPS
5007             | D3DDD_TRANSFORMCAPS
5008             | D3DDD_BCLIPPING
5009             | D3DDD_LIGHTINGCAPS
5010             | D3DDD_LINECAPS
5011             | D3DDD_TRICAPS
5012             | D3DDD_DEVICERENDERBITDEPTH
5013             | D3DDD_DEVICEZBUFFERBITDEPTH
5014             | D3DDD_MAXBUFFERSIZE
5015             | D3DDD_MAXVERTEXCOUNT;
5016
5017     desc1->dcmColorModel = D3DCOLOR_RGB;
5018     desc1->dwDevCaps = desc7->dwDevCaps;
5019     desc1->dtcTransformCaps.dwSize = sizeof(D3DTRANSFORMCAPS);
5020     desc1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
5021     desc1->bClipping = TRUE;
5022     desc1->dlcLightingCaps.dwSize = sizeof(D3DLIGHTINGCAPS);
5023     desc1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL
5024             | D3DLIGHTCAPS_PARALLELPOINT
5025             | D3DLIGHTCAPS_POINT
5026             | D3DLIGHTCAPS_SPOT;
5027
5028     desc1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
5029     desc1->dlcLightingCaps.dwNumLights = desc7->dwMaxActiveLights;
5030
5031     desc1->dpcLineCaps.dwSize = sizeof(D3DPRIMCAPS);
5032     desc1->dpcLineCaps.dwMiscCaps = desc7->dpcLineCaps.dwMiscCaps;
5033     desc1->dpcLineCaps.dwRasterCaps = desc7->dpcLineCaps.dwRasterCaps;
5034     desc1->dpcLineCaps.dwZCmpCaps = desc7->dpcLineCaps.dwZCmpCaps;
5035     desc1->dpcLineCaps.dwSrcBlendCaps = desc7->dpcLineCaps.dwSrcBlendCaps;
5036     desc1->dpcLineCaps.dwDestBlendCaps = desc7->dpcLineCaps.dwDestBlendCaps;
5037     desc1->dpcLineCaps.dwShadeCaps = desc7->dpcLineCaps.dwShadeCaps;
5038     desc1->dpcLineCaps.dwTextureCaps = desc7->dpcLineCaps.dwTextureCaps;
5039     desc1->dpcLineCaps.dwTextureFilterCaps = desc7->dpcLineCaps.dwTextureFilterCaps;
5040     desc1->dpcLineCaps.dwTextureBlendCaps = desc7->dpcLineCaps.dwTextureBlendCaps;
5041     desc1->dpcLineCaps.dwTextureAddressCaps = desc7->dpcLineCaps.dwTextureAddressCaps;
5042     desc1->dpcLineCaps.dwStippleWidth = desc7->dpcLineCaps.dwStippleWidth;
5043     desc1->dpcLineCaps.dwAlphaCmpCaps = desc7->dpcLineCaps.dwAlphaCmpCaps;
5044
5045     desc1->dpcTriCaps.dwSize = sizeof(D3DPRIMCAPS);
5046     desc1->dpcTriCaps.dwMiscCaps = desc7->dpcTriCaps.dwMiscCaps;
5047     desc1->dpcTriCaps.dwRasterCaps = desc7->dpcTriCaps.dwRasterCaps;
5048     desc1->dpcTriCaps.dwZCmpCaps = desc7->dpcTriCaps.dwZCmpCaps;
5049     desc1->dpcTriCaps.dwSrcBlendCaps = desc7->dpcTriCaps.dwSrcBlendCaps;
5050     desc1->dpcTriCaps.dwDestBlendCaps = desc7->dpcTriCaps.dwDestBlendCaps;
5051     desc1->dpcTriCaps.dwShadeCaps = desc7->dpcTriCaps.dwShadeCaps;
5052     desc1->dpcTriCaps.dwTextureCaps = desc7->dpcTriCaps.dwTextureCaps;
5053     desc1->dpcTriCaps.dwTextureFilterCaps = desc7->dpcTriCaps.dwTextureFilterCaps;
5054     desc1->dpcTriCaps.dwTextureBlendCaps = desc7->dpcTriCaps.dwTextureBlendCaps;
5055     desc1->dpcTriCaps.dwTextureAddressCaps = desc7->dpcTriCaps.dwTextureAddressCaps;
5056     desc1->dpcTriCaps.dwStippleWidth = desc7->dpcTriCaps.dwStippleWidth;
5057     desc1->dpcTriCaps.dwAlphaCmpCaps = desc7->dpcTriCaps.dwAlphaCmpCaps;
5058
5059     desc1->dwDeviceRenderBitDepth = desc7->dwDeviceRenderBitDepth;
5060     desc1->dwDeviceZBufferBitDepth = desc7->dwDeviceZBufferBitDepth;
5061     desc1->dwMaxBufferSize = 0;
5062     desc1->dwMaxVertexCount = 65536;
5063     desc1->dwMinTextureWidth  = desc7->dwMinTextureWidth;
5064     desc1->dwMinTextureHeight = desc7->dwMinTextureHeight;
5065     desc1->dwMaxTextureWidth  = desc7->dwMaxTextureWidth;
5066     desc1->dwMaxTextureHeight = desc7->dwMaxTextureHeight;
5067     desc1->dwMinStippleWidth  = 1;
5068     desc1->dwMinStippleHeight = 1;
5069     desc1->dwMaxStippleWidth  = 32;
5070     desc1->dwMaxStippleHeight = 32;
5071     desc1->dwMaxTextureRepeat = desc7->dwMaxTextureRepeat;
5072     desc1->dwMaxTextureAspectRatio = desc7->dwMaxTextureAspectRatio;
5073     desc1->dwMaxAnisotropy = desc7->dwMaxAnisotropy;
5074     desc1->dvGuardBandLeft = desc7->dvGuardBandLeft;
5075     desc1->dvGuardBandRight = desc7->dvGuardBandRight;
5076     desc1->dvGuardBandTop = desc7->dvGuardBandTop;
5077     desc1->dvGuardBandBottom = desc7->dvGuardBandBottom;
5078     desc1->dvExtentsAdjust = desc7->dvExtentsAdjust;
5079     desc1->dwStencilCaps = desc7->dwStencilCaps;
5080     desc1->dwFVFCaps = desc7->dwFVFCaps;
5081     desc1->dwTextureOpCaps = desc7->dwTextureOpCaps;
5082     desc1->wMaxTextureBlendStages = desc7->wMaxTextureBlendStages;
5083     desc1->wMaxSimultaneousTextures = desc7->wMaxSimultaneousTextures;
5084
5085     return DD_OK;
5086 }
5087
5088 /*****************************************************************************
5089  * IDirectDraw7 VTable
5090  *****************************************************************************/
5091 static const struct IDirectDraw7Vtbl ddraw7_vtbl =
5092 {
5093     /* IUnknown */
5094     ddraw7_QueryInterface,
5095     ddraw7_AddRef,
5096     ddraw7_Release,
5097     /* IDirectDraw */
5098     ddraw7_Compact,
5099     ddraw7_CreateClipper,
5100     ddraw7_CreatePalette,
5101     ddraw7_CreateSurface,
5102     ddraw7_DuplicateSurface,
5103     ddraw7_EnumDisplayModes,
5104     ddraw7_EnumSurfaces,
5105     ddraw7_FlipToGDISurface,
5106     ddraw7_GetCaps,
5107     ddraw7_GetDisplayMode,
5108     ddraw7_GetFourCCCodes,
5109     ddraw7_GetGDISurface,
5110     ddraw7_GetMonitorFrequency,
5111     ddraw7_GetScanLine,
5112     ddraw7_GetVerticalBlankStatus,
5113     ddraw7_Initialize,
5114     ddraw7_RestoreDisplayMode,
5115     ddraw7_SetCooperativeLevel,
5116     ddraw7_SetDisplayMode,
5117     ddraw7_WaitForVerticalBlank,
5118     /* IDirectDraw2 */
5119     ddraw7_GetAvailableVidMem,
5120     /* IDirectDraw3 */
5121     ddraw7_GetSurfaceFromDC,
5122     /* IDirectDraw4 */
5123     ddraw7_RestoreAllSurfaces,
5124     ddraw7_TestCooperativeLevel,
5125     ddraw7_GetDeviceIdentifier,
5126     /* IDirectDraw7 */
5127     ddraw7_StartModeTest,
5128     ddraw7_EvaluateMode
5129 };
5130
5131 static const struct IDirectDraw4Vtbl ddraw4_vtbl =
5132 {
5133     /* IUnknown */
5134     ddraw4_QueryInterface,
5135     ddraw4_AddRef,
5136     ddraw4_Release,
5137     /* IDirectDraw */
5138     ddraw4_Compact,
5139     ddraw4_CreateClipper,
5140     ddraw4_CreatePalette,
5141     ddraw4_CreateSurface,
5142     ddraw4_DuplicateSurface,
5143     ddraw4_EnumDisplayModes,
5144     ddraw4_EnumSurfaces,
5145     ddraw4_FlipToGDISurface,
5146     ddraw4_GetCaps,
5147     ddraw4_GetDisplayMode,
5148     ddraw4_GetFourCCCodes,
5149     ddraw4_GetGDISurface,
5150     ddraw4_GetMonitorFrequency,
5151     ddraw4_GetScanLine,
5152     ddraw4_GetVerticalBlankStatus,
5153     ddraw4_Initialize,
5154     ddraw4_RestoreDisplayMode,
5155     ddraw4_SetCooperativeLevel,
5156     ddraw4_SetDisplayMode,
5157     ddraw4_WaitForVerticalBlank,
5158     /* IDirectDraw2 */
5159     ddraw4_GetAvailableVidMem,
5160     /* IDirectDraw3 */
5161     ddraw4_GetSurfaceFromDC,
5162     /* IDirectDraw4 */
5163     ddraw4_RestoreAllSurfaces,
5164     ddraw4_TestCooperativeLevel,
5165     ddraw4_GetDeviceIdentifier,
5166 };
5167
5168 static const struct IDirectDraw2Vtbl ddraw2_vtbl =
5169 {
5170     /* IUnknown */
5171     ddraw2_QueryInterface,
5172     ddraw2_AddRef,
5173     ddraw2_Release,
5174     /* IDirectDraw */
5175     ddraw2_Compact,
5176     ddraw2_CreateClipper,
5177     ddraw2_CreatePalette,
5178     ddraw2_CreateSurface,
5179     ddraw2_DuplicateSurface,
5180     ddraw2_EnumDisplayModes,
5181     ddraw2_EnumSurfaces,
5182     ddraw2_FlipToGDISurface,
5183     ddraw2_GetCaps,
5184     ddraw2_GetDisplayMode,
5185     ddraw2_GetFourCCCodes,
5186     ddraw2_GetGDISurface,
5187     ddraw2_GetMonitorFrequency,
5188     ddraw2_GetScanLine,
5189     ddraw2_GetVerticalBlankStatus,
5190     ddraw2_Initialize,
5191     ddraw2_RestoreDisplayMode,
5192     ddraw2_SetCooperativeLevel,
5193     ddraw2_SetDisplayMode,
5194     ddraw2_WaitForVerticalBlank,
5195     /* IDirectDraw2 */
5196     ddraw2_GetAvailableVidMem,
5197 };
5198
5199 static const struct IDirectDrawVtbl ddraw1_vtbl =
5200 {
5201     /* IUnknown */
5202     ddraw1_QueryInterface,
5203     ddraw1_AddRef,
5204     ddraw1_Release,
5205     /* IDirectDraw */
5206     ddraw1_Compact,
5207     ddraw1_CreateClipper,
5208     ddraw1_CreatePalette,
5209     ddraw1_CreateSurface,
5210     ddraw1_DuplicateSurface,
5211     ddraw1_EnumDisplayModes,
5212     ddraw1_EnumSurfaces,
5213     ddraw1_FlipToGDISurface,
5214     ddraw1_GetCaps,
5215     ddraw1_GetDisplayMode,
5216     ddraw1_GetFourCCCodes,
5217     ddraw1_GetGDISurface,
5218     ddraw1_GetMonitorFrequency,
5219     ddraw1_GetScanLine,
5220     ddraw1_GetVerticalBlankStatus,
5221     ddraw1_Initialize,
5222     ddraw1_RestoreDisplayMode,
5223     ddraw1_SetCooperativeLevel,
5224     ddraw1_SetDisplayMode,
5225     ddraw1_WaitForVerticalBlank,
5226 };
5227
5228 static const struct IDirect3D7Vtbl d3d7_vtbl =
5229 {
5230     /* IUnknown methods */
5231     d3d7_QueryInterface,
5232     d3d7_AddRef,
5233     d3d7_Release,
5234     /* IDirect3D7 methods */
5235     d3d7_EnumDevices,
5236     d3d7_CreateDevice,
5237     d3d7_CreateVertexBuffer,
5238     d3d7_EnumZBufferFormats,
5239     d3d7_EvictManagedTextures
5240 };
5241
5242 static const struct IDirect3D3Vtbl d3d3_vtbl =
5243 {
5244     /* IUnknown methods */
5245     d3d3_QueryInterface,
5246     d3d3_AddRef,
5247     d3d3_Release,
5248     /* IDirect3D3 methods */
5249     d3d3_EnumDevices,
5250     d3d3_CreateLight,
5251     d3d3_CreateMaterial,
5252     d3d3_CreateViewport,
5253     d3d3_FindDevice,
5254     d3d3_CreateDevice,
5255     d3d3_CreateVertexBuffer,
5256     d3d3_EnumZBufferFormats,
5257     d3d3_EvictManagedTextures
5258 };
5259
5260 static const struct IDirect3D2Vtbl d3d2_vtbl =
5261 {
5262     /* IUnknown methods */
5263     d3d2_QueryInterface,
5264     d3d2_AddRef,
5265     d3d2_Release,
5266     /* IDirect3D2 methods */
5267     d3d2_EnumDevices,
5268     d3d2_CreateLight,
5269     d3d2_CreateMaterial,
5270     d3d2_CreateViewport,
5271     d3d2_FindDevice,
5272     d3d2_CreateDevice
5273 };
5274
5275 static const struct IDirect3DVtbl d3d1_vtbl =
5276 {
5277     /* IUnknown methods */
5278     d3d1_QueryInterface,
5279     d3d1_AddRef,
5280     d3d1_Release,
5281     /* IDirect3D methods */
5282     d3d1_Initialize,
5283     d3d1_EnumDevices,
5284     d3d1_CreateLight,
5285     d3d1_CreateMaterial,
5286     d3d1_CreateViewport,
5287     d3d1_FindDevice
5288 };
5289
5290 /*****************************************************************************
5291  * ddraw_find_decl
5292  *
5293  * Finds the WineD3D vertex declaration for a specific fvf, and creates one
5294  * if none was found.
5295  *
5296  * This function is in ddraw.c and the DDraw object space because D3D7
5297  * vertex buffers are created using the IDirect3D interface to the ddraw
5298  * object, so they can be valid across D3D devices(theoretically. The ddraw
5299  * object also owns the wined3d device
5300  *
5301  * Parameters:
5302  *  This: Device
5303  *  fvf: Fvf to find the decl for
5304  *
5305  * Returns:
5306  *  NULL in case of an error, the vertex declaration for the FVF otherwise.
5307  *
5308  *****************************************************************************/
5309 struct wined3d_vertex_declaration *ddraw_find_decl(IDirectDrawImpl *This, DWORD fvf)
5310 {
5311     struct wined3d_vertex_declaration *pDecl = NULL;
5312     HRESULT hr;
5313     int p, low, high; /* deliberately signed */
5314     struct FvfToDecl *convertedDecls = This->decls;
5315
5316     TRACE("Searching for declaration for fvf %08x... ", fvf);
5317
5318     low = 0;
5319     high = This->numConvertedDecls - 1;
5320     while(low <= high) {
5321         p = (low + high) >> 1;
5322         TRACE("%d ", p);
5323         if(convertedDecls[p].fvf == fvf) {
5324             TRACE("found %p\n", convertedDecls[p].decl);
5325             return convertedDecls[p].decl;
5326         } else if(convertedDecls[p].fvf < fvf) {
5327             low = p + 1;
5328         } else {
5329             high = p - 1;
5330         }
5331     }
5332     TRACE("not found. Creating and inserting at position %d.\n", low);
5333
5334     hr = wined3d_vertex_declaration_create_from_fvf(This->wined3d_device,
5335             fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
5336     if (hr != S_OK) return NULL;
5337
5338     if(This->declArraySize == This->numConvertedDecls) {
5339         int grow = max(This->declArraySize / 2, 8);
5340         convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
5341                                      sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
5342         if (!convertedDecls)
5343         {
5344             wined3d_vertex_declaration_decref(pDecl);
5345             return NULL;
5346         }
5347         This->decls = convertedDecls;
5348         This->declArraySize += grow;
5349     }
5350
5351     memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
5352     convertedDecls[low].decl = pDecl;
5353     convertedDecls[low].fvf = fvf;
5354     This->numConvertedDecls++;
5355
5356     TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
5357     return pDecl;
5358 }
5359
5360 static inline struct IDirectDrawImpl *ddraw_from_device_parent(struct wined3d_device_parent *device_parent)
5361 {
5362     return CONTAINING_RECORD(device_parent, struct IDirectDrawImpl, device_parent);
5363 }
5364
5365 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
5366         struct wined3d_device *device)
5367 {
5368     TRACE("device_parent %p, device %p.\n", device_parent, device);
5369 }
5370
5371 /* This is run from device_process_message() in wined3d, we can't take the
5372  * wined3d mutex. */
5373 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
5374 {
5375     struct IDirectDrawImpl *ddraw = ddraw_from_device_parent(device_parent);
5376     MONITORINFO monitor_info;
5377     HMONITOR monitor;
5378     BOOL ret;
5379     RECT *r;
5380
5381     TRACE("device_parent %p.\n", device_parent);
5382
5383     if (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE) || !ddraw->swapchain_window)
5384     {
5385         TRACE("Nothing to resize.\n");
5386         return;
5387     }
5388
5389     monitor = MonitorFromWindow(ddraw->swapchain_window, MONITOR_DEFAULTTOPRIMARY);
5390     monitor_info.cbSize = sizeof(monitor_info);
5391     if (!(ret = GetMonitorInfoW(monitor, &monitor_info)))
5392     {
5393         ERR("Failed to get monitor info.\n");
5394         return;
5395     }
5396
5397     r = &monitor_info.rcMonitor;
5398     TRACE("Resizing window %p to %s.\n", ddraw->swapchain_window, wine_dbgstr_rect(r));
5399
5400     if (!(ret = SetWindowPos(ddraw->swapchain_window, HWND_TOP, r->left, r->top,
5401             r->right - r->left, r->bottom - r->top, SWP_SHOWWINDOW | SWP_NOACTIVATE)))
5402         ERR("Failed to resize window.\n");
5403 }
5404
5405 static HRESULT CDECL device_parent_create_surface(struct wined3d_device_parent *device_parent,
5406         void *container_parent, UINT width, UINT height, enum wined3d_format_id format, DWORD usage,
5407         enum wined3d_pool pool, UINT level, enum wined3d_cubemap_face face, struct wined3d_surface **surface)
5408 {
5409     struct IDirectDrawImpl *ddraw = ddraw_from_device_parent(device_parent);
5410     IDirectDrawSurfaceImpl *surf = NULL;
5411     UINT i = 0;
5412     DDSCAPS2 searchcaps = ddraw->tex_root->surface_desc.ddsCaps;
5413
5414     TRACE("device_parent %p, container_parent %p, width %u, height %u, format %#x, usage %#x,\n"
5415             "\tpool %#x, level %u, face %u, surface %p.\n",
5416             device_parent, container_parent, width, height, format, usage, pool, level, face, surface);
5417
5418     searchcaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
5419     switch (face)
5420     {
5421         case WINED3D_CUBEMAP_FACE_POSITIVE_X:
5422             TRACE("Asked for positive x\n");
5423             if (searchcaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5424             {
5425                 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
5426             }
5427             surf = ddraw->tex_root; break;
5428         case WINED3D_CUBEMAP_FACE_NEGATIVE_X:
5429             TRACE("Asked for negative x\n");
5430             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX; break;
5431         case WINED3D_CUBEMAP_FACE_POSITIVE_Y:
5432             TRACE("Asked for positive y\n");
5433             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY; break;
5434         case WINED3D_CUBEMAP_FACE_NEGATIVE_Y:
5435             TRACE("Asked for negative y\n");
5436             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY; break;
5437         case WINED3D_CUBEMAP_FACE_POSITIVE_Z:
5438             TRACE("Asked for positive z\n");
5439             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ; break;
5440         case WINED3D_CUBEMAP_FACE_NEGATIVE_Z:
5441             TRACE("Asked for negative z\n");
5442             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ; break;
5443         default:
5444             ERR("Unexpected cube face.\n");
5445     }
5446
5447     if (!surf)
5448     {
5449         IDirectDrawSurface7 *attached;
5450         IDirectDrawSurface7_GetAttachedSurface(&ddraw->tex_root->IDirectDrawSurface7_iface, &searchcaps, &attached);
5451         surf = unsafe_impl_from_IDirectDrawSurface7(attached);
5452         IDirectDrawSurface7_Release(attached);
5453     }
5454     if (!surf) ERR("root search surface not found\n");
5455
5456     /* Find the wanted mipmap. There are enough mipmaps in the chain */
5457     while (i < level)
5458     {
5459         IDirectDrawSurface7 *attached;
5460         IDirectDrawSurface7_GetAttachedSurface(&surf->IDirectDrawSurface7_iface, &searchcaps, &attached);
5461         if(!attached) ERR("Surface not found\n");
5462         surf = impl_from_IDirectDrawSurface7(attached);
5463         IDirectDrawSurface7_Release(attached);
5464         ++i;
5465     }
5466
5467     /* Return the surface */
5468     *surface = surf->wined3d_surface;
5469     wined3d_surface_incref(*surface);
5470
5471     TRACE("Returning wineD3DSurface %p, it belongs to surface %p\n", *surface, surf);
5472
5473     return D3D_OK;
5474 }
5475
5476 static void STDMETHODCALLTYPE ddraw_frontbuffer_destroyed(void *parent)
5477 {
5478     struct IDirectDrawImpl *ddraw = parent;
5479     ddraw->wined3d_frontbuffer = NULL;
5480 }
5481
5482 static const struct wined3d_parent_ops ddraw_frontbuffer_parent_ops =
5483 {
5484     ddraw_frontbuffer_destroyed,
5485 };
5486
5487 static HRESULT CDECL device_parent_create_rendertarget(struct wined3d_device_parent *device_parent,
5488         void *container_parent, UINT width, UINT height, enum wined3d_format_id format,
5489         enum wined3d_multisample_type multisample_type, DWORD multisample_quality, BOOL lockable,
5490         struct wined3d_surface **surface)
5491 {
5492     struct IDirectDrawImpl *ddraw = ddraw_from_device_parent(device_parent);
5493     DWORD flags = 0;
5494     HRESULT hr;
5495
5496     TRACE("device_parent %p, container_parent %p, width %u, height %u, format %#x, multisample_type %#x,\n"
5497             "\tmultisample_quality %u, lockable %u, surface %p.\n",
5498             device_parent, container_parent, width, height, format, multisample_type,
5499             multisample_quality, lockable, surface);
5500
5501     if (ddraw->wined3d_frontbuffer)
5502     {
5503         ERR("Frontbuffer already created.\n");
5504         return E_FAIL;
5505     }
5506
5507     if (lockable)
5508         flags |= WINED3D_SURFACE_MAPPABLE;
5509
5510     hr = wined3d_surface_create(ddraw->wined3d_device, width, height, format, 0,
5511             WINED3DUSAGE_RENDERTARGET, WINED3D_POOL_DEFAULT, multisample_type, multisample_quality,
5512             DefaultSurfaceType, flags, ddraw, &ddraw_frontbuffer_parent_ops, surface);
5513     if (SUCCEEDED(hr))
5514         ddraw->wined3d_frontbuffer = *surface;
5515
5516     return hr;
5517 }
5518
5519 static HRESULT CDECL device_parent_create_depth_stencil(struct wined3d_device_parent *device_parent,
5520         UINT width, UINT height, enum wined3d_format_id format, enum wined3d_multisample_type multisample_type,
5521         DWORD multisample_quality, BOOL discard, struct wined3d_surface **surface)
5522 {
5523     ERR("DirectDraw doesn't have and shouldn't try creating implicit depth buffers.\n");
5524     return E_NOTIMPL;
5525 }
5526
5527 static HRESULT CDECL device_parent_create_volume(struct wined3d_device_parent *device_parent,
5528         void *container_parent, UINT width, UINT height, UINT depth, enum wined3d_format_id format,
5529         enum wined3d_pool pool, DWORD usage, struct wined3d_volume **volume)
5530 {
5531     TRACE("device_parent %p, container_parent %p, width %u, height %u, depth %u, "
5532             "format %#x, pool %#x, usage %#x, volume %p.\n",
5533             device_parent, container_parent, width, height, depth,
5534             format, pool, usage, volume);
5535
5536     ERR("Not implemented!\n");
5537
5538     return E_NOTIMPL;
5539 }
5540
5541 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
5542         struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
5543 {
5544     struct IDirectDrawImpl *ddraw = ddraw_from_device_parent(device_parent);
5545     HRESULT hr;
5546
5547     TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
5548
5549     if (ddraw->wined3d_swapchain)
5550     {
5551         ERR("Swapchain already created.\n");
5552         return E_FAIL;
5553     }
5554
5555     hr = wined3d_swapchain_create(ddraw->wined3d_device, desc,
5556             DefaultSurfaceType, NULL, &ddraw_null_wined3d_parent_ops, swapchain);
5557     if (FAILED(hr))
5558         WARN("Failed to create swapchain, hr %#x.\n", hr);
5559
5560     return hr;
5561 }
5562
5563 static const struct wined3d_device_parent_ops ddraw_wined3d_device_parent_ops =
5564 {
5565     device_parent_wined3d_device_created,
5566     device_parent_mode_changed,
5567     device_parent_create_surface,
5568     device_parent_create_rendertarget,
5569     device_parent_create_depth_stencil,
5570     device_parent_create_volume,
5571     device_parent_create_swapchain,
5572 };
5573
5574 HRESULT ddraw_init(IDirectDrawImpl *ddraw, enum wined3d_device_type device_type)
5575 {
5576     HRESULT hr;
5577     HDC hDC;
5578
5579     ddraw->IDirectDraw7_iface.lpVtbl = &ddraw7_vtbl;
5580     ddraw->IDirectDraw_iface.lpVtbl = &ddraw1_vtbl;
5581     ddraw->IDirectDraw2_iface.lpVtbl = &ddraw2_vtbl;
5582     ddraw->IDirectDraw4_iface.lpVtbl = &ddraw4_vtbl;
5583     ddraw->IDirect3D_iface.lpVtbl = &d3d1_vtbl;
5584     ddraw->IDirect3D2_iface.lpVtbl = &d3d2_vtbl;
5585     ddraw->IDirect3D3_iface.lpVtbl = &d3d3_vtbl;
5586     ddraw->IDirect3D7_iface.lpVtbl = &d3d7_vtbl;
5587     ddraw->device_parent.ops = &ddraw_wined3d_device_parent_ops;
5588     ddraw->numIfaces = 1;
5589     ddraw->ref7 = 1;
5590
5591     /* Get the current screen settings. */
5592     hDC = GetDC(0);
5593     ddraw->orig_bpp = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
5594     ReleaseDC(0, hDC);
5595     ddraw->orig_width = GetSystemMetrics(SM_CXSCREEN);
5596     ddraw->orig_height = GetSystemMetrics(SM_CYSCREEN);
5597
5598     ddraw->wined3d = wined3d_create(7, WINED3D_LEGACY_DEPTH_BIAS,
5599             &ddraw->IDirectDraw7_iface);
5600     if (!ddraw->wined3d)
5601     {
5602         WARN("Failed to create a wined3d object.\n");
5603         return E_OUTOFMEMORY;
5604     }
5605
5606     hr = wined3d_device_create(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type,
5607             NULL, 0, 8, &ddraw->device_parent, &ddraw->wined3d_device);
5608     if (FAILED(hr))
5609     {
5610         WARN("Failed to create a wined3d device, hr %#x.\n", hr);
5611         wined3d_decref(ddraw->wined3d);
5612         return hr;
5613     }
5614
5615     list_init(&ddraw->surface_list);
5616
5617     return DD_OK;
5618 }