dlls/ddraw/main.c

   1 /*        DirectDraw Base Functions
   2  *
   3  * Copyright 1997-1999 Marcus Meissner
   4  * Copyright 1998 Lionel Ulmer
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  * Copyright 2006 Stefan Dösinger
   7  * Copyright 2008 Denver Gingerich
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #define DDRAW_INIT_GUID
  28 #include "ddraw_private.h"
  29 #include "rpcproxy.h"
  30
  31 #include "wine/exception.h"
  32 #include "winreg.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  35
  36 static struct list global_ddraw_list = LIST_INIT(global_ddraw_list);
  37
  38 static HINSTANCE instance;
  39
  40 /* value of ForceRefreshRate */
  41 DWORD force_refresh_rate = 0;
  42
  43 /* Structure for converting DirectDrawEnumerateA to DirectDrawEnumerateExA */
  44 struct callback_info
  45 {
  46     LPDDENUMCALLBACKA callback;
  47     void *context;
  48 };
  49
  50 /* Enumeration callback for converting DirectDrawEnumerateA to DirectDrawEnumerateExA */
  51 static BOOL CALLBACK enum_callback(GUID *guid, char *description, char *driver_name,
  52                                       void *context, HMONITOR monitor)
  53 {
  54     const struct callback_info *info = context;
  55
  56     return info->callback(guid, description, driver_name, info->context);
  57 }
  58
  59 static void ddraw_enumerate_secondary_devices(struct wined3d *wined3d, LPDDENUMCALLBACKEXA callback,
  60                                               void *context)
  61 {
  62     struct wined3d_adapter_identifier adapter_id;
  63     struct wined3d_output_desc output_desc;
  64     BOOL cont_enum = TRUE;
  65     HRESULT hr = S_OK;
  66     UINT adapter = 0;
  67
  68     for (adapter = 0; SUCCEEDED(hr) && cont_enum; adapter++)
  69     {
  70         char DriverName[512] = "", DriverDescription[512] = "";
  71
  72         /* The Battle.net System Checker expects the GetAdapterIdentifier DeviceName to match the
  73          * Driver Name, so obtain the DeviceName and GUID from D3D. */
  74         memset(&adapter_id, 0x0, sizeof(adapter_id));
  75         adapter_id.device_name = DriverName;
  76         adapter_id.device_name_size = sizeof(DriverName);
  77         adapter_id.description = DriverDescription;
  78         adapter_id.description_size = sizeof(DriverDescription);
  79         wined3d_mutex_lock();
  80         if (SUCCEEDED(hr = wined3d_get_adapter_identifier(wined3d, adapter, 0x0, &adapter_id)))
  81             hr = wined3d_get_output_desc(wined3d, adapter, &output_desc);
  82         wined3d_mutex_unlock();
  83         if (SUCCEEDED(hr))
  84         {
  85             TRACE("Interface %d: %s\n", adapter, wine_dbgstr_guid(&adapter_id.device_identifier));
  86             cont_enum = callback(&adapter_id.device_identifier, adapter_id.description,
  87                     adapter_id.device_name, context, output_desc.monitor);
  88         }
  89     }
  90 }
  91
  92 /* Handle table functions */
  93 BOOL ddraw_handle_table_init(struct ddraw_handle_table *t, UINT initial_size)
  94 {
  95     t->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(*t->entries));
  96     if (!t->entries)
  97     {
  98         ERR("Failed to allocate handle table memory.\n");
  99         return FALSE;
 100     }
 101     t->free_entries = NULL;
 102     t->table_size = initial_size;
 103     t->entry_count = 0;
 104
 105     return TRUE;
 106 }
 107
 108 void ddraw_handle_table_destroy(struct ddraw_handle_table *t)
 109 {
 110     HeapFree(GetProcessHeap(), 0, t->entries);
 111     memset(t, 0, sizeof(*t));
 112 }
 113
 114 DWORD ddraw_allocate_handle(struct ddraw_handle_table *t, void *object, enum ddraw_handle_type type)
 115 {
 116     struct ddraw_handle_entry *entry;
 117
 118     if (t->free_entries)
 119     {
 120         DWORD idx = t->free_entries - t->entries;
 121         /* Use a free handle */
 122         entry = t->free_entries;
 123         if (entry->type != DDRAW_HANDLE_FREE)
 124         {
 125             ERR("Handle %#x (%p) is in the free list, but has type %#x.\n", idx, entry->object, entry->type);
 126             return DDRAW_INVALID_HANDLE;
 127         }
 128         t->free_entries = entry->object;
 129         entry->object = object;
 130         entry->type = type;
 131
 132         return idx;
 133     }
 134
 135     if (!(t->entry_count < t->table_size))
 136     {
 137         /* Grow the table */
 138         UINT new_size = t->table_size + (t->table_size >> 1);
 139         struct ddraw_handle_entry *new_entries = HeapReAlloc(GetProcessHeap(),
 140                 0, t->entries, new_size * sizeof(*t->entries));
 141         if (!new_entries)
 142         {
 143             ERR("Failed to grow the handle table.\n");
 144             return DDRAW_INVALID_HANDLE;
 145         }
 146         t->entries = new_entries;
 147         t->table_size = new_size;
 148     }
 149
 150     entry = &t->entries[t->entry_count];
 151     entry->object = object;
 152     entry->type = type;
 153
 154     return t->entry_count++;
 155 }
 156
 157 void *ddraw_free_handle(struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type)
 158 {
 159     struct ddraw_handle_entry *entry;
 160     void *object;
 161
 162     if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
 163     {
 164         WARN("Invalid handle %#x passed.\n", handle);
 165         return NULL;
 166     }
 167
 168     entry = &t->entries[handle];
 169     if (entry->type != type)
 170     {
 171         WARN("Handle %#x (%p) is not of type %#x.\n", handle, entry->object, type);
 172         return NULL;
 173     }
 174
 175     object = entry->object;
 176     entry->object = t->free_entries;
 177     entry->type = DDRAW_HANDLE_FREE;
 178     t->free_entries = entry;
 179
 180     return object;
 181 }
 182
 183 void *ddraw_get_object(struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type)
 184 {
 185     struct ddraw_handle_entry *entry;
 186
 187     if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
 188     {
 189         WARN("Invalid handle %#x passed.\n", handle);
 190         return NULL;
 191     }
 192
 193     entry = &t->entries[handle];
 194     if (entry->type != type)
 195     {
 196         WARN("Handle %#x (%p) is not of type %#x.\n", handle, entry->object, type);
 197         return NULL;
 198     }
 199
 200     return entry->object;
 201 }
 202
 203 /***********************************************************************
 204  *
 205  * Helper function for DirectDrawCreate and friends
 206  * Creates a new DDraw interface with the given REFIID
 207  *
 208  * Interfaces that can be created:
 209  *  IDirectDraw, IDirectDraw2, IDirectDraw4, IDirectDraw7
 210  *  IDirect3D, IDirect3D2, IDirect3D3, IDirect3D7. (Does Windows return
 211  *  IDirect3D interfaces?)
 212  *
 213  * Arguments:
 214  *  guid: ID of the requested driver, NULL for the default driver.
 215  *        The GUID can be queried with DirectDrawEnumerate(Ex)A/W
 216  *  DD: Used to return the pointer to the created object
 217  *  UnkOuter: For aggregation, which is unsupported. Must be NULL
 218  *  iid: requested version ID.
 219  *
 220  * Returns:
 221  *  DD_OK if the Interface was created successfully
 222  *  CLASS_E_NOAGGREGATION if UnkOuter is not NULL
 223  *  E_OUTOFMEMORY if some allocation failed
 224  *
 225  ***********************************************************************/
 226 static HRESULT
 227 DDRAW_Create(const GUID *guid,
 228              void **DD,
 229              IUnknown *UnkOuter,
 230              REFIID iid)
 231 {
 232     enum wined3d_device_type device_type;
 233     struct ddraw *ddraw;
 234     HRESULT hr;
 235     DWORD flags = 0;
 236
 237     TRACE("driver_guid %s, ddraw %p, outer_unknown %p, interface_iid %s.\n",
 238             debugstr_guid(guid), DD, UnkOuter, debugstr_guid(iid));
 239
 240     *DD = NULL;
 241
 242     if (guid == (GUID *) DDCREATE_EMULATIONONLY)
 243     {
 244         /* Use the reference device id. This doesn't actually change anything,
 245          * WineD3D always uses OpenGL for D3D rendering. One could make it request
 246          * indirect rendering
 247          */
 248         device_type = WINED3D_DEVICE_TYPE_REF;
 249     }
 250     else if(guid == (GUID *) DDCREATE_HARDWAREONLY)
 251     {
 252         device_type = WINED3D_DEVICE_TYPE_HAL;
 253     }
 254     else
 255     {
 256         device_type = 0;
 257     }
 258
 259     /* DDraw doesn't support aggregation, according to msdn */
 260     if (UnkOuter != NULL)
 261         return CLASS_E_NOAGGREGATION;
 262
 263     if (!IsEqualGUID(iid, &IID_IDirectDraw7))
 264         flags = WINED3D_LEGACY_FFP_LIGHTING;
 265
 266     /* DirectDraw creation comes here */
 267     ddraw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw));
 268     if (!ddraw)
 269     {
 270         ERR("Out of memory when creating DirectDraw\n");
 271         return E_OUTOFMEMORY;
 272     }
 273
 274     hr = ddraw_init(ddraw, flags, device_type);
 275     if (FAILED(hr))
 276     {
 277         WARN("Failed to initialize ddraw object, hr %#x.\n", hr);
 278         HeapFree(GetProcessHeap(), 0, ddraw);
 279         return hr;
 280     }
 281
 282     hr = IDirectDraw7_QueryInterface(&ddraw->IDirectDraw7_iface, iid, DD);
 283     IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
 284     if (SUCCEEDED(hr))
 285         list_add_head(&global_ddraw_list, &ddraw->ddraw_list_entry);
 286     else
 287         WARN("Failed to query interface %s from ddraw object %p.\n", debugstr_guid(iid), ddraw);
 288
 289     return hr;
 290 }
 291
 292 /***********************************************************************
 293  * DirectDrawCreate (DDRAW.@)
 294  *
 295  * Creates legacy DirectDraw Interfaces. Can't create IDirectDraw7
 296  * interfaces in theory
 297  *
 298  * Arguments, return values: See DDRAW_Create
 299  *
 300  ***********************************************************************/
 301 HRESULT WINAPI DECLSPEC_HOTPATCH DirectDrawCreate(GUID *driver_guid, IDirectDraw **ddraw, IUnknown *outer)
 302 {
 303     HRESULT hr;
 304
 305     TRACE("driver_guid %s, ddraw %p, outer %p.\n",
 306             debugstr_guid(driver_guid), ddraw, outer);
 307
 308     wined3d_mutex_lock();
 309     hr = DDRAW_Create(driver_guid, (void **)ddraw, outer, &IID_IDirectDraw);
 310     wined3d_mutex_unlock();
 311
 312     if (SUCCEEDED(hr))
 313     {
 314         if (FAILED(hr = IDirectDraw_Initialize(*ddraw, driver_guid)))
 315             IDirectDraw_Release(*ddraw);
 316     }
 317
 318     return hr;
 319 }
 320
 321 /***********************************************************************
 322  * DirectDrawCreateEx (DDRAW.@)
 323  *
 324  * Only creates new IDirectDraw7 interfaces, supposed to fail if legacy
 325  * interfaces are requested.
 326  *
 327  * Arguments, return values: See DDRAW_Create
 328  *
 329  ***********************************************************************/
 330 HRESULT WINAPI DECLSPEC_HOTPATCH DirectDrawCreateEx(GUID *driver_guid,
 331         void **ddraw, REFIID interface_iid, IUnknown *outer)
 332 {
 333     HRESULT hr;
 334
 335     TRACE("driver_guid %s, ddraw %p, interface_iid %s, outer %p.\n",
 336             debugstr_guid(driver_guid), ddraw, debugstr_guid(interface_iid), outer);
 337
 338     if (!IsEqualGUID(interface_iid, &IID_IDirectDraw7))
 339         return DDERR_INVALIDPARAMS;
 340
 341     wined3d_mutex_lock();
 342     hr = DDRAW_Create(driver_guid, ddraw, outer, interface_iid);
 343     wined3d_mutex_unlock();
 344
 345     if (SUCCEEDED(hr))
 346     {
 347         IDirectDraw7 *ddraw7 = *(IDirectDraw7 **)ddraw;
 348         hr = IDirectDraw7_Initialize(ddraw7, driver_guid);
 349         if (FAILED(hr))
 350             IDirectDraw7_Release(ddraw7);
 351     }
 352
 353     return hr;
 354 }
 355
 356 /***********************************************************************
 357  * DirectDrawEnumerateA (DDRAW.@)
 358  *
 359  * Enumerates legacy ddraw drivers, ascii version. We only have one
 360  * driver, which relays to WineD3D. If we were sufficiently cool,
 361  * we could offer various interfaces, which use a different default surface
 362  * implementation, but I think it's better to offer this choice in
 363  * winecfg, because some apps use the default driver, so we would need
 364  * a winecfg option anyway, and there shouldn't be 2 ways to set one setting
 365  *
 366  * Arguments:
 367  *  Callback: Callback function from the app
 368  *  Context: Argument to the call back.
 369  *
 370  * Returns:
 371  *  DD_OK on success
 372  *  E_INVALIDARG if the Callback caused a page fault
 373  *
 374  *
 375  ***********************************************************************/
 376 HRESULT WINAPI DirectDrawEnumerateA(LPDDENUMCALLBACKA callback, void *context)
 377 {
 378     struct callback_info info;
 379
 380     TRACE("callback %p, context %p.\n", callback, context);
 381
 382     info.callback = callback;
 383     info.context = context;
 384     return DirectDrawEnumerateExA(enum_callback, &info, 0x0);
 385 }
 386
 387 /***********************************************************************
 388  * DirectDrawEnumerateExA (DDRAW.@)
 389  *
 390  * Enumerates DirectDraw7 drivers, ascii version. See
 391  * the comments above DirectDrawEnumerateA for more details.
 392  *
 393  * The Flag member is not supported right now.
 394  *
 395  ***********************************************************************/
 396 HRESULT WINAPI DirectDrawEnumerateExA(LPDDENUMCALLBACKEXA callback, void *context, DWORD flags)
 397 {
 398     struct wined3d *wined3d;
 399
 400     TRACE("callback %p, context %p, flags %#x.\n", callback, context, flags);
 401
 402     if (flags & ~(DDENUM_ATTACHEDSECONDARYDEVICES |
 403                   DDENUM_DETACHEDSECONDARYDEVICES |
 404                   DDENUM_NONDISPLAYDEVICES))
 405         return DDERR_INVALIDPARAMS;
 406
 407     if (flags & ~DDENUM_ATTACHEDSECONDARYDEVICES)
 408         FIXME("flags 0x%08x not handled\n", flags & ~DDENUM_ATTACHEDSECONDARYDEVICES);
 409
 410     TRACE("Enumerating ddraw interfaces\n");
 411     if (!(wined3d = wined3d_create(DDRAW_WINED3D_FLAGS)))
 412     {
 413         if (!(wined3d = wined3d_create(DDRAW_WINED3D_FLAGS | WINED3D_NO3D)))
 414         {
 415             WARN("Failed to create a wined3d object.\n");
 416             return E_FAIL;
 417         }
 418
 419         WARN("Created a wined3d object without 3D support.\n");
 420     }
 421
 422     __TRY
 423     {
 424         /* QuickTime expects the description "DirectDraw HAL" */
 425         static CHAR driver_desc[] = "DirectDraw HAL",
 426         driver_name[] = "display";
 427         BOOL cont_enum;
 428
 429         TRACE("Default interface: DirectDraw HAL\n");
 430         cont_enum = callback(NULL, driver_desc, driver_name, context, 0);
 431
 432         /* The Battle.net System Checker expects both a NULL device and a GUID-based device */
 433         if (cont_enum && (flags & DDENUM_ATTACHEDSECONDARYDEVICES))
 434             ddraw_enumerate_secondary_devices(wined3d, callback, context);
 435     }
 436     __EXCEPT_PAGE_FAULT
 437     {
 438         wined3d_decref(wined3d);
 439         return DDERR_INVALIDPARAMS;
 440     }
 441     __ENDTRY;
 442
 443     wined3d_decref(wined3d);
 444     TRACE("End of enumeration\n");
 445     return DD_OK;
 446 }
 447
 448 /***********************************************************************
 449  * DirectDrawEnumerateW (DDRAW.@)
 450  *
 451  * Enumerates legacy drivers, unicode version.
 452  * This function is not implemented on Windows.
 453  *
 454  ***********************************************************************/
 455 HRESULT WINAPI DirectDrawEnumerateW(LPDDENUMCALLBACKW callback, void *context)
 456 {
 457     TRACE("callback %p, context %p.\n", callback, context);
 458
 459     if (!callback)
 460         return DDERR_INVALIDPARAMS;
 461     else
 462         return DDERR_UNSUPPORTED;
 463 }
 464
 465 /***********************************************************************
 466  * DirectDrawEnumerateExW (DDRAW.@)
 467  *
 468  * Enumerates DirectDraw7 drivers, unicode version.
 469  * This function is not implemented on Windows.
 470  *
 471  ***********************************************************************/
 472 HRESULT WINAPI DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW callback, void *context, DWORD flags)
 473 {
 474     TRACE("callback %p, context %p, flags %#x.\n", callback, context, flags);
 475
 476     return DDERR_UNSUPPORTED;
 477 }
 478
 479 /***********************************************************************
 480  * Classfactory implementation.
 481  ***********************************************************************/
 482
 483 /***********************************************************************
 484  * CF_CreateDirectDraw
 485  *
 486  * DDraw creation function for the class factory
 487  *
 488  * Params:
 489  *  UnkOuter: Set to NULL
 490  *  iid: ID of the wanted interface
 491  *  obj: Address to pass the interface pointer back
 492  *
 493  * Returns
 494  *  DD_OK / DDERR*, see DDRAW_Create
 495  *
 496  ***********************************************************************/
 497 static HRESULT
 498 CF_CreateDirectDraw(IUnknown* UnkOuter, REFIID iid,
 499                     void **obj)
 500 {
 501     HRESULT hr;
 502
 503     TRACE("outer_unknown %p, riid %s, object %p.\n", UnkOuter, debugstr_guid(iid), obj);
 504
 505     wined3d_mutex_lock();
 506     hr = DDRAW_Create(NULL, obj, UnkOuter, iid);
 507     wined3d_mutex_unlock();
 508
 509     return hr;
 510 }
 511
 512 /***********************************************************************
 513  * CF_CreateDirectDraw
 514  *
 515  * Clipper creation function for the class factory
 516  *
 517  * Params:
 518  *  UnkOuter: Set to NULL
 519  *  iid: ID of the wanted interface
 520  *  obj: Address to pass the interface pointer back
 521  *
 522  * Returns
 523  *  DD_OK / DDERR*, see DDRAW_Create
 524  *
 525  ***********************************************************************/
 526 static HRESULT
 527 CF_CreateDirectDrawClipper(IUnknown* UnkOuter, REFIID riid,
 528                               void **obj)
 529 {
 530     HRESULT hr;
 531     IDirectDrawClipper *Clip;
 532
 533     TRACE("outer_unknown %p, riid %s, object %p.\n", UnkOuter, debugstr_guid(riid), obj);
 534
 535     wined3d_mutex_lock();
 536     hr = DirectDrawCreateClipper(0, &Clip, UnkOuter);
 537     if (hr != DD_OK)
 538     {
 539         wined3d_mutex_unlock();
 540         return hr;
 541     }
 542
 543     hr = IDirectDrawClipper_QueryInterface(Clip, riid, obj);
 544     IDirectDrawClipper_Release(Clip);
 545
 546     wined3d_mutex_unlock();
 547
 548     return hr;
 549 }
 550
 551 static const struct object_creation_info object_creation[] =
 552 {
 553     { &CLSID_DirectDraw,        CF_CreateDirectDraw },
 554     { &CLSID_DirectDraw7,       CF_CreateDirectDraw },
 555     { &CLSID_DirectDrawClipper, CF_CreateDirectDrawClipper }
 556 };
 557
 558 struct ddraw_class_factory
 559 {
 560     IClassFactory IClassFactory_iface;
 561
 562     LONG ref;
 563     HRESULT (*pfnCreateInstance)(IUnknown *outer, REFIID iid, void **out);
 564 };
 565
 566 static inline struct ddraw_class_factory *impl_from_IClassFactory(IClassFactory *iface)
 567 {
 568     return CONTAINING_RECORD(iface, struct ddraw_class_factory, IClassFactory_iface);
 569 }
 570
 571 /*******************************************************************************
 572  * IDirectDrawClassFactory::QueryInterface
 573  *
 574  * QueryInterface for the class factory
 575  *
 576  * PARAMS
 577  *    riid   Reference to identifier of queried interface
 578  *    ppv    Address to return the interface pointer at
 579  *
 580  * RETURNS
 581  *    Success: S_OK
 582  *    Failure: E_NOINTERFACE
 583  *
 584  *******************************************************************************/
 585 static HRESULT WINAPI ddraw_class_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **out)
 586 {
 587     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 588
 589     if (IsEqualGUID(riid, &IID_IUnknown)
 590         || IsEqualGUID(riid, &IID_IClassFactory))
 591     {
 592         IClassFactory_AddRef(iface);
 593         *out = iface;
 594         return S_OK;
 595     }
 596
 597     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 598
 599     return E_NOINTERFACE;
 600 }
 601
 602 /*******************************************************************************
 603  * IDirectDrawClassFactory::AddRef
 604  *
 605  * AddRef for the class factory
 606  *
 607  * RETURNS
 608  *  The new refcount
 609  *
 610  *******************************************************************************/
 611 static ULONG WINAPI ddraw_class_factory_AddRef(IClassFactory *iface)
 612 {
 613     struct ddraw_class_factory *factory = impl_from_IClassFactory(iface);
 614     ULONG ref = InterlockedIncrement(&factory->ref);
 615
 616     TRACE("%p increasing refcount to %u.\n", factory, ref);
 617
 618     return ref;
 619 }
 620
 621 /*******************************************************************************
 622  * IDirectDrawClassFactory::Release
 623  *
 624  * Release for the class factory. If the refcount falls to 0, the object
 625  * is destroyed
 626  *
 627  * RETURNS
 628  *  The new refcount
 629  *
 630  *******************************************************************************/
 631 static ULONG WINAPI ddraw_class_factory_Release(IClassFactory *iface)
 632 {
 633     struct ddraw_class_factory *factory = impl_from_IClassFactory(iface);
 634     ULONG ref = InterlockedDecrement(&factory->ref);
 635
 636     TRACE("%p decreasing refcount to %u.\n", factory, ref);
 637
 638     if (!ref)
 639         HeapFree(GetProcessHeap(), 0, factory);
 640
 641     return ref;
 642 }
 643
 644
 645 /*******************************************************************************
 646  * IDirectDrawClassFactory::CreateInstance
 647  *
 648  * What is this? Seems to create DirectDraw objects...
 649  *
 650  * Params
 651  *  The usual things???
 652  *
 653  * RETURNS
 654  *  ???
 655  *
 656  *******************************************************************************/
 657 static HRESULT WINAPI ddraw_class_factory_CreateInstance(IClassFactory *iface,
 658         IUnknown *outer_unknown, REFIID riid, void **out)
 659 {
 660     struct ddraw_class_factory *factory = impl_from_IClassFactory(iface);
 661
 662     TRACE("iface %p, outer_unknown %p, riid %s, out %p.\n",
 663             iface, outer_unknown, debugstr_guid(riid), out);
 664
 665     return factory->pfnCreateInstance(outer_unknown, riid, out);
 666 }
 667
 668 /*******************************************************************************
 669  * IDirectDrawClassFactory::LockServer
 670  *
 671  * What is this?
 672  *
 673  * Params
 674  *  ???
 675  *
 676  * RETURNS
 677  *  S_OK, because it's a stub
 678  *
 679  *******************************************************************************/
 680 static HRESULT WINAPI ddraw_class_factory_LockServer(IClassFactory *iface, BOOL dolock)
 681 {
 682     FIXME("iface %p, dolock %#x stub!\n", iface, dolock);
 683
 684     return S_OK;
 685 }
 686
 687 /*******************************************************************************
 688  * The class factory VTable
 689  *******************************************************************************/
 690 static const IClassFactoryVtbl IClassFactory_Vtbl =
 691 {
 692     ddraw_class_factory_QueryInterface,
 693     ddraw_class_factory_AddRef,
 694     ddraw_class_factory_Release,
 695     ddraw_class_factory_CreateInstance,
 696     ddraw_class_factory_LockServer
 697 };
 698
 699 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **out)
 700 {
 701     struct ddraw_class_factory *factory;
 702     unsigned int i;
 703
 704     TRACE("rclsid %s, riid %s, out %p.\n",
 705             debugstr_guid(rclsid), debugstr_guid(riid), out);
 706
 707     if (!IsEqualGUID(&IID_IClassFactory, riid)
 708             && !IsEqualGUID(&IID_IUnknown, riid))
 709         return E_NOINTERFACE;
 710
 711     for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
 712     {
 713         if (IsEqualGUID(object_creation[i].clsid, rclsid))
 714             break;
 715     }
 716
 717     if (i == sizeof(object_creation)/sizeof(object_creation[0]))
 718     {
 719         FIXME("%s: no class found.\n", debugstr_guid(rclsid));
 720         return CLASS_E_CLASSNOTAVAILABLE;
 721     }
 722
 723     factory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*factory));
 724     if (factory == NULL) return E_OUTOFMEMORY;
 725
 726     factory->IClassFactory_iface.lpVtbl = &IClassFactory_Vtbl;
 727     factory->ref = 1;
 728
 729     factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
 730
 731     *out = factory;
 732     return S_OK;
 733 }
 734
 735
 736 /*******************************************************************************
 737  * DllCanUnloadNow [DDRAW.@]  Determines whether the DLL is in use.
 738  *
 739  * RETURNS
 740  *    Success: S_OK
 741  *    Failure: S_FALSE
 742  */
 743 HRESULT WINAPI DllCanUnloadNow(void)
 744 {
 745     TRACE("\n");
 746
 747     return S_FALSE;
 748 }
 749
 750
 751 /***********************************************************************
 752  *              DllRegisterServer (DDRAW.@)
 753  */
 754 HRESULT WINAPI DllRegisterServer(void)
 755 {
 756     return __wine_register_resources( instance );
 757 }
 758
 759 /***********************************************************************
 760  *              DllUnregisterServer (DDRAW.@)
 761  */
 762 HRESULT WINAPI DllUnregisterServer(void)
 763 {
 764     return __wine_unregister_resources( instance );
 765 }
 766
 767 /*******************************************************************************
 768  * DestroyCallback
 769  *
 770  * Callback function for the EnumSurfaces call in DllMain.
 771  * Dumps some surface info and releases the surface
 772  *
 773  * Params:
 774  *  surf: The enumerated surface
 775  *  desc: it's description
 776  *  context: Pointer to the ddraw impl
 777  *
 778  * Returns:
 779  *  DDENUMRET_OK;
 780  *******************************************************************************/
 781 static HRESULT WINAPI
 782 DestroyCallback(IDirectDrawSurface7 *surf,
 783                 DDSURFACEDESC2 *desc,
 784                 void *context)
 785 {
 786     struct ddraw_surface *Impl = impl_from_IDirectDrawSurface7(surf);
 787     ULONG ref7, ref4, ref3, ref2, ref1, gamma_count, iface_count;
 788
 789     ref7 = IDirectDrawSurface7_Release(surf);  /* For the EnumSurfaces */
 790     ref4 = Impl->ref4;
 791     ref3 = Impl->ref3;
 792     ref2 = Impl->ref2;
 793     ref1 = Impl->ref1;
 794     gamma_count = Impl->gamma_count;
 795
 796     WARN("Surface %p has an reference counts of 7: %u 4: %u 3: %u 2: %u 1: %u gamma: %u\n",
 797             Impl, ref7, ref4, ref3, ref2, ref1, gamma_count);
 798
 799     /* Skip surfaces which are attached somewhere or which are
 800      * part of a complex compound. They will get released when destroying
 801      * the root
 802      */
 803     if( (!Impl->is_complex_root) || (Impl->first_attached != Impl) )
 804         return DDENUMRET_OK;
 805
 806     /* Destroy the surface */
 807     iface_count = ddraw_surface_release_iface(Impl);
 808     while (iface_count) iface_count = ddraw_surface_release_iface(Impl);
 809
 810     return DDENUMRET_OK;
 811 }
 812
 813 /***********************************************************************
 814  * DllMain (DDRAW.0)
 815  *
 816  * Could be used to register DirectDraw drivers, if we have more than
 817  * one. Also used to destroy any objects left at unload if the
 818  * app didn't release them properly(Gothic 2, Diablo 2, Moto racer, ...)
 819  *
 820  ***********************************************************************/
 821 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
 822 {
 823     switch (reason)
 824     {
 825     case DLL_PROCESS_ATTACH:
 826     {
 827         static HMODULE ddraw_self;
 828         HKEY hkey = 0;
 829         WNDCLASSA wc;
 830
 831         /* Register the window class. This is used to create a hidden window
 832          * for D3D rendering, if the application didn't pass one. It can also
 833          * be used for creating a device window from SetCooperativeLevel(). */
 834         wc.style = CS_HREDRAW | CS_VREDRAW;
 835         wc.lpfnWndProc = DefWindowProcA;
 836         wc.cbClsExtra = 0;
 837         wc.cbWndExtra = 0;
 838         wc.hInstance = inst;
 839         wc.hIcon = 0;
 840         wc.hCursor = 0;
 841         wc.hbrBackground = GetStockObject(BLACK_BRUSH);
 842         wc.lpszMenuName = NULL;
 843         wc.lpszClassName = DDRAW_WINDOW_CLASS_NAME;
 844         if (!RegisterClassA(&wc))
 845         {
 846             ERR("Failed to register ddraw window class, last error %#x.\n", GetLastError());
 847             return FALSE;
 848         }
 849
 850         /* On Windows one can force the refresh rate that DirectDraw uses by
 851          * setting an override value in dxdiag.  This is documented in KB315614
 852          * (main article), KB230002, and KB217348.  By comparing registry dumps
 853          * before and after setting the override, we see that the override value
 854          * is stored in HKLM\Software\Microsoft\DirectDraw\ForceRefreshRate as a
 855          * DWORD that represents the refresh rate to force.  We use this
 856          * registry entry to modify the behavior of SetDisplayMode so that Wine
 857          * users can override the refresh rate in a Windows-compatible way.
 858          *
 859          * dxdiag will not accept a refresh rate lower than 40 or higher than
 860          * 120 so this value should be within that range.  It is, of course,
 861          * possible for a user to set the registry entry value directly so that
 862          * assumption might not hold.
 863          *
 864          * There is no current mechanism for setting this value through the Wine
 865          * GUI.  It would be most appropriate to set this value through a dxdiag
 866          * clone, but it may be sufficient to use winecfg.
 867          *
 868          * TODO: Create a mechanism for setting this value through the Wine GUI.
 869          */
 870         if ( !RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\DirectDraw", &hkey ) )
 871         {
 872             DWORD type, data, size;
 873
 874             size = sizeof(data);
 875             if (!RegQueryValueExA(hkey, "ForceRefreshRate", NULL, &type, (BYTE *)&data, &size) && type == REG_DWORD)
 876             {
 877                 TRACE("ForceRefreshRate set; overriding refresh rate to %d Hz\n", data);
 878                 force_refresh_rate = data;
 879             }
 880             RegCloseKey( hkey );
 881         }
 882
 883         /* Prevent the ddraw module from being unloaded. When switching to
 884          * exclusive mode, we replace the window proc of the ddraw window. If
 885          * an application would unload ddraw from the WM_DESTROY handler for
 886          * that window, it would return to unmapped memory and die. Apparently
 887          * this is supposed to work on Windows. */
 888         if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_PIN,
 889                 (const WCHAR *)&ddraw_self, &ddraw_self))
 890             ERR("Failed to get own module handle.\n");
 891
 892         instance = inst;
 893         DisableThreadLibraryCalls(inst);
 894         break;
 895     }
 896
 897     case DLL_PROCESS_DETACH:
 898         if(!list_empty(&global_ddraw_list))
 899         {
 900             struct list *entry, *entry2;
 901             WARN("There are still existing DirectDraw interfaces. Wine bug or buggy application?\n");
 902
 903             /* We remove elements from this loop */
 904             LIST_FOR_EACH_SAFE(entry, entry2, &global_ddraw_list)
 905             {
 906                 struct ddraw *ddraw = LIST_ENTRY(entry, struct ddraw, ddraw_list_entry);
 907                 HRESULT hr;
 908                 DDSURFACEDESC2 desc;
 909                 int i;
 910
 911                 WARN("DDraw %p has a refcount of %d\n", ddraw, ddraw->ref7 + ddraw->ref4 + ddraw->ref3 + ddraw->ref2 + ddraw->ref1);
 912
 913                 /* Add references to each interface to avoid freeing them unexpectedly */
 914                 IDirectDraw_AddRef(&ddraw->IDirectDraw_iface);
 915                 IDirectDraw2_AddRef(&ddraw->IDirectDraw2_iface);
 916                 IDirectDraw4_AddRef(&ddraw->IDirectDraw4_iface);
 917                 IDirectDraw7_AddRef(&ddraw->IDirectDraw7_iface);
 918
 919                 /* Does a D3D device exist? Destroy it
 920                     * TODO: Destroy all Vertex buffers, Lights, Materials
 921                     * and execute buffers too
 922                     */
 923                 if(ddraw->d3ddevice)
 924                 {
 925                     WARN("DDraw %p has d3ddevice %p attached\n", ddraw, ddraw->d3ddevice);
 926                     while(IDirect3DDevice7_Release(&ddraw->d3ddevice->IDirect3DDevice7_iface));
 927                 }
 928
 929                 /* Destroy the swapchain after any 3D device. The 3D device
 930                  * cleanup code needs a swapchain. Specifically, it tries to
 931                  * set the current render target to the front buffer. */
 932                 if (ddraw->wined3d_swapchain)
 933                     ddraw_destroy_swapchain(ddraw);
 934
 935                 /* Try to release the objects
 936                     * Do an EnumSurfaces to find any hanging surfaces
 937                     */
 938                 memset(&desc, 0, sizeof(desc));
 939                 desc.dwSize = sizeof(desc);
 940                 for(i = 0; i <= 1; i++)
 941                 {
 942                     hr = IDirectDraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, DDENUMSURFACES_ALL,
 943                             &desc, ddraw, DestroyCallback);
 944                     if(hr != D3D_OK)
 945                         ERR("(%p) EnumSurfaces failed, prepare for trouble\n", ddraw);
 946                 }
 947
 948                 if (!list_empty(&ddraw->surface_list))
 949                     ERR("DDraw %p still has surfaces attached.\n", ddraw);
 950
 951                 /* Release all hanging references to destroy the objects. This
 952                     * restores the screen mode too
 953                     */
 954                 while(IDirectDraw_Release(&ddraw->IDirectDraw_iface));
 955                 while(IDirectDraw2_Release(&ddraw->IDirectDraw2_iface));
 956                 while(IDirectDraw4_Release(&ddraw->IDirectDraw4_iface));
 957                 while(IDirectDraw7_Release(&ddraw->IDirectDraw7_iface));
 958             }
 959         }
 960
 961         if (reserved) break;
 962         UnregisterClassA(DDRAW_WINDOW_CLASS_NAME, inst);
 963     }
 964
 965     return TRUE;
 966 }