[AMSTREAM] Sync with Wine Staging 3.9. CORE-14656
[reactos.git] / dll / directx / ddraw / startup.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: dll/directx/ddraw/startup.c
5 * PURPOSE: DirectDraw Library
6 * PROGRAMMER: Magnus Olsen (greatlrd)
7 *
8 */
9
10 #include "rosdraw.h"
11
12 DDRAWI_DIRECTDRAW_GBL ddgbl;
13 DDRAWI_DDRAWSURFACE_GBL ddSurfGbl;
14
15 WCHAR classname[128];
16 WNDCLASSW wnd_class;
17
18
19 HRESULT WINAPI
20 Create_DirectDraw (LPGUID pGUID, LPDIRECTDRAW* pIface,
21 REFIID id, BOOL reenable)
22 {
23 LPDDRAWI_DIRECTDRAW_INT This;
24
25 DX_WINDBG_trace();
26 BOOL linking = FALSE;
27
28 if (pIface == NULL)
29 {
30 return DDERR_INVALIDPARAMS;
31 }
32
33 This = (LPDDRAWI_DIRECTDRAW_INT)*pIface;
34
35 DX_STUB_str("Linking?\n")
36
37 _SEH2_TRY
38 {
39 linking = This->lpLcl ? TRUE:FALSE;
40 }
41 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
42 {
43 linking = FALSE;
44 }
45 _SEH2_END;
46
47 /* fixme linking too second link when we shall not doing it */
48 if (!linking)
49 {
50 /* We do not have a DirectDraw interface, we need alloc it*/
51 LPDDRAWI_DIRECTDRAW_INT memThis;
52
53 DX_STUB_str("1. no linking\n");
54
55 DxHeapMemAlloc(memThis, sizeof(DDRAWI_DIRECTDRAW_INT));
56 if (memThis == NULL)
57 {
58 return DDERR_OUTOFMEMORY;
59 }
60
61 This = memThis;
62
63 /* Fixme release memory alloc if we fail */
64
65 DxHeapMemAlloc(This->lpLcl, sizeof(DDRAWI_DIRECTDRAW_LCL));
66 if (This->lpLcl == NULL)
67 {
68 return DDERR_OUTOFMEMORY;
69 }
70 }
71 else
72 {
73 /* We got the DirectDraw interface alloc and we need create the link */
74 LPDDRAWI_DIRECTDRAW_INT newThis;
75
76 DX_STUB_str("2.linking\n");
77
78 /* step 1.Alloc the new DDRAWI_DIRECTDRAW_INT for the link */
79 DxHeapMemAlloc(newThis, sizeof(DDRAWI_DIRECTDRAW_INT));
80 if (newThis == NULL)
81 {
82 return DDERR_OUTOFMEMORY;
83 }
84
85 /* step 2 check if it not DDCREATE_HARDWAREONLY we got if so we fail */
86 if ((pGUID) && (pGUID != (LPGUID)DDCREATE_HARDWAREONLY))
87 {
88 if (pGUID !=NULL)
89 {
90 This = newThis;
91 return DDERR_INVALIDDIRECTDRAWGUID;
92 }
93 }
94
95 /* step 3 do the link the old interface are store in the new one */
96 newThis->lpLink = This;
97
98 /* step 4 we need create new local directdraw struct for the new linked interface */
99 DxHeapMemAlloc(newThis->lpLcl, sizeof(DDRAWI_DIRECTDRAW_LCL));
100 if (newThis->lpLcl == NULL)
101 {
102 This = newThis;
103 return DDERR_OUTOFMEMORY;
104 }
105
106 This = newThis;
107 }
108
109 This->lpLcl->lpGbl = &ddgbl;
110
111 *pIface = (LPDIRECTDRAW)This;
112
113 /* Get right interface we whant */
114
115 This->lpVtbl = 0;
116 if (IsEqualGUID(&IID_IDirectDraw7, id))
117 {
118 /* DirectDraw7 Vtable */
119 This->lpVtbl = &DirectDraw7_Vtable;
120 This->lpLcl->dwLocalFlags = This->lpLcl->dwLocalFlags + DDRAWILCL_DIRECTDRAW7;
121 *pIface = (LPDIRECTDRAW)&This->lpVtbl;
122 Main_DirectDraw_AddRef(This);
123 }
124 else if (IsEqualGUID(&IID_IDirectDraw4, id))
125 {
126 /* DirectDraw4 Vtable */
127 This->lpVtbl = &DirectDraw4_Vtable;
128 *pIface = (LPDIRECTDRAW)&This->lpVtbl;
129 Main_DirectDraw_AddRef(This);
130 }
131 else if (IsEqualGUID(&IID_IDirectDraw2, id))
132 {
133 /* DirectDraw2 Vtable */
134 This->lpVtbl = &DirectDraw2_Vtable;
135 *pIface = (LPDIRECTDRAW)&This->lpVtbl;
136 Main_DirectDraw_AddRef(This);
137 }
138 else if (IsEqualGUID(&IID_IDirectDraw, id))
139 {
140 /* DirectDraw Vtable */
141 This->lpVtbl = &DirectDraw_Vtable;
142 *pIface = (LPDIRECTDRAW)&This->lpVtbl;
143 Main_DirectDraw_AddRef(This);
144 }
145
146 if ( This->lpVtbl != 0)
147 {
148 DX_STUB_str("Got iface\n");
149
150 if (StartDirectDraw((LPDIRECTDRAW)This, pGUID, FALSE) == DD_OK)
151 {
152 /*
153 RtlZeroMemory(&wnd_class, sizeof(wnd_class));
154 wnd_class.style = CS_HREDRAW | CS_VREDRAW;
155 wnd_class.lpfnWndProc = DefWindowProcW;
156 wnd_class.cbClsExtra = 0;
157 wnd_class.cbWndExtra = 0;
158 wnd_class.hInstance = GetModuleHandleW(0);
159 wnd_class.hIcon = 0;
160 wnd_class.hCursor = 0;
161 wnd_class.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
162 wnd_class.lpszMenuName = NULL;
163 wnd_class.lpszClassName = classname;
164 if(!RegisterClassW(&wnd_class))
165 {
166 DX_STUB_str("DDERR_GENERIC");
167 return DDERR_GENERIC;
168 }
169 */
170 This->lpLcl->hDD = ddgbl.hDD;
171 return DD_OK;
172 }
173 }
174
175 return DDERR_INVALIDPARAMS;
176 }
177
178
179 HRESULT WINAPI
180 StartDirectDraw(LPDIRECTDRAW iface, LPGUID lpGuid, BOOL reenable)
181 {
182 LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
183 DWORD hal_ret = DD_FALSE;
184 DWORD hel_ret = DD_FALSE;
185 DWORD devicetypes = 0;
186 DWORD dwFlags = 0;
187
188
189 DX_WINDBG_trace();
190
191
192 /*
193 * ddgbl.dwPDevice is not longer in use in windows 2000 and higher
194 * I am using it for device type
195 * devicetypes = 1 : both hal and hel are enable
196 * devicetypes = 2 : both hal are enable
197 * devicetypes = 3 : both hel are enable
198 * devicetypes = 4 :loading a guid drv from the register
199 */
200
201 ddgbl.lpDriverHandle = &ddgbl;
202 ddgbl.hDDVxd = -1;
203
204 if (reenable == FALSE)
205 {
206 if ((!IsBadReadPtr(This->lpLink,sizeof(LPDIRECTDRAW))) && (This->lpLink == NULL))
207 {
208 RtlZeroMemory(&ddgbl, sizeof(DDRAWI_DIRECTDRAW_GBL));
209 This->lpLcl->lpGbl->dwRefCnt++;
210 if (ddgbl.lpDDCBtmp == NULL)
211 {
212 // LPDDHAL_CALLBACKS
213 DxHeapMemAlloc( ddgbl.lpDDCBtmp , sizeof(DDHAL_CALLBACKS));
214 if (ddgbl.lpDDCBtmp == NULL)
215 {
216 DX_STUB_str("Out of memory\n");
217 return DD_FALSE;
218 }
219 }
220 }
221
222 DxHeapMemAlloc(ddgbl.lpModeInfo, sizeof(DDHALMODEINFO));
223 if (!ddgbl.lpModeInfo)
224 {
225 return DDERR_OUTOFMEMORY;
226 }
227
228 }
229 /* Windows handler are by set of SetCooperLevel
230 * so do not set it
231 */
232
233 if (reenable == FALSE)
234 {
235 if (lpGuid == NULL)
236 {
237 devicetypes= 1;
238
239 /* Create HDC for default, hal and hel driver */
240 // This->lpLcl->hWnd = (ULONG_PTR) GetActiveWindow();
241 This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
242
243 /* cObsolete is undoc in msdn it being use in CreateDCA */
244 RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
245 RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
246 dwFlags |= DDRAWI_DISPLAYDRV | DDRAWI_GDIDRV;
247 }
248 else if (lpGuid == (LPGUID) DDCREATE_HARDWAREONLY)
249 {
250 devicetypes = 2;
251 /* Create HDC for default, hal driver */
252 // This->lpLcl->hWnd =(ULONG_PTR) GetActiveWindow();
253 This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
254
255 /* cObsolete is undoc in msdn it being use in CreateDCA */
256 RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
257 RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
258 dwFlags |= DDRAWI_DISPLAYDRV | DDRAWI_GDIDRV;
259 }
260 else if (lpGuid == (LPGUID) DDCREATE_EMULATIONONLY)
261 {
262 devicetypes = 3;
263
264 /* Create HDC for default, hal and hel driver */
265 //This->lpLcl->hWnd = (ULONG_PTR) GetActiveWindow();
266 This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
267
268 /* cObsolete is undoc in msdn it being use in CreateDCA */
269 RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
270 RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
271
272 dwFlags |= DDRAWI_DISPLAYDRV | DDRAWI_GDIDRV;
273 }
274 else
275 {
276 /* FIXME : need getting driver from the GUID that have been pass in from
277 * the register. we do not support that yet
278 */
279 devicetypes = 4;
280 //This->lpLcl->hDC = (ULONG_PTR) NULL ;
281 //This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
282 }
283
284 /*
285 if ( (HDC)This->lpLcl->hDC == NULL)
286 {
287 DX_STUB_str("DDERR_OUTOFMEMORY\n");
288 return DDERR_OUTOFMEMORY ;
289 }
290 */
291 }
292
293 This->lpLcl->lpDDCB = ddgbl.lpDDCBtmp;
294
295 /* Startup HEL and HAL */
296 This->lpLcl->lpDDCB = This->lpLcl->lpGbl->lpDDCBtmp;
297 This->lpLcl->dwProcessId = GetCurrentProcessId();
298 switch (devicetypes)
299 {
300 case 2:
301 hal_ret = StartDirectDrawHal(iface, reenable);
302 This->lpLcl->lpDDCB->HELDD.dwFlags = 0;
303 break;
304
305 case 3:
306 hel_ret = StartDirectDrawHel(iface, reenable);
307 This->lpLcl->lpDDCB->HALDD.dwFlags = 0;
308 break;
309
310 default:
311 hal_ret = StartDirectDrawHal(iface, reenable);
312 hel_ret = StartDirectDrawHel(iface, reenable);
313 break;
314 }
315
316 if (hal_ret!=DD_OK)
317 {
318 if (hel_ret!=DD_OK)
319 {
320 DX_STUB_str("DDERR_NODIRECTDRAWSUPPORT\n");
321 return DDERR_NODIRECTDRAWSUPPORT;
322 }
323 dwFlags |= DDRAWI_NOHARDWARE;
324 DX_STUB_str("No hardware support\n");
325 }
326
327 if (hel_ret!=DD_OK)
328 {
329 dwFlags |= DDRAWI_NOEMULATION;
330
331 }
332 else
333 {
334 dwFlags |= DDRAWI_EMULATIONINITIALIZED;
335 }
336
337 /* Fill some basic info for Surface */
338 This->lpLcl->lpGbl->dwFlags = This->lpLcl->lpGbl->dwFlags | dwFlags | DDRAWI_ATTACHEDTODESKTOP;
339 This->lpLcl->lpDDCB = This->lpLcl->lpGbl->lpDDCBtmp;
340 This->lpLcl->hDD = ddgbl.hDD;
341
342 ddgbl.rectDevice.top = 0;
343 ddgbl.rectDevice.left = 0;
344 ddgbl.rectDevice.right = ddgbl.vmiData.dwDisplayWidth;
345 ddgbl.rectDevice.bottom = ddgbl.vmiData.dwDisplayHeight;
346
347 ddgbl.rectDesktop.top = 0;
348 ddgbl.rectDesktop.left = 0;
349 ddgbl.rectDesktop.right = ddgbl.vmiData.dwDisplayWidth;
350 ddgbl.rectDesktop.bottom = ddgbl.vmiData.dwDisplayHeight;
351
352 ddgbl.dwMonitorFrequency = GetDeviceCaps(GetWindowDC(NULL),VREFRESH);
353 ddgbl.lpModeInfo->dwWidth = ddgbl.vmiData.dwDisplayWidth;
354 ddgbl.lpModeInfo->dwHeight = ddgbl.vmiData.dwDisplayHeight;
355 ddgbl.lpModeInfo->dwBPP = ddgbl.vmiData.ddpfDisplay.dwRGBBitCount;
356 ddgbl.lpModeInfo->lPitch = ddgbl.vmiData.lDisplayPitch;
357 ddgbl.lpModeInfo->wRefreshRate = ddgbl.dwMonitorFrequency;
358 ddgbl.lpModeInfo->dwRBitMask = ddgbl.vmiData.ddpfDisplay.dwRBitMask;
359 ddgbl.lpModeInfo->dwGBitMask = ddgbl.vmiData.ddpfDisplay.dwGBitMask;
360 ddgbl.lpModeInfo->dwBBitMask = ddgbl.vmiData.ddpfDisplay.dwBBitMask;
361 ddgbl.lpModeInfo->dwAlphaBitMask = ddgbl.vmiData.ddpfDisplay.dwRGBAlphaBitMask;
362
363 return DD_OK;
364 }
365
366
367 HRESULT WINAPI
368 StartDirectDrawHel(LPDIRECTDRAW iface, BOOL reenable)
369 {
370 LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
371
372 if (reenable == FALSE)
373 {
374 if (ddgbl.lpDDCBtmp == NULL)
375 {
376 DxHeapMemAlloc(ddgbl.lpDDCBtmp, sizeof(DDHAL_CALLBACKS));
377 if ( ddgbl.lpDDCBtmp == NULL)
378 {
379 return DD_FALSE;
380 }
381 }
382 }
383
384 ddgbl.lpDDCBtmp->HELDD.CanCreateSurface = HelDdCanCreateSurface;
385 ddgbl.lpDDCBtmp->HELDD.CreateSurface = HelDdCreateSurface;
386 ddgbl.lpDDCBtmp->HELDD.CreatePalette = HelDdCreatePalette;
387 ddgbl.lpDDCBtmp->HELDD.DestroyDriver = HelDdDestroyDriver;
388 ddgbl.lpDDCBtmp->HELDD.FlipToGDISurface = HelDdFlipToGDISurface;
389 ddgbl.lpDDCBtmp->HELDD.GetScanLine = HelDdGetScanLine;
390 ddgbl.lpDDCBtmp->HELDD.SetColorKey = HelDdSetColorKey;
391 ddgbl.lpDDCBtmp->HELDD.SetExclusiveMode = HelDdSetExclusiveMode;
392 ddgbl.lpDDCBtmp->HELDD.SetMode = HelDdSetMode;
393 ddgbl.lpDDCBtmp->HELDD.WaitForVerticalBlank = HelDdWaitForVerticalBlank;
394
395 ddgbl.lpDDCBtmp->HELDD.dwFlags = DDHAL_CB32_CANCREATESURFACE |
396 DDHAL_CB32_CREATESURFACE |
397 DDHAL_CB32_CREATEPALETTE |
398 DDHAL_CB32_DESTROYDRIVER |
399 DDHAL_CB32_FLIPTOGDISURFACE |
400 DDHAL_CB32_GETSCANLINE |
401 DDHAL_CB32_SETCOLORKEY |
402 DDHAL_CB32_SETEXCLUSIVEMODE |
403 DDHAL_CB32_SETMODE |
404 DDHAL_CB32_WAITFORVERTICALBLANK ;
405
406 ddgbl.lpDDCBtmp->HELDD.dwSize = sizeof(This->lpLcl->lpDDCB->HELDD);
407
408 ddgbl.lpDDCBtmp->HELDDSurface.AddAttachedSurface = HelDdSurfAddAttachedSurface;
409 ddgbl.lpDDCBtmp->HELDDSurface.Blt = HelDdSurfBlt;
410 ddgbl.lpDDCBtmp->HELDDSurface.DestroySurface = HelDdSurfDestroySurface;
411 ddgbl.lpDDCBtmp->HELDDSurface.Flip = HelDdSurfFlip;
412 ddgbl.lpDDCBtmp->HELDDSurface.GetBltStatus = HelDdSurfGetBltStatus;
413 ddgbl.lpDDCBtmp->HELDDSurface.GetFlipStatus = HelDdSurfGetFlipStatus;
414 ddgbl.lpDDCBtmp->HELDDSurface.Lock = HelDdSurfLock;
415 ddgbl.lpDDCBtmp->HELDDSurface.reserved4 = HelDdSurfreserved4;
416 ddgbl.lpDDCBtmp->HELDDSurface.SetClipList = HelDdSurfSetClipList;
417 ddgbl.lpDDCBtmp->HELDDSurface.SetColorKey = HelDdSurfSetColorKey;
418 ddgbl.lpDDCBtmp->HELDDSurface.SetOverlayPosition = HelDdSurfSetOverlayPosition;
419 ddgbl.lpDDCBtmp->HELDDSurface.SetPalette = HelDdSurfSetPalette;
420 ddgbl.lpDDCBtmp->HELDDSurface.Unlock = HelDdSurfUnlock;
421 ddgbl.lpDDCBtmp->HELDDSurface.UpdateOverlay = HelDdSurfUpdateOverlay;
422 ddgbl.lpDDCBtmp->HELDDSurface.dwFlags = DDHAL_SURFCB32_ADDATTACHEDSURFACE |
423 DDHAL_SURFCB32_BLT |
424 DDHAL_SURFCB32_DESTROYSURFACE |
425 DDHAL_SURFCB32_FLIP |
426 DDHAL_SURFCB32_GETBLTSTATUS |
427 DDHAL_SURFCB32_GETFLIPSTATUS |
428 DDHAL_SURFCB32_LOCK |
429 DDHAL_SURFCB32_RESERVED4 |
430 DDHAL_SURFCB32_SETCLIPLIST |
431 DDHAL_SURFCB32_SETCOLORKEY |
432 DDHAL_SURFCB32_SETOVERLAYPOSITION |
433 DDHAL_SURFCB32_SETPALETTE |
434 DDHAL_SURFCB32_UNLOCK |
435 DDHAL_SURFCB32_UPDATEOVERLAY;
436
437 ddgbl.lpDDCBtmp->HELDDSurface.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDSurface);
438
439 /*
440 This->lpLcl->lpDDCB->HELDDPalette.DestroyPalette = HelDdPalDestroyPalette;
441 This->lpLcl->lpDDCB->HELDDPalette.SetEntries = HelDdPalSetEntries;
442 This->lpLcl->lpDDCB->HELDDPalette.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDPalette);
443 */
444
445 /*
446 This->lpLcl->lpDDCB->HELDDExeBuf.CanCreateExecuteBuffer = HelDdExeCanCreateExecuteBuffer;
447 This->lpLcl->lpDDCB->HELDDExeBuf.CreateExecuteBuffer = HelDdExeCreateExecuteBuffer;
448 This->lpLcl->lpDDCB->HELDDExeBuf.DestroyExecuteBuffer = HelDdExeDestroyExecuteBuffer;
449 This->lpLcl->lpDDCB->HELDDExeBuf.LockExecuteBuffer = HelDdExeLockExecuteBuffer;
450 This->lpLcl->lpDDCB->HELDDExeBuf.UnlockExecuteBuffer = HelDdExeUnlockExecuteBuffer;
451 */
452
453 return DD_OK;
454 }
455
456
457 HRESULT WINAPI
458 StartDirectDrawHal(LPDIRECTDRAW iface, BOOL reenable)
459 {
460 LPDWORD mpFourCC = NULL;
461 DDHALINFO mHALInfo;
462 BOOL newmode = FALSE;
463 LPDDSURFACEDESC mpTextures;
464 D3DHAL_CALLBACKS mD3dCallbacks;
465 D3DHAL_GLOBALDRIVERDATA mD3dDriverData;
466 DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks;
467 LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
468 DDHAL_GETDRIVERINFODATA DdGetDriverInfo = { 0 };
469
470 DX_WINDBG_trace();
471
472 RtlZeroMemory(&mHALInfo, sizeof(DDHALINFO));
473 RtlZeroMemory(&mD3dCallbacks, sizeof(D3DHAL_CALLBACKS));
474 RtlZeroMemory(&mD3dDriverData, sizeof(D3DHAL_GLOBALDRIVERDATA));
475 RtlZeroMemory(&mD3dBufferCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
476
477 if (reenable == FALSE)
478 {
479 if (ddgbl.lpDDCBtmp == NULL)
480 {
481 DxHeapMemAlloc(ddgbl.lpDDCBtmp, sizeof(DDHAL_CALLBACKS));
482 if ( ddgbl.lpDDCBtmp == NULL)
483 {
484 return DD_FALSE;
485 }
486 }
487 }
488 else
489 {
490 RtlZeroMemory(ddgbl.lpDDCBtmp,sizeof(DDHAL_CALLBACKS));
491 }
492
493 /*
494 * Startup DX HAL step one of three
495 */
496 if (!DdCreateDirectDrawObject(This->lpLcl->lpGbl, (HDC)This->lpLcl->hDC))
497 {
498 DxHeapMemFree(ddgbl.lpDDCBtmp);
499 return DD_FALSE;
500 }
501
502 /* Some card disable the dx after it have been created so
503 * we are force reenabling it
504 */
505 if (!DdReenableDirectDrawObject(This->lpLcl->lpGbl, &newmode))
506 {
507 DxHeapMemFree(ddgbl.lpDDCBtmp);
508 return DD_FALSE;
509 }
510
511 if (!DdQueryDirectDrawObject(This->lpLcl->lpGbl,
512 &mHALInfo,
513 &ddgbl.lpDDCBtmp->HALDD,
514 &ddgbl.lpDDCBtmp->HALDDSurface,
515 &ddgbl.lpDDCBtmp->HALDDPalette,
516 &mD3dCallbacks,
517 &mD3dDriverData,
518 &mD3dBufferCallbacks,
519 NULL,
520 mpFourCC,
521 NULL))
522 {
523 DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
524 DxHeapMemFree(ddgbl.lpDDCBtmp);
525 // FIXME Close DX first and second call
526 return DD_FALSE;
527 }
528
529 /* Alloc mpFourCC */
530 if (This->lpLcl->lpGbl->lpdwFourCC != NULL)
531 {
532 DxHeapMemFree(This->lpLcl->lpGbl->lpdwFourCC);
533 }
534
535 if (mHALInfo.ddCaps.dwNumFourCCCodes > 0 )
536 {
537
538 DxHeapMemAlloc(mpFourCC, sizeof(DWORD) * (mHALInfo.ddCaps.dwNumFourCCCodes + 2));
539
540 if (mpFourCC == NULL)
541 {
542 DxHeapMemFree(ddgbl.lpDDCBtmp);
543 // FIXME Close DX first and second call
544 return DD_FALSE;
545 }
546 }
547
548 /* Alloc mpTextures */
549 #if 0
550 DX_STUB_str("1 Here\n");
551
552 if (This->lpLcl->lpGbl->texture != NULL)
553 {
554 DxHeapMemFree(This->lpLcl->lpGbl->texture;
555 }
556
557 mpTextures = NULL;
558 if (mD3dDriverData.dwNumTextureFormats > 0)
559 {
560 mpTextures = (DDSURFACEDESC*) DxHeapMemAlloc(sizeof(DDSURFACEDESC) * mD3dDriverData.dwNumTextureFormats);
561 if (mpTextures == NULL)
562 {
563 DxHeapMemFree(mpFourCC);
564 DxHeapMemFree(ddgbl.lpDDCBtmp);
565 // FIXME Close DX first and second call
566 }
567 }
568
569 DX_STUB_str("2 Here\n");
570
571 #else
572 mpTextures = NULL;
573 #endif
574
575
576 /* Get all basic data from the driver */
577 if (!DdQueryDirectDrawObject(
578 This->lpLcl->lpGbl,
579 &mHALInfo,
580 &ddgbl.lpDDCBtmp->HALDD,
581 &ddgbl.lpDDCBtmp->HALDDSurface,
582 &ddgbl.lpDDCBtmp->HALDDPalette,
583 &mD3dCallbacks,
584 &mD3dDriverData,
585 &ddgbl.lpDDCBtmp->HALDDExeBuf,
586 (DDSURFACEDESC*)mpTextures,
587 mpFourCC,
588 NULL))
589 {
590 DxHeapMemFree(mpFourCC);
591 DxHeapMemFree(mpTextures);
592 DxHeapMemFree(ddgbl.lpDDCBtmp);
593 // FIXME Close DX first and second call
594 return DD_FALSE;
595 }
596
597 memcpy(&ddgbl.vmiData, &mHALInfo.vmiData,sizeof(VIDMEMINFO));
598
599
600 memcpy(&ddgbl.ddCaps, &mHALInfo.ddCaps,sizeof(DDCORECAPS));
601
602 This->lpLcl->lpGbl->dwNumFourCC = mHALInfo.ddCaps.dwNumFourCCCodes;
603 This->lpLcl->lpGbl->lpdwFourCC = mpFourCC;
604 // This->lpLcl->lpGbl->dwMonitorFrequency = mHALInfo.dwMonitorFrequency; // 0
605 This->lpLcl->lpGbl->dwModeIndex = mHALInfo.dwModeIndex;
606 // This->lpLcl->lpGbl->dwNumModes = mHALInfo.dwNumModes;
607 // This->lpLcl->lpGbl->lpModeInfo = mHALInfo.lpModeInfo;
608
609 /* FIXME convert mpTextures to DDHALMODEINFO */
610 // DxHeapMemFree( mpTextures);
611
612 /* FIXME D3D setup mD3dCallbacks and mD3dDriverData */
613
614
615
616
617 if (mHALInfo.dwFlags & DDHALINFO_GETDRIVERINFOSET)
618 {
619 DdGetDriverInfo.dwSize = sizeof (DDHAL_GETDRIVERINFODATA);
620 DdGetDriverInfo.guidInfo = GUID_MiscellaneousCallbacks;
621 DdGetDriverInfo.lpvData = (PVOID)&ddgbl.lpDDCBtmp->HALDDMiscellaneous;
622 DdGetDriverInfo.dwExpectedSize = sizeof (DDHAL_DDMISCELLANEOUSCALLBACKS);
623
624 if(mHALInfo.GetDriverInfo (&DdGetDriverInfo) == DDHAL_DRIVER_NOTHANDLED || DdGetDriverInfo.ddRVal != DD_OK)
625 {
626 DxHeapMemFree(mpFourCC);
627 DxHeapMemFree(mpTextures);
628 DxHeapMemFree(ddgbl.lpDDCBtmp);
629 // FIXME Close DX fristcall and second call
630 return DD_FALSE;
631 }
632
633 RtlZeroMemory(&DdGetDriverInfo, sizeof(DDHAL_GETDRIVERINFODATA));
634 DdGetDriverInfo.dwSize = sizeof (DDHAL_GETDRIVERINFODATA);
635 DdGetDriverInfo.guidInfo = GUID_Miscellaneous2Callbacks;
636
637 /* FIXME
638 DdGetDriverInfo.lpvData = (PVOID)&ddgbl.lpDDCBtmp->HALDDMiscellaneous;
639 DdGetDriverInfo.dwExpectedSize = sizeof (DDHAL_DDMISCELLANEOUS2CALLBACKS);
640
641 if(mHALInfo.GetDriverInfo (&DdGetDriverInfo) == DDHAL_DRIVER_NOTHANDLED || DdGetDriverInfo.ddRVal != DD_OK)
642 {
643 DxHeapMemFree(mpFourCC);
644 DxHeapMemFree(mpTextures);
645 DxHeapMemFree(ddgbl.lpDDCBtmp);
646 // FIXME Close DX fristcall and second call
647 return DD_FALSE;
648 }
649 DD_MISCELLANEOUS2CALLBACKS
650 {
651 DWORD dwSize;
652 DWORD dwFlags;
653 PDD_ALPHABLT AlphaBlt; // unsuse according to msdn and always set to NULL
654 PDD_CREATESURFACEEX CreateSurfaceEx;
655 PDD_GETDRIVERSTATE GetDriverState;
656 PDD_DESTROYDDLOCAL DestroyDDLocal;
657 }
658 DDHAL_MISC2CB32_CREATESURFACEEX
659 DDHAL_MISC2CB32_GETDRIVERSTATE
660 DDHAL_MISC2CB32_DESTROYDDLOCAL
661 */
662 }
663
664 if (mHALInfo.dwFlags & DDHALINFO_GETDRIVERINFO2)
665 {
666 This->lpLcl->lpGbl->dwFlags = This->lpLcl->lpGbl->dwFlags | DDRAWI_DRIVERINFO2;
667 }
668
669
670 return DD_OK;
671 }