dlls/ddraw/main.c

   1 /*              DirectDraw Base Functions
   2  *
   3  * Copyright 1997-1999 Marcus Meissner
   4  * Copyright 1998 Lionel Ulmer (most of Direct3D stuff)
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  *
   7  * This file contains the (internal) driver registration functions,
   8  * driver enumeration APIs and DirectDraw creation functions.
   9  */
  10
  11 #include "config.h"
  12
  13 #include <assert.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16
  17 #include "winerror.h"
  18 #include "debugtools.h"
  19 #include "heap.h"
  20
  21 #include "ddraw.h"
  22 #include "d3d.h"
  23
  24 /* This for all the enumeration and creation of D3D-related objects */
  25 #include "ddraw_private.h"
  26
  27 #define MAX_DDRAW_DRIVERS 3
  28 static const ddraw_driver* DDRAW_drivers[MAX_DDRAW_DRIVERS];
  29 static int DDRAW_num_drivers; /* = 0 */
  30 static int DDRAW_default_driver;
  31
  32 DEFAULT_DEBUG_CHANNEL(ddraw);
  33
  34 /**********************************************************************/
  35
  36 typedef struct {
  37     LPVOID lpCallback;
  38     LPVOID lpContext;
  39 } DirectDrawEnumerateProcData;
  40
  41 /***********************************************************************
  42  *              DirectDrawEnumerateExA (DDRAW.@)
  43  */
  44 HRESULT WINAPI DirectDrawEnumerateExA(
  45     LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
  46 {
  47     int i;
  48     TRACE("(%p,%p, %08lx)\n", lpCallback, lpContext, dwFlags);
  49
  50     if (TRACE_ON(ddraw)) {
  51         DPRINTF("  Flags : ");
  52         if (dwFlags & DDENUM_ATTACHEDSECONDARYDEVICES)
  53             DPRINTF("DDENUM_ATTACHEDSECONDARYDEVICES ");
  54         if (dwFlags & DDENUM_DETACHEDSECONDARYDEVICES)
  55             DPRINTF("DDENUM_DETACHEDSECONDARYDEVICES ");
  56         if (dwFlags & DDENUM_NONDISPLAYDEVICES)
  57             DPRINTF("DDENUM_NONDISPLAYDEVICES ");
  58         DPRINTF("\n");
  59     }
  60
  61     for (i=0; i<DDRAW_num_drivers; i++)
  62     {
  63         TRACE("Enumerating %s/%s interface\n",
  64               DDRAW_drivers[i]->info->szDriver,
  65               DDRAW_drivers[i]->info->szDescription);
  66
  67         /* We have to pass NULL from the primary display device.
  68          * RoadRage chapter 6's enumeration routine expects it. */
  69         if (!lpCallback((DDRAW_default_driver == i) ? NULL
  70                         :(LPGUID)&DDRAW_drivers[i]->info->guidDeviceIdentifier,
  71                         (LPSTR)DDRAW_drivers[i]->info->szDescription,
  72                         (LPSTR)DDRAW_drivers[i]->info->szDriver,
  73                         lpContext, 0))
  74             return DD_OK;
  75     }
  76
  77     /* Unsupported flags */
  78     if (dwFlags & DDENUM_NONDISPLAYDEVICES) {
  79         FIXME("no non-display devices supported.\n");
  80     }
  81     if (dwFlags & DDENUM_DETACHEDSECONDARYDEVICES) {
  82         FIXME("no detached secondary devices supported.\n");
  83     }
  84
  85     return DD_OK;
  86 }
  87
  88 /***********************************************************************
  89  *              DirectDrawEnumerateExW (DDRAW.@)
  90  */
  91
  92 static BOOL CALLBACK DirectDrawEnumerateExProcW(
  93     GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
  94     LPVOID lpContext, HMONITOR hm)
  95 {
  96     DirectDrawEnumerateProcData *pEPD = (DirectDrawEnumerateProcData*)lpContext;
  97     LPWSTR lpDriverDescriptionW =
  98         HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverDescription);
  99     LPWSTR lpDriverNameW =
 100         HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverName);
 101
 102     BOOL bResult = (*(LPDDENUMCALLBACKEXW *) pEPD->lpCallback)(
 103         lpGUID, lpDriverDescriptionW, lpDriverNameW, pEPD->lpContext, hm);
 104
 105     HeapFree(GetProcessHeap(), 0, lpDriverDescriptionW);
 106     HeapFree(GetProcessHeap(), 0, lpDriverNameW);
 107     return bResult;
 108 }
 109
 110 HRESULT WINAPI DirectDrawEnumerateExW(
 111   LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
 112 {
 113     DirectDrawEnumerateProcData epd;
 114     epd.lpCallback = (LPVOID) lpCallback;
 115     epd.lpContext = lpContext;
 116
 117     return DirectDrawEnumerateExA(DirectDrawEnumerateExProcW, (LPVOID) &epd, 0);
 118 }
 119
 120 /***********************************************************************
 121  *              DirectDrawEnumerateA (DDRAW.@)
 122  */
 123
 124 static BOOL CALLBACK DirectDrawEnumerateProcA(
 125         GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
 126         LPVOID lpContext, HMONITOR hm)
 127 {
 128     DirectDrawEnumerateProcData *pEPD = (DirectDrawEnumerateProcData*)lpContext;
 129
 130     return ((LPDDENUMCALLBACKA) pEPD->lpCallback)(
 131         lpGUID, lpDriverDescription, lpDriverName, pEPD->lpContext);
 132 }
 133
 134 HRESULT WINAPI DirectDrawEnumerateA(
 135   LPDDENUMCALLBACKA lpCallback, LPVOID lpContext)
 136 {
 137     DirectDrawEnumerateProcData epd;
 138     epd.lpCallback = (LPVOID) lpCallback;
 139     epd.lpContext = lpContext;
 140
 141     return DirectDrawEnumerateExA(DirectDrawEnumerateProcA, (LPVOID) &epd, 0);
 142 }
 143
 144 /***********************************************************************
 145  *              DirectDrawEnumerateW (DDRAW.@)
 146  */
 147
 148 static BOOL WINAPI DirectDrawEnumerateProcW(
 149   GUID *lpGUID, LPWSTR lpDriverDescription, LPWSTR lpDriverName,
 150   LPVOID lpContext, HMONITOR hm)
 151 {
 152     DirectDrawEnumerateProcData *pEPD = (DirectDrawEnumerateProcData*)lpContext;
 153
 154     return ((LPDDENUMCALLBACKW) pEPD->lpCallback)(
 155         lpGUID, lpDriverDescription, lpDriverName, pEPD->lpContext);
 156 }
 157
 158 HRESULT WINAPI DirectDrawEnumerateW(
 159   LPDDENUMCALLBACKW lpCallback, LPVOID lpContext)
 160 {
 161     DirectDrawEnumerateProcData epd;
 162     epd.lpCallback = (LPVOID) lpCallback;
 163     epd.lpContext = lpContext;
 164
 165     return DirectDrawEnumerateExW(DirectDrawEnumerateProcW, (LPVOID) &epd, 0);
 166 }
 167
 168 /***********************************************************************
 169  *              DirectDrawCreate (DDRAW.@)
 170  */
 171
 172 const ddraw_driver* DDRAW_FindDriver(const GUID* pGUID)
 173 {
 174     static const GUID zeroGUID; /* gets zero-inited */
 175
 176     TRACE("(%s)\n", pGUID ? debugstr_guid(pGUID) : "(null)");
 177
 178     if (DDRAW_num_drivers == 0) return NULL;
 179
 180     if (pGUID == (LPGUID)DDCREATE_EMULATIONONLY
 181         || pGUID == (LPGUID)DDCREATE_HARDWAREONLY)
 182         pGUID = NULL;
 183
 184     if (pGUID == NULL || memcmp(pGUID, &zeroGUID, sizeof(GUID)) == 0)
 185     {
 186         /* Use the default driver. */
 187         return DDRAW_drivers[DDRAW_default_driver];
 188     }
 189     else
 190     {
 191         /* Look for a matching GUID. */
 192
 193         int i;
 194         for (i=0; i < DDRAW_num_drivers; i++)
 195         {
 196             if (IsEqualGUID(pGUID,
 197                             &DDRAW_drivers[i]->info->guidDeviceIdentifier))
 198                 break;
 199         }
 200
 201         if (i < DDRAW_num_drivers)
 202         {
 203             return DDRAW_drivers[i];
 204         }
 205         else
 206         {
 207             ERR("(%s): did not recognize requested GUID.\n",debugstr_guid(pGUID));
 208             return NULL;
 209         }
 210     }
 211 }
 212
 213 static HRESULT DDRAW_Create(
 214         LPGUID lpGUID, LPVOID *lplpDD, LPUNKNOWN pUnkOuter, REFIID iid, BOOL ex
 215 ) {
 216     const ddraw_driver* driver;
 217     LPDIRECTDRAW7 pDD;
 218     HRESULT hr;
 219
 220     if (DDRAW_num_drivers == 0)
 221     {
 222         WARN("no DirectDraw drivers registered\n");
 223         return DDERR_INVALIDDIRECTDRAWGUID;
 224     }
 225
 226     if (lpGUID == (LPGUID)DDCREATE_EMULATIONONLY
 227         || lpGUID == (LPGUID)DDCREATE_HARDWAREONLY)
 228         lpGUID = NULL;
 229
 230     TRACE("(%s,%p,%p)\n",debugstr_guid(lpGUID),lplpDD,pUnkOuter);
 231
 232     if (pUnkOuter != NULL)
 233         return DDERR_INVALIDPARAMS; /* CLASS_E_NOAGGREGATION? */
 234
 235     driver = DDRAW_FindDriver(lpGUID);
 236     if (driver == NULL) return DDERR_INVALIDDIRECTDRAWGUID;
 237
 238     hr = driver->create(lpGUID, &pDD, pUnkOuter, ex);
 239     if (FAILED(hr)) return hr;
 240
 241     hr = IDirectDraw7_QueryInterface(pDD, iid, lplpDD);
 242     IDirectDraw7_Release(pDD);
 243     return hr;
 244 }
 245
 246 /***********************************************************************
 247  *              DirectDrawCreate (DDRAW.@)
 248  *
 249  * Only creates legacy IDirectDraw interfaces.
 250  * Cannot create IDirectDraw7 interfaces.
 251  * In theory.
 252  */
 253 HRESULT WINAPI DirectDrawCreate(
 254         LPGUID lpGUID, LPDIRECTDRAW* lplpDD, LPUNKNOWN pUnkOuter
 255 ) {
 256   return DDRAW_Create(lpGUID,(LPVOID*)lplpDD,pUnkOuter,&IID_IDirectDraw,FALSE);
 257 }
 258
 259 /***********************************************************************
 260  *              DirectDrawCreateEx (DDRAW.@)
 261  *
 262  * Only creates new IDirectDraw7 interfaces.
 263  * Supposed to fail if legacy interfaces are requested.
 264  * In theory.
 265  */
 266 HRESULT WINAPI DirectDrawCreateEx(
 267         LPGUID lpGUID, LPVOID* lplpDD, REFIID iid, LPUNKNOWN pUnkOuter
 268 ) {
 269     if (!IsEqualGUID(iid, &IID_IDirectDraw7))
 270         return DDERR_INVALIDPARAMS;
 271
 272   return DDRAW_Create(lpGUID, lplpDD, pUnkOuter, iid, TRUE);
 273 }
 274
 275 extern HRESULT Uninit_DirectDraw_Create(const GUID*, LPDIRECTDRAW7*,
 276                                         LPUNKNOWN, BOOL);
 277
 278 /* This is for the class factory. */
 279 static HRESULT DDRAW_CreateDirectDraw(IUnknown* pUnkOuter, REFIID iid,
 280                                       LPVOID* ppObj)
 281 {
 282     LPDIRECTDRAW7 pDD;
 283     HRESULT hr;
 284
 285     hr = Uninit_DirectDraw_Create(NULL, &pDD, pUnkOuter, TRUE); /* ex? */
 286     if (FAILED(hr)) return hr;
 287
 288     hr = IDirectDraw7_QueryInterface(pDD, iid, ppObj);
 289     IDirectDraw_Release(pDD);
 290     return hr;
 291 }
 292
 293 /******************************************************************************
 294  * DirectDraw ClassFactory
 295  */
 296 typedef struct {
 297     ICOM_VFIELD_MULTI(IClassFactory);
 298
 299     DWORD ref;
 300     HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, REFIID iid,
 301                                  LPVOID *ppObj);
 302 } IClassFactoryImpl;
 303
 304 struct object_creation_info
 305 {
 306     const CLSID *clsid;
 307     HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, REFIID riid,
 308                                  LPVOID *ppObj);
 309 };
 310
 311 /* There should be more, but these are the only ones listed in the header
 312  * file. */
 313 extern HRESULT DDRAW_CreateDirectDrawClipper(IUnknown *pUnkOuter, REFIID riid,
 314                                              LPVOID *ppObj);
 315
 316 static const struct object_creation_info object_creation[] =
 317 {
 318     { &CLSID_DirectDraw,        DDRAW_CreateDirectDraw },
 319     { &CLSID_DirectDraw7,       DDRAW_CreateDirectDraw },
 320     { &CLSID_DirectDrawClipper, DDRAW_CreateDirectDrawClipper }
 321 };
 322
 323 static HRESULT WINAPI
 324 DDCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
 325 {
 326     ICOM_THIS(IClassFactoryImpl,iface);
 327
 328     if (IsEqualGUID(riid, &IID_IUnknown)
 329         || IsEqualGUID(riid, &IID_IClassFactory))
 330     {
 331         IClassFactory_AddRef(iface);
 332         *ppobj = This;
 333         return S_OK;
 334     }
 335
 336     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
 337     return E_NOINTERFACE;
 338 }
 339
 340 static ULONG WINAPI DDCF_AddRef(LPCLASSFACTORY iface) {
 341     ICOM_THIS(IClassFactoryImpl,iface);
 342     return ++(This->ref);
 343 }
 344
 345 static ULONG WINAPI DDCF_Release(LPCLASSFACTORY iface) {
 346     ICOM_THIS(IClassFactoryImpl,iface);
 347
 348     ULONG ref = --This->ref;
 349
 350     if (ref == 0)
 351         HeapFree(GetProcessHeap(), 0, This);
 352
 353     return ref;
 354 }
 355
 356
 357 static HRESULT WINAPI DDCF_CreateInstance(
 358         LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
 359 ) {
 360     ICOM_THIS(IClassFactoryImpl,iface);
 361
 362     TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
 363
 364     return This->pfnCreateInstance(pOuter, riid, ppobj);
 365 }
 366
 367 static HRESULT WINAPI DDCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 368     ICOM_THIS(IClassFactoryImpl,iface);
 369     FIXME("(%p)->(%d),stub!\n",This,dolock);
 370     return S_OK;
 371 }
 372
 373 static ICOM_VTABLE(IClassFactory) DDCF_Vtbl =
 374 {
 375     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 376     DDCF_QueryInterface,
 377     DDCF_AddRef,
 378     DDCF_Release,
 379     DDCF_CreateInstance,
 380     DDCF_LockServer
 381 };
 382
 383 /*******************************************************************************
 384  * DllGetClassObject [DDRAW.@]
 385  * Retrieves class object from a DLL object
 386  *
 387  * NOTES
 388  *    Docs say returns STDAPI
 389  *
 390  * PARAMS
 391  *    rclsid [I] CLSID for the class object
 392  *    riid   [I] Reference to identifier of interface for class object
 393  *    ppv    [O] Address of variable to receive interface pointer for riid
 394  *
 395  * RETURNS
 396  *    Success: S_OK
 397  *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
 398  *             E_UNEXPECTED
 399  */
 400 DWORD WINAPI DDRAW_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
 401 {
 402     unsigned int i;
 403     IClassFactoryImpl *factory;
 404
 405     TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 406
 407     if ( !IsEqualGUID( &IID_IClassFactory, riid )
 408          && ! IsEqualGUID( &IID_IUnknown, riid) )
 409         return E_NOINTERFACE;
 410
 411     for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
 412     {
 413         if (IsEqualGUID(object_creation[i].clsid, rclsid))
 414             break;
 415     }
 416
 417     if (i == sizeof(object_creation)/sizeof(object_creation[0]))
 418     {
 419         FIXME("%s: no class found.\n", debugstr_guid(rclsid));
 420         return CLASS_E_CLASSNOTAVAILABLE;
 421     }
 422
 423     factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory));
 424     if (factory == NULL) return E_OUTOFMEMORY;
 425
 426     ICOM_INIT_INTERFACE(factory, IClassFactory, DDCF_Vtbl);
 427     factory->ref = 1;
 428
 429     factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
 430
 431     *ppv = ICOM_INTERFACE(factory, IClassFactory);
 432     return S_OK;
 433 }
 434
 435
 436 /*******************************************************************************
 437  * DllCanUnloadNow [DDRAW.@]  Determines whether the DLL is in use.
 438  *
 439  * RETURNS
 440  *    Success: S_OK
 441  *    Failure: S_FALSE
 442  */
 443 DWORD WINAPI DDRAW_DllCanUnloadNow(void) {
 444     FIXME("(void): stub\n");
 445     return S_FALSE;
 446 }
 447
 448 /******************************************************************************
 449  * Initialisation
 450  */
 451
 452 /* Choose which driver is considered the primary display driver. It will
 453  * be created when we get a NULL guid for the DirectDrawCreate(Ex). */
 454 static int DDRAW_ChooseDefaultDriver(void)
 455 {
 456     int i;
 457     int best = 0;
 458     int best_score = 0;
 459
 460     assert(DDRAW_num_drivers > 0);
 461
 462     /* This algorithm is really stupid. */
 463     for (i=0; i < DDRAW_num_drivers; i++)
 464     {
 465         if (DDRAW_drivers[i]->preference > best_score)
 466         {
 467             best_score = DDRAW_drivers[i]->preference;
 468             best = i;
 469         }
 470     }
 471
 472     assert(best_score > 0);
 473
 474     return best;
 475 }
 476
 477 BOOL WINAPI DDRAW_DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 478 {
 479     /* If we were sufficiently cool, DDraw drivers would just be COM
 480      * objects, registered with a particular component category. */
 481
 482     DDRAW_HAL_Init(hInstDLL, fdwReason, lpv);
 483     DDRAW_User_Init(hInstDLL, fdwReason, lpv);
 484
 485     if (DDRAW_num_drivers > 0)
 486         DDRAW_default_driver = DDRAW_ChooseDefaultDriver();
 487
 488     return TRUE;
 489 }
 490
 491 /* Register a direct draw driver. This should be called from your init
 492  * function. (That's why there is no locking: your init func is called from
 493  * our DllInit, which is serialised.) */
 494 void DDRAW_register_driver(const ddraw_driver *driver)
 495 {
 496     int i;
 497
 498     for (i = 0; i < DDRAW_num_drivers; i++)
 499     {
 500         if (DDRAW_drivers[i] == driver)
 501         {
 502             ERR("Driver reregistering %p\n", driver);
 503             return;
 504         }
 505     }
 506
 507     if (DDRAW_num_drivers == sizeof(DDRAW_drivers)/sizeof(DDRAW_drivers[0]))
 508     {
 509         ERR("too many DDRAW drivers\n");
 510         return;
 511     }
 512
 513     DDRAW_drivers[DDRAW_num_drivers++] = driver;
 514 }
 515
 516 /* This totally doesn't belong here. */
 517 LONG DDRAW_width_bpp_to_pitch(DWORD width, DWORD bpp)
 518 {
 519     LONG pitch;
 520
 521     assert(bpp != 0); /* keeps happening... */
 522
 523     if (bpp == 15) bpp = 16;
 524     pitch = width * (bpp / 8);
 525     return pitch + (8 - (pitch % 8)) % 8;
 526 }