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