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