projects / reactos.git / blob
? search:


cca6582fbb380f0ef99955f75d166e36b3be5a07
[reactos.git] / reactos / dll / win32 / gdi32 / misc / gdientry.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS GDI32
4 * PURPOSE: GDI DirectX inteface
5 * FILE: lib/gdi32/misc/gdientry.c
6 * PROGRAMERS: Alex Ionescu (alex@relsoft.net)
7 * Magnus Olsen (magnus@greatlord.com)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include "precomp.h"
13 #include <ddraw.h>
14 #include <ddrawi.h>
15 #include <ddrawint.h>
16 #include <ddrawgdi.h>
17 #include <ntgdi.h>
18 #include <d3dhal.h>
19
20 /* DATA **********************************************************************/
21
22 HANDLE ghDirectDraw;
23 ULONG gcDirectDraw;
24
25 #define GetDdHandle(Handle) ((HANDLE)Handle ? (HANDLE)Handle : ghDirectDraw)
26
27
28
29 /* CALLBACKS *****************************************************************/
30
31 /*
32 * @implemented
33 *
34 * DdAddAttachedSurface
35 */
36 DWORD
37 WINAPI
38 DdAddAttachedSurface(LPDDHAL_ADDATTACHEDSURFACEDATA Attach)
39 {
40 /* Call win32k */
41 return NtGdiDdAddAttachedSurface((HANDLE)Attach->lpDDSurface->hDDSurface,
42 (HANDLE)Attach->lpSurfAttached->hDDSurface,
43 (PDD_ADDATTACHEDSURFACEDATA)Attach);
44 }
45
46 /*
47 * @implemented
48 *
49 * DdBlt
50 */
51 DWORD
52 WINAPI
53 DdBlt(LPDDHAL_BLTDATA Blt)
54 {
55 HANDLE Surface = 0;
56
57 /* Use the right surface */
58 if (Blt->lpDDSrcSurface)
59 {
60 Surface = (HANDLE)Blt->lpDDSrcSurface->hDDSurface;
61 }
62
63 /* Call win32k */
64 return NtGdiDdBlt((HANDLE)Blt->lpDDDestSurface->hDDSurface, Surface, (PDD_BLTDATA)Blt);
65 }
66
67 /*
68 * @implemented
69 *
70 * DdDestroySurface
71 */
72 DWORD
73 WINAPI
74 DdDestroySurface(LPDDHAL_DESTROYSURFACEDATA pDestroySurface)
75 {
76 DWORD Return = DDHAL_DRIVER_NOTHANDLED;
77 BOOL RealDestroy;
78
79 if (pDestroySurface->lpDDSurface->hDDSurface)
80 {
81 /* Check if we shoudl really destroy it */
82 RealDestroy = !(pDestroySurface->lpDDSurface->dwFlags & DDRAWISURF_DRIVERMANAGED) ||
83 !(pDestroySurface->lpDDSurface->dwFlags & DDRAWISURF_INVALID);
84
85 /* Call win32k */
86 Return = NtGdiDdDestroySurface((HANDLE)pDestroySurface->lpDDSurface->hDDSurface, RealDestroy);
87 }
88
89 return Return;
90 }
91
92 /*
93 * @implemented
94 *
95 * DdFlip
96 */
97 DWORD
98 WINAPI
99 DdFlip(LPDDHAL_FLIPDATA Flip)
100 {
101 /* Note :
102 * See http://msdn2.microsoft.com/en-us/library/ms794213.aspx and
103 * http://msdn2.microsoft.com/en-us/library/ms792675.aspx
104 */
105
106 HANDLE hSurfaceCurrentLeft = NULL;
107 HANDLE hSurfaceTargetLeft = NULL;
108
109 /* Auto flip off or on */
110 if (Flip->dwFlags & DDFLIP_STEREO )
111 {
112 if ( (Flip->lpSurfTargLeft) &&
113 (Flip->lpSurfCurrLeft))
114 {
115 /* Auto flip on */
116 hSurfaceTargetLeft = (HANDLE) Flip->lpSurfTargLeft->hDDSurface;
117 hSurfaceCurrentLeft = (HANDLE) Flip->lpSurfCurrLeft->hDDSurface;
118 }
119 }
120
121 /* Call win32k */
122 return NtGdiDdFlip( (HANDLE) Flip->lpSurfCurr->hDDSurface,
123 (HANDLE) Flip->lpSurfTarg->hDDSurface,
124 hSurfaceCurrentLeft,
125 hSurfaceTargetLeft,
126 (PDD_FLIPDATA) Flip);
127 }
128
129 /*
130 * @implemented
131 *
132 * DdLock
133 */
134 DWORD
135 WINAPI
136 DdLock(LPDDHAL_LOCKDATA Lock)
137 {
138
139 /* Call win32k */
140 return NtGdiDdLock((HANDLE)Lock->lpDDSurface->hDDSurface,
141 (PDD_LOCKDATA)Lock,
142 (HANDLE)Lock->lpDDSurface->hDC);
143 }
144
145 /*
146 * @implemented
147 *
148 * DdUnlock
149 */
150 DWORD
151 WINAPI
152 DdUnlock(LPDDHAL_UNLOCKDATA Unlock)
153 {
154 /* Call win32k */
155 return NtGdiDdUnlock((HANDLE)Unlock->lpDDSurface->hDDSurface,
156 (PDD_UNLOCKDATA)Unlock);
157 }
158
159 /*
160 * @implemented
161 *
162 * DdGetBltStatus
163 */
164 DWORD
165 WINAPI
166 DdGetBltStatus(LPDDHAL_GETBLTSTATUSDATA GetBltStatus)
167 {
168 /* Call win32k */
169 return NtGdiDdGetBltStatus((HANDLE)GetBltStatus->lpDDSurface->hDDSurface,
170 (PDD_GETBLTSTATUSDATA)GetBltStatus);
171 }
172
173 /*
174 * @implemented
175 *
176 * DdGetBltStatus
177 */
178 DWORD
179 WINAPI
180 DdGetFlipStatus(LPDDHAL_GETFLIPSTATUSDATA GetFlipStatus)
181 {
182 /* Call win32k */
183 return NtGdiDdGetFlipStatus((HANDLE)GetFlipStatus->lpDDSurface->hDDSurface,
184 (PDD_GETFLIPSTATUSDATA)GetFlipStatus);
185 }
186
187 /*
188 * @implemented
189 *
190 * DdUpdateOverlay
191 */
192 DWORD
193 WINAPI
194 DdUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA UpdateOverlay)
195 {
196
197 /* We have to handle this manually here */
198 if (UpdateOverlay->dwFlags & DDOVER_KEYDEST)
199 {
200 /* Use the override */
201 UpdateOverlay->dwFlags &= ~DDOVER_KEYDEST;
202 UpdateOverlay->dwFlags |= DDOVER_KEYDESTOVERRIDE;
203
204 /* Set the overlay */
205 UpdateOverlay->overlayFX.dckDestColorkey =
206 UpdateOverlay->lpDDDestSurface->ddckCKDestOverlay;
207 }
208 if (UpdateOverlay->dwFlags & DDOVER_KEYSRC)
209 {
210 /* Use the override */
211 UpdateOverlay->dwFlags &= ~DDOVER_KEYSRC;
212 UpdateOverlay->dwFlags |= DDOVER_KEYSRCOVERRIDE;
213
214 /* Set the overlay */
215 UpdateOverlay->overlayFX.dckSrcColorkey =
216 UpdateOverlay->lpDDSrcSurface->ddckCKSrcOverlay;
217 }
218
219 /* Call win32k */
220 return NtGdiDdUpdateOverlay((HANDLE)UpdateOverlay->lpDDDestSurface->hDDSurface,
221 (HANDLE)UpdateOverlay->lpDDSrcSurface->hDDSurface,
222 (PDD_UPDATEOVERLAYDATA)UpdateOverlay);
223 }
224
225 /*
226 * @implemented
227 *
228 * DdSetOverlayPosition
229 */
230 DWORD
231 WINAPI
232 DdSetOverlayPosition(LPDDHAL_SETOVERLAYPOSITIONDATA SetOverlayPosition)
233 {
234 /* Call win32k */
235 return NtGdiDdSetOverlayPosition( (HANDLE)SetOverlayPosition->lpDDSrcSurface->hDDSurface,
236 (HANDLE)SetOverlayPosition->lpDDDestSurface->hDDSurface,
237 (PDD_SETOVERLAYPOSITIONDATA) SetOverlayPosition);
238 }
239
240 /*
241 * @implemented
242 *
243 * DdWaitForVerticalBlank
244 */
245 DWORD
246 WINAPI
247 DdWaitForVerticalBlank(LPDDHAL_WAITFORVERTICALBLANKDATA WaitForVerticalBlank)
248 {
249 /* Call win32k */
250 return NtGdiDdWaitForVerticalBlank(GetDdHandle(
251 WaitForVerticalBlank->lpDD->hDD),
252 (PDD_WAITFORVERTICALBLANKDATA)
253 WaitForVerticalBlank);
254 }
255
256 /*
257 * @implemented
258 *
259 * DdCanCreateSurface
260 */
261 DWORD
262 WINAPI
263 DdCanCreateSurface(LPDDHAL_CANCREATESURFACEDATA CanCreateSurface)
264 {
265 /*
266 * Note : This functions are basic same, in win32k
267 * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs
268 * toghter in win32k at end and retrurn same data, it is still sepreated
269 * at user mode but in kmode it is not.
270 */
271
272 /* Call win32k */
273 return NtGdiDdCanCreateSurface(GetDdHandle(CanCreateSurface->lpDD->hDD),
274 (PDD_CANCREATESURFACEDATA)CanCreateSurface);
275 }
276
277 /*
278 * @implemented
279 *
280 * DdCreateSurface
281 */
282 DWORD
283 WINAPI
284 DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface)
285 {
286 DWORD Return = DDHAL_DRIVER_NOTHANDLED;
287 ULONG SurfaceCount = pCreateSurface->dwSCnt;
288 DD_SURFACE_LOCAL DdSurfaceLocal;
289 DD_SURFACE_MORE DdSurfaceMore;
290 DD_SURFACE_GLOBAL DdSurfaceGlobal;
291
292 HANDLE hPrevSurface, hSurface;
293
294 PDD_SURFACE_LOCAL pDdSurfaceLocal = NULL;
295 PDD_SURFACE_MORE pDdSurfaceMore = NULL;
296 PDD_SURFACE_GLOBAL pDdSurfaceGlobal = NULL;
297
298 PDD_SURFACE_LOCAL ptmpDdSurfaceLocal = NULL;
299 PDD_SURFACE_MORE ptmpDdSurfaceMore = NULL;
300 PDD_SURFACE_GLOBAL ptmpDdSurfaceGlobal = NULL;
301 PHANDLE phSurface = NULL, puhSurface = NULL;
302 ULONG i;
303 LPDDSURFACEDESC pSurfaceDesc = NULL;
304
305 /* TODO : Speed optimze, most games/dx apps/program does not want 1 surface, they want lest 2
306 * so we need incress the stack so it can contain 2 surface instead of one, this will incress
307 * the speed of the apps when it trying alloc buffer. How to incress the surface stack space
308 * we need create a own struct for DD_SURFACE_LOCAL DdSurfaceLocal, DD_SURFACE_MORE DdSurfaceMore
309 * DD_SURFACE_GLOBAL DdSurfaceGlobal. HANDLE hPrevSurface, hSurface. like
310 * struct { DD_SURFACE_LOCAL DdSurfaceLocal1, DD_SURFACE_LOCAL DdSurfaceLocal2 }
311 * lest so it contain two surface. maybe 4. we need watch what is most common here before
312 * we create the size activate this IF when you start doing the optimze and please also
313 * take report from user which value they got here
314 */
315 #if 1
316 {
317 char buffer[1024]; \
318 sprintf ( buffer, "Function %s : Optimze max to %d Surface ? (%s:%d)\n", __FUNCTION__, (int)SurfaceCount,__FILE__,__LINE__ );
319 OutputDebugStringA(buffer);
320 }
321 #endif
322
323 /* Check how many surfaces there are */
324 if (SurfaceCount != 1)
325 {
326 /* We got more that one surface so we need alloc memory for them */
327 pDdSurfaceLocal = (PDD_SURFACE_LOCAL) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(DD_SURFACE_LOCAL) * SurfaceCount ));
328 pDdSurfaceMore = (PDD_SURFACE_MORE) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(DD_SURFACE_MORE) * SurfaceCount ));
329 pDdSurfaceGlobal = (PDD_SURFACE_GLOBAL) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(DD_SURFACE_GLOBAL) * SurfaceCount ));
330 phSurface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(HANDLE) * SurfaceCount ));
331 puhSurface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(HANDLE) * SurfaceCount ));
332
333 /* check if we sueese alloc all memory we need */
334 if ((pDdSurfaceLocal == NULL) || (pDdSurfaceMore == NULL) || (pDdSurfaceGlobal == NULL) || (phSurface == NULL) || (puhSurface == NULL))
335 {
336 pCreateSurface->ddRVal = DDERR_OUTOFMEMORY;
337
338 if ( pDdSurfaceLocal != NULL )
339 {
340 HeapFree(GetProcessHeap(), 0, pDdSurfaceLocal);
341 }
342
343 if ( pDdSurfaceMore != NULL )
344 {
345 HeapFree(GetProcessHeap(), 0, pDdSurfaceMore);
346 }
347
348 if ( phSurface != NULL )
349 {
350 HeapFree(GetProcessHeap(), 0, phSurface);
351 }
352
353 if ( puhSurface != NULL )
354 {
355 HeapFree(GetProcessHeap(), 0, puhSurface);
356 }
357
358 return DDHAL_DRIVER_HANDLED;
359 }
360 }
361 else
362 {
363 /* We'll use what we have on the stack */
364 pDdSurfaceLocal = &DdSurfaceLocal;
365 pDdSurfaceMore = &DdSurfaceMore;
366 pDdSurfaceGlobal = &DdSurfaceGlobal;
367 phSurface = &hPrevSurface;
368 puhSurface = &hSurface;
369
370 /* Clear the structures */
371 RtlZeroMemory(&DdSurfaceLocal, sizeof(DdSurfaceLocal));
372 RtlZeroMemory(&DdSurfaceGlobal, sizeof(DdSurfaceGlobal));
373 RtlZeroMemory(&DdSurfaceMore, sizeof(DdSurfaceMore));
374 }
375
376 /* check if we got a surface or not */
377 if (SurfaceCount!=0)
378 {
379 /* Loop for each surface */
380 ptmpDdSurfaceGlobal = pDdSurfaceGlobal;
381 ptmpDdSurfaceLocal = pDdSurfaceLocal;
382 ptmpDdSurfaceMore = pDdSurfaceMore;
383 pSurfaceDesc = pCreateSurface->lpDDSurfaceDesc;
384
385 for (i = 0; i < SurfaceCount; i++)
386 {
387 LPDDRAWI_DDRAWSURFACE_LCL lcl = pCreateSurface->lplpSList[i];
388 LPDDRAWI_DDRAWSURFACE_GBL gpl = pCreateSurface->lplpSList[i]->lpGbl;
389
390 phSurface[i] = (HANDLE)lcl->hDDSurface;
391 ptmpDdSurfaceLocal->ddsCaps.dwCaps = lcl->ddsCaps.dwCaps;
392
393 ptmpDdSurfaceLocal->dwFlags = (ptmpDdSurfaceLocal->dwFlags &
394 (0xB0000000 | DDRAWISURF_INMASTERSPRITELIST |
395 DDRAWISURF_HELCB | DDRAWISURF_FRONTBUFFER |
396 DDRAWISURF_BACKBUFFER | DDRAWISURF_INVALID |
397 DDRAWISURF_DCIBUSY | DDRAWISURF_DCILOCK)) |
398 (lcl->dwFlags & DDRAWISURF_DRIVERMANAGED);
399
400 ptmpDdSurfaceGlobal->wWidth = gpl->wWidth;
401 ptmpDdSurfaceGlobal->wHeight = gpl->wHeight;
402 ptmpDdSurfaceGlobal->lPitch = gpl->lPitch;
403 ptmpDdSurfaceGlobal->fpVidMem = gpl->fpVidMem;
404 ptmpDdSurfaceGlobal->dwBlockSizeX = gpl->dwBlockSizeX;
405 ptmpDdSurfaceGlobal->dwBlockSizeY = gpl->dwBlockSizeY;
406
407 if (lcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
408 {
409 RtlCopyMemory( &ptmpDdSurfaceGlobal->ddpfSurface ,
410 &gpl->ddpfSurface,
411 sizeof(DDPIXELFORMAT));
412
413 ptmpDdSurfaceGlobal->ddpfSurface.dwSize = sizeof(DDPIXELFORMAT);
414 }
415 else
416 {
417 RtlCopyMemory( &ptmpDdSurfaceGlobal->ddpfSurface ,
418 &gpl->lpDD->vmiData.ddpfDisplay,
419 sizeof(DDPIXELFORMAT));
420 }
421
422 /* Note if lcl->lpSurfMore is NULL zero out
423 * ptmpDdSurfaceMore->ddsCapsEx.dwCaps2,
424 * dwCaps3, dwCaps4, ptmpDdSurfaceMore->dwSurfaceHandle
425 */
426 if (lcl->lpSurfMore)
427 {
428 ptmpDdSurfaceMore->ddsCapsEx.dwCaps2 = lcl->lpSurfMore->ddsCapsEx.dwCaps2;
429 ptmpDdSurfaceMore->ddsCapsEx.dwCaps3 = lcl->lpSurfMore->ddsCapsEx.dwCaps3;
430 ptmpDdSurfaceMore->ddsCapsEx.dwCaps4 = lcl->lpSurfMore->ddsCapsEx.dwCaps4;
431 ptmpDdSurfaceMore->dwSurfaceHandle = lcl->lpSurfMore->dwSurfaceHandle;
432 }
433
434
435 /* count to next SurfaceCount */
436 ptmpDdSurfaceGlobal = (PDD_SURFACE_GLOBAL) (((PBYTE) ((ULONG_PTR) ptmpDdSurfaceGlobal)) + sizeof(DD_SURFACE_GLOBAL));
437 ptmpDdSurfaceLocal = (PDD_SURFACE_LOCAL) (((PBYTE) ((ULONG_PTR) ptmpDdSurfaceLocal)) + sizeof(DD_SURFACE_LOCAL));
438 ptmpDdSurfaceMore = (PDD_SURFACE_MORE) (((PBYTE) ((ULONG_PTR) ptmpDdSurfaceMore)) + sizeof(DD_SURFACE_MORE));
439 }
440 }
441
442 /* Call win32k now */
443 pCreateSurface->ddRVal = DDERR_GENERIC;
444
445 Return = NtGdiDdCreateSurface(GetDdHandle(pCreateSurface->lpDD->hDD),
446 (HANDLE *)phSurface,
447 pSurfaceDesc,
448 pDdSurfaceGlobal,
449 pDdSurfaceLocal,
450 pDdSurfaceMore,
451 (PDD_CREATESURFACEDATA)pCreateSurface,
452 puhSurface);
453
454 if (SurfaceCount == 0)
455 {
456 pCreateSurface->ddRVal = DDERR_GENERIC;
457 }
458 else
459 {
460 ptmpDdSurfaceMore = pDdSurfaceMore;
461 ptmpDdSurfaceGlobal = pDdSurfaceGlobal;
462 ptmpDdSurfaceLocal = pDdSurfaceLocal;
463
464 for (i=0;i<SurfaceCount;i++)
465 {
466 LPDDRAWI_DDRAWSURFACE_LCL lcl = pCreateSurface->lplpSList[i];
467 LPDDRAWI_DDRAWSURFACE_GBL gpl = pCreateSurface->lplpSList[i]->lpGbl;
468
469 gpl->lPitch = ptmpDdSurfaceGlobal->lPitch;
470 gpl->fpVidMem = ptmpDdSurfaceGlobal->fpVidMem;
471 gpl->dwBlockSizeX = ptmpDdSurfaceGlobal->dwBlockSizeX;
472 gpl->dwBlockSizeY = ptmpDdSurfaceGlobal->dwBlockSizeY;
473
474 if (lcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
475 {
476 RtlCopyMemory( &gpl->ddpfSurface, &ptmpDdSurfaceGlobal->ddpfSurface , sizeof(DDPIXELFORMAT));
477 }
478
479 if (pCreateSurface->ddRVal != DD_OK)
480 {
481 gpl->fpVidMem = 0;
482 if (lcl->hDDSurface)
483 {
484 NtGdiDdDeleteSurfaceObject( (HANDLE)lcl->hDDSurface);
485 }
486 lcl->hDDSurface = 0;
487 }
488 else
489 {
490
491 lcl->hDDSurface = (ULONG_PTR) puhSurface[i];
492 }
493
494 lcl->ddsCaps.dwCaps = ptmpDdSurfaceLocal->ddsCaps.dwCaps;
495 if (lcl->lpSurfMore)
496 {
497 lcl->lpSurfMore->ddsCapsEx.dwCaps2 = ptmpDdSurfaceMore->ddsCapsEx.dwCaps2;
498 lcl->lpSurfMore->ddsCapsEx.dwCaps3 = ptmpDdSurfaceMore->ddsCapsEx.dwCaps3;
499 lcl->lpSurfMore->ddsCapsEx.dwCaps4 = ptmpDdSurfaceMore->ddsCapsEx.dwCaps4;
500 }
501
502 /* count to next SurfaceCount */
503 ptmpDdSurfaceGlobal = (PDD_SURFACE_GLOBAL) (((PBYTE) ((ULONG_PTR) ptmpDdSurfaceGlobal)) + sizeof(DD_SURFACE_GLOBAL));
504 ptmpDdSurfaceLocal = (PDD_SURFACE_LOCAL) (((PBYTE) ((ULONG_PTR) ptmpDdSurfaceLocal)) + sizeof(DD_SURFACE_LOCAL));
505 ptmpDdSurfaceMore = (PDD_SURFACE_MORE) (((PBYTE) ((ULONG_PTR) ptmpDdSurfaceMore)) + sizeof(DD_SURFACE_MORE));
506 }
507 }
508
509 /* Check if we have to free all our local allocations */
510 if (SurfaceCount > 1)
511 {
512 if ( pDdSurfaceLocal != NULL )
513 {
514 HeapFree(GetProcessHeap(), 0, pDdSurfaceLocal);
515 }
516
517 if ( pDdSurfaceMore != NULL )
518 {
519 HeapFree(GetProcessHeap(), 0, pDdSurfaceMore);
520 }
521
522 if ( phSurface != NULL )
523 {
524 HeapFree(GetProcessHeap(), 0, phSurface);
525 }
526
527 if ( puhSurface != NULL )
528 {
529 HeapFree(GetProcessHeap(), 0, puhSurface);
530 }
531 }
532
533 /* Return */
534 return Return;
535 }
536
537 /*
538 * @implemented
539 *
540 * DdSetColorKey
541 */
542 DWORD
543 WINAPI
544 DdSetColorKey(LPDDHAL_SETCOLORKEYDATA pSetColorKey)
545 {
546 /* Call win32k */
547 return NtGdiDdSetColorKey((HANDLE)pSetColorKey->lpDDSurface->hDDSurface,
548 (PDD_SETCOLORKEYDATA)pSetColorKey);
549 }
550
551 /*
552 * @implemented
553 *
554 * DdGetScanLine
555 */
556 DWORD
557 WINAPI
558 DdGetScanLine(LPDDHAL_GETSCANLINEDATA pGetScanLine)
559 {
560 /* Call win32k */
561 return NtGdiDdGetScanLine(GetDdHandle(pGetScanLine->lpDD->hDD),
562 (PDD_GETSCANLINEDATA)pGetScanLine);
563 }
564
565
566 /*
567 * @implemented
568 *
569 * DvpCreateVideoPort
570 */
571 BOOL
572 WINAPI
573 DvpCreateVideoPort(LPDDHAL_CREATEVPORTDATA pDvdCreatePort)
574 {
575 pDvdCreatePort->lpVideoPort->hDDVideoPort =
576 NtGdiDvpCreateVideoPort(GetDdHandle(pDvdCreatePort->lpDD->lpGbl->hDD),
577 (PDD_CREATEVPORTDATA) pDvdCreatePort);
578
579 return TRUE;
580 }
581
582 /*
583 * @implemented
584 *
585 * DvpCreateVideoPort
586 */
587 DWORD
588 WINAPI
589 DvpDestroyVideoPort(LPDDHAL_DESTROYVPORTDATA pDvdDestoryPort)
590 {
591 return NtGdiDvpDestroyVideoPort(pDvdDestoryPort->lpVideoPort->hDDVideoPort, (PDD_DESTROYVPORTDATA)pDvdDestoryPort);
592 }
593
594 /*
595 * @implemented
596 *
597 * DvpCreateVideoPort
598 */
599 DWORD
600 WINAPI
601 DvpFlipVideoPort(LPDDHAL_FLIPVPORTDATA pDvdPortFlip)
602 {
603 return NtGdiDvpFlipVideoPort(pDvdPortFlip->lpVideoPort->hDDVideoPort,
604 (HANDLE)pDvdPortFlip->lpSurfCurr->hDDSurface,
605 (HANDLE)pDvdPortFlip->lpSurfTarg->hDDSurface,
606 (PDD_FLIPVPORTDATA) pDvdPortFlip);
607 }
608
609 /*
610 * @implemented
611 *
612 * DvpGetVideoPortBandwidth
613 */
614 DWORD
615 WINAPI
616 DvpGetVideoPortBandwidth(LPDDHAL_GETVPORTBANDWIDTHDATA pDvdPortBandWidth)
617 {
618 return NtGdiDvpGetVideoPortBandwidth(pDvdPortBandWidth->lpVideoPort->hDDVideoPort, (PDD_GETVPORTBANDWIDTHDATA)pDvdPortBandWidth);
619 }
620
621 /*
622 * @implemented
623 *
624 * DvpColorControl
625 */
626 DWORD
627 WINAPI
628 DvpColorControl(LPDDHAL_VPORTCOLORDATA pDvdPortColorControl)
629 {
630 return NtGdiDvpColorControl(pDvdPortColorControl->lpVideoPort->hDDVideoPort, (PDD_VPORTCOLORDATA) pDvdPortColorControl);
631 }
632
633 /*
634 * @implemented
635 *
636 * DvpGetVideoSignalStatus
637 */
638 DWORD
639 WINAPI
640 DvpGetVideoSignalStatus(LPDDHAL_GETVPORTSIGNALDATA pDvdPortVideoSignalStatus)
641 {
642 return NtGdiDvpGetVideoSignalStatus(pDvdPortVideoSignalStatus->lpVideoPort->hDDVideoPort, (PDD_GETVPORTSIGNALDATA) pDvdPortVideoSignalStatus);
643 }
644
645 /*
646 * @implemented
647 *
648 * DvpGetVideoPortFlipStatus
649 */
650 DWORD
651 WINAPI
652 DvpGetVideoPortFlipStatus(LPDDHAL_GETVPORTFLIPSTATUSDATA pDvdPortVideoPortFlipStatus)
653 {
654 return NtGdiDvpGetVideoPortFlipStatus(GetDdHandle(pDvdPortVideoPortFlipStatus->lpDD->lpGbl->hDD), (PDD_GETVPORTFLIPSTATUSDATA) pDvdPortVideoPortFlipStatus);
655
656 }
657
658 /*
659 * @implemented
660 *
661 * DvpCanCreateVideoPort
662 */
663 DWORD
664 WINAPI
665 DvpCanCreateVideoPort(LPDDHAL_CANCREATEVPORTDATA pDvdCanCreateVideoPort)
666 {
667 return NtGdiDvpCanCreateVideoPort(GetDdHandle(pDvdCanCreateVideoPort->lpDD->lpGbl->hDD), (PDD_CANCREATEVPORTDATA) pDvdCanCreateVideoPort);
668 }
669 /*
670 * @implemented
671 *
672 * DvpWaitForVideoPortSync
673 */
674 DWORD
675 WINAPI
676 DvpWaitForVideoPortSync(LPDDHAL_WAITFORVPORTSYNCDATA pDvdWaitForVideoPortSync)
677 {
678 return NtGdiDvpWaitForVideoPortSync(pDvdWaitForVideoPortSync->lpVideoPort->hDDVideoPort, (PDD_WAITFORVPORTSYNCDATA) pDvdWaitForVideoPortSync);
679 }
680
681 /*
682 * @implemented
683 *
684 * DvpUpdateVideoPort
685 */
686 DWORD
687 WINAPI
688 DvpUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pDvdUpdateVideoPort)
689 {
690 /*
691 * Windows XP limit to max 10 handles of videoport surface and Vbi
692 * ReactOS doing same to keep compatible, if it is more that 10
693 * videoport surface or vbi the stack will be curpted in windows xp
694 * ReactOS safe guard againts that
695 *
696 */
697
698 HANDLE phSurfaceVideo[10];
699 HANDLE phSurfaceVbi[10];
700
701 if (pDvdUpdateVideoPort->dwFlags != DDRAWI_VPORTSTOP)
702 {
703 DWORD dwNumAutoflip;
704 DWORD dwNumVBIAutoflip;
705
706 /* Take copy of lplpDDSurface for the handle value will be modify in dxg */
707 dwNumAutoflip = pDvdUpdateVideoPort->dwNumAutoflip;
708 if ((dwNumAutoflip == 0) &&
709 (pDvdUpdateVideoPort->lplpDDSurface == 0))
710 {
711 dwNumAutoflip++;
712 }
713
714 if (dwNumAutoflip != 0)
715 {
716 if (dwNumAutoflip>10)
717 {
718 dwNumAutoflip = 10;
719 }
720 memcpy(phSurfaceVideo,pDvdUpdateVideoPort->lplpDDSurface,dwNumAutoflip*sizeof(HANDLE));
721 }
722
723 /* Take copy of lplpDDVBISurface for the handle value will be modify in dxg */
724 dwNumVBIAutoflip = pDvdUpdateVideoPort->dwNumVBIAutoflip;
725 if ( (dwNumVBIAutoflip == 0) &&
726 (pDvdUpdateVideoPort->lplpDDVBISurface == 0) )
727 {
728 dwNumVBIAutoflip++;
729 }
730
731 if (dwNumVBIAutoflip != 0)
732 {
733 if (dwNumVBIAutoflip>10)
734 {
735 dwNumVBIAutoflip = 10;
736 }
737 memcpy(phSurfaceVbi,pDvdUpdateVideoPort->lplpDDVBISurface,dwNumVBIAutoflip*sizeof(HANDLE));
738 }
739 }
740
741 /* Call Win32k */
742 return NtGdiDvpUpdateVideoPort(pDvdUpdateVideoPort->lpVideoPort->hDDVideoPort,phSurfaceVideo,phSurfaceVbi, (PDD_UPDATEVPORTDATA)pDvdUpdateVideoPort);
743 }
744
745 /*
746 * @implemented
747 *
748 * DvpWaitForVideoPortSync
749 */
750 DWORD
751 WINAPI
752 DvpGetVideoPortField(LPDDHAL_FLIPVPORTDATA pDvdGetVideoPortField)
753 {
754 return NtGdiDvpGetVideoPortField(pDvdGetVideoPortField->lpVideoPort->hDDVideoPort, (PDD_GETVPORTFIELDDATA)pDvdGetVideoPortField);
755 }
756
757 /*
758 * @implemented
759 *
760 * DvpWaitForVideoPortSync
761 */
762 DWORD
763 WINAPI
764 DvpGetVideoPortInputFormats(LPDDHAL_GETVPORTINPUTFORMATDATA pDvdGetVideoPortInputFormat)
765 {
766 return NtGdiDvpGetVideoPortInputFormats(pDvdGetVideoPortInputFormat->lpVideoPort->hDDVideoPort, (PDD_GETVPORTINPUTFORMATDATA) pDvdGetVideoPortInputFormat);
767 }
768
769 /*
770 * @implemented
771 *
772 * DvpGetVideoPortLine
773 */
774 DWORD
775 WINAPI
776 DvpGetVideoPortLine(LPDDHAL_GETVPORTLINEDATA pDvdGetVideoPortLine)
777 {
778 return NtGdiDvpGetVideoPortLine(pDvdGetVideoPortLine->lpVideoPort->hDDVideoPort, (PDD_GETVPORTLINEDATA)pDvdGetVideoPortLine);
779 }
780
781 /*
782 * @implemented
783 *
784 * DvpGetVideoPortOutputFormats
785 */
786 DWORD
787 WINAPI
788 DvpGetVideoPortOutputFormats(LPDDHAL_GETVPORTLINEDATA pDvdGetVideoPortOutputFormat)
789 {
790 return NtGdiDvpGetVideoPortLine(pDvdGetVideoPortOutputFormat->lpVideoPort->hDDVideoPort, (PDD_GETVPORTLINEDATA)pDvdGetVideoPortOutputFormat);
791 }
792
793 /*
794 * @implemented
795 *
796 * DvpGetVideoPortConnectInfo
797 */
798 DWORD
799 WINAPI
800 DvpGetVideoPortConnectInfo(LPDDHAL_GETVPORTCONNECTDATA pDvdGetVideoPortInfo)
801 {
802 return NtGdiDvpGetVideoPortConnectInfo( GetDdHandle( pDvdGetVideoPortInfo->lpDD->lpGbl->hDD) , (PDD_GETVPORTCONNECTDATA) pDvdGetVideoPortInfo);
803 }
804
805 /*
806 * @implemented
807 *
808 * DdGetAvailDriverMemory
809 */
810 DWORD
811 WINAPI
812 DdGetAvailDriverMemory(LPDDHAL_GETAVAILDRIVERMEMORYDATA pDdGetAvailDriverMemory)
813 {
814 return NtGdiDdGetAvailDriverMemory(GetDdHandle( pDdGetAvailDriverMemory->lpDD->hDD), (PDD_GETAVAILDRIVERMEMORYDATA) pDdGetAvailDriverMemory);
815 }
816
817 /*
818 * @implemented
819 *
820 * DdAlphaBlt
821 */
822 DWORD
823 WINAPI
824 DdAlphaBlt(LPDDHAL_BLTDATA pDdAlphaBlt)
825 {
826 HANDLE hDDSrcSurface = 0;
827
828 if (pDdAlphaBlt->lpDDSrcSurface != 0)
829 {
830 hDDSrcSurface = (HANDLE) pDdAlphaBlt->lpDDSrcSurface->hDDSurface;
831 }
832
833 return NtGdiDdAlphaBlt((HANDLE)pDdAlphaBlt->lpDDDestSurface->hDDSurface, hDDSrcSurface, (PDD_BLTDATA)&pDdAlphaBlt);
834 }
835
836 /*
837 * @implemented
838 *
839 * DdCreateSurfaceEx
840 */
841 DWORD
842 WINAPI
843 DdCreateSurfaceEx(LPDDHAL_CREATESURFACEEXDATA pDdCreateSurfaceEx)
844 {
845 pDdCreateSurfaceEx->ddRVal = NtGdiDdCreateSurfaceEx( GetDdHandle(pDdCreateSurfaceEx->lpDDLcl->lpGbl->hDD),
846 (HANDLE)pDdCreateSurfaceEx->lpDDSLcl->hDDSurface,
847 pDdCreateSurfaceEx->lpDDSLcl->lpSurfMore->dwSurfaceHandle);
848 return TRUE;
849 }
850
851 /*
852 * @implemented
853 *
854 * DdColorControl
855 */
856 DWORD
857 WINAPI
858 DdColorControl(LPDDHAL_COLORCONTROLDATA pDdColorControl)
859 {
860 return NtGdiDdColorControl( (HANDLE) pDdColorControl->lpDDSurface->hDDSurface, (PDD_COLORCONTROLDATA) &pDdColorControl);
861 }
862
863 /*
864 * @implemented
865 *
866 * DdSetExclusiveMode
867 */
868 DWORD
869 WINAPI
870 DdSetExclusiveMode(LPDDHAL_SETEXCLUSIVEMODEDATA pDdSetExclusiveMode)
871 {
872 return NtGdiDdSetExclusiveMode( GetDdHandle(pDdSetExclusiveMode->lpDD->hDD), (PDD_SETEXCLUSIVEMODEDATA) &pDdSetExclusiveMode);
873 }
874
875 /*
876 * @implemented
877 *
878 * DdFlipToGDISurface
879 */
880 DWORD
881 WINAPI
882 DdFlipToGDISurface(LPDDHAL_FLIPTOGDISURFACEDATA pDdFlipToGDISurface)
883 {
884 return NtGdiDdFlipToGDISurface( GetDdHandle(pDdFlipToGDISurface->lpDD->hDD), (PDD_FLIPTOGDISURFACEDATA) &pDdFlipToGDISurface);
885 }
886
887 /* TODO */
888 DWORD
889 WINAPI
890 DdGetDriverInfo(LPDDHAL_GETDRIVERINFODATA pData)
891 {
892 DDHAL_GETDRIVERINFODATA pDrvInfoData;
893 DWORD retValue = DDHAL_DRIVER_NOTHANDLED;
894 HANDLE hDD;
895
896 /* FIXME add SEH around this functions */
897
898 RtlZeroMemory(&pDrvInfoData, sizeof (DDHAL_GETDRIVERINFODATA));
899 RtlCopyMemory(&pDrvInfoData.guidInfo, &pData->guidInfo, sizeof(GUID));
900
901 hDD = GetDdHandle(pData->dwContext);
902
903 pDrvInfoData.dwSize = sizeof (DDHAL_GETDRIVERINFODATA);
904 pDrvInfoData.ddRVal = DDERR_GENERIC;
905 pDrvInfoData.dwContext = (ULONG_PTR)hDD;
906
907
908 /* Videoport Callbacks check and setup for DirectX/ ReactX */
909 if (IsEqualGUID(&pData->guidInfo, &GUID_VideoPortCallbacks))
910 {
911 DDHAL_DDVIDEOPORTCALLBACKS pDvdPort;
912 DDHAL_DDVIDEOPORTCALLBACKS* pUserDvdPort = (DDHAL_DDVIDEOPORTCALLBACKS *)pData->lpvData;
913
914 /* Clear internal out buffer and set it up*/
915 RtlZeroMemory(&pDvdPort, DDVIDEOPORTCALLBACKSSIZE);
916 pDvdPort.dwSize = DDVIDEOPORTCALLBACKSSIZE;
917
918 /* set up internal buffer */
919 pDrvInfoData.lpvData = (PVOID)&pDvdPort;
920 pDrvInfoData.dwExpectedSize = DDVIDEOPORTCALLBACKSSIZE ;
921
922 /* Call win32k */
923 retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData);
924
925 /* Setup user out buffer and convert kmode callbacks to user mode */
926 pUserDvdPort->dwSize = DDVIDEOPORTCALLBACKSSIZE;
927 pUserDvdPort->dwFlags = pDrvInfoData.dwFlags = 0;
928
929 pUserDvdPort->dwFlags = (pDrvInfoData.dwFlags & ~(DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP |
930 DDHAL_VPORT32_DESTROY | DDHAL_VPORT32_UPDATE | DDHAL_VPORT32_WAITFORSYNC)) |
931 (DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP |
932 DDHAL_VPORT32_DESTROY | DDHAL_VPORT32_UPDATE);
933
934 pData->dwActualSize = DDVIDEOPORTCALLBACKSSIZE;
935 pUserDvdPort->CreateVideoPort = (LPDDHALVPORTCB_CREATEVIDEOPORT) DvpCreateVideoPort;
936 pUserDvdPort->FlipVideoPort = (LPDDHALVPORTCB_FLIP) DvpFlipVideoPort;
937 pUserDvdPort->DestroyVideoPort = (LPDDHALVPORTCB_DESTROYVPORT) DvpDestroyVideoPort;
938 pUserDvdPort->UpdateVideoPort = (LPDDHALVPORTCB_UPDATE) DvpUpdateVideoPort;
939
940 if (pDvdPort.CanCreateVideoPort)
941 {
942 pUserDvdPort->CanCreateVideoPort = (LPDDHALVPORTCB_CANCREATEVIDEOPORT) DvpCanCreateVideoPort;
943 }
944
945 if (pDvdPort.GetVideoPortBandwidth)
946 {
947 pUserDvdPort->GetVideoPortBandwidth = (LPDDHALVPORTCB_GETBANDWIDTH) DvpGetVideoPortBandwidth;
948 }
949
950 if (pDvdPort.GetVideoPortInputFormats)
951 {
952 pUserDvdPort->GetVideoPortInputFormats = (LPDDHALVPORTCB_GETINPUTFORMATS) DvpGetVideoPortInputFormats;
953 }
954
955 if (pDvdPort.GetVideoPortOutputFormats)
956 {
957 pUserDvdPort->GetVideoPortOutputFormats = (LPDDHALVPORTCB_GETOUTPUTFORMATS) DvpGetVideoPortOutputFormats;
958 }
959
960 if (pDvdPort.GetVideoPortField)
961 {
962 pUserDvdPort->GetVideoPortField = (LPDDHALVPORTCB_GETFIELD) DvpGetVideoPortField;
963 }
964
965 if (pDvdPort.GetVideoPortLine)
966 {
967 pUserDvdPort->GetVideoPortLine = (LPDDHALVPORTCB_GETLINE) DvpGetVideoPortLine;
968 }
969
970 if (pDvdPort.GetVideoPortConnectInfo)
971 {
972 pUserDvdPort->GetVideoPortConnectInfo = (LPDDHALVPORTCB_GETVPORTCONNECT) DvpGetVideoPortConnectInfo;
973 }
974
975 if (pDvdPort.GetVideoPortFlipStatus)
976 {
977 pUserDvdPort->GetVideoPortFlipStatus = (LPDDHALVPORTCB_GETFLIPSTATUS) DvpGetVideoPortFlipStatus;
978 }
979
980 if (pDvdPort.WaitForVideoPortSync)
981 {
982 pUserDvdPort->WaitForVideoPortSync = (LPDDHALVPORTCB_WAITFORSYNC) DvpWaitForVideoPortSync;
983 }
984
985 if (pDvdPort.GetVideoSignalStatus)
986 {
987 pUserDvdPort->GetVideoSignalStatus = (LPDDHALVPORTCB_GETSIGNALSTATUS) DvpGetVideoSignalStatus;
988 }
989
990 if (pDvdPort.ColorControl)
991 {
992 pUserDvdPort->ColorControl = (LPDDHALVPORTCB_COLORCONTROL) DvpColorControl;
993 }
994
995 /* Windows XP never repot back the true return value,
996 * it only report back if we have a driver or not
997 * ReactOS keep this behoir to be compatible with
998 * Windows XP
999 */
1000 pData->ddRVal = retValue;
1001 }
1002
1003 /* Color Control Callbacks check and setup for DirectX/ ReactX */
1004 if (IsEqualGUID(&pData->guidInfo, &GUID_ColorControlCallbacks))
1005 {
1006 DDHAL_DDCOLORCONTROLCALLBACKS pColorControl;
1007 DDHAL_DDCOLORCONTROLCALLBACKS* pUserColorControl = (DDHAL_DDCOLORCONTROLCALLBACKS *)pData->lpvData;
1008
1009 /* Clear internal out buffer and set it up*/
1010 RtlZeroMemory(&pColorControl, DDCOLORCONTROLCALLBACKSSIZE);
1011 pColorControl.dwSize = DDCOLORCONTROLCALLBACKSSIZE;
1012
1013 /* set up internal buffer */
1014 pDrvInfoData.lpvData = (PVOID)&pColorControl;
1015 pDrvInfoData.dwExpectedSize = DDCOLORCONTROLCALLBACKSSIZE ;
1016
1017 /* Call win32k */
1018 retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData);
1019
1020 pData->dwActualSize = DDCOLORCONTROLCALLBACKSSIZE;
1021 pData->dwFlags = pDrvInfoData.dwFlags;
1022
1023 pUserColorControl->dwSize = DDCOLORCONTROLCALLBACKSSIZE;
1024 pUserColorControl->dwFlags = pUserColorControl->dwFlags;
1025
1026 if (pColorControl.ColorControl != NULL)
1027 {
1028 pUserColorControl->ColorControl = (LPDDHALCOLORCB_COLORCONTROL) DdColorControl;
1029 }
1030
1031 /* Windows XP never repot back the true return value,
1032 * it only report back if we have a driver or not
1033 * ReactOS keep this behoir to be compatible with
1034 * Windows XP
1035 */
1036 pData->ddRVal = retValue;
1037 }
1038
1039 /* Misc Callbacks check and setup for DirectX/ ReactX */
1040 else if (IsEqualGUID(&pData->guidInfo, &GUID_MiscellaneousCallbacks))
1041 {
1042 DDHAL_DDMISCELLANEOUSCALLBACKS pMisc;
1043 DDHAL_DDMISCELLANEOUSCALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUSCALLBACKS *)pData->lpvData;
1044
1045 /* Clear internal out buffer and set it up*/
1046 RtlZeroMemory(&pMisc, DDMISCELLANEOUSCALLBACKSSIZE);
1047 pMisc.dwSize = DDMISCELLANEOUSCALLBACKSSIZE;
1048
1049 /* set up internal buffer */
1050 pDrvInfoData.lpvData = (PVOID)&pMisc;
1051 pDrvInfoData.dwExpectedSize = DDMISCELLANEOUSCALLBACKSSIZE ;
1052
1053 /* Call win32k */
1054 retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData);
1055
1056 pData->dwActualSize = DDMISCELLANEOUSCALLBACKSSIZE;
1057
1058 /* Only one callbacks are supported */
1059 pUserMisc->dwFlags = pMisc.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY;
1060 pUserMisc->GetAvailDriverMemory = (LPDDHAL_GETAVAILDRIVERMEMORY) DdGetAvailDriverMemory;
1061
1062 /* This callbacks are only for win9x and theirfor it is not longer use in NT or ReactOS
1063 * pUserMisc->UpdateNonLocalHeap;
1064 * pUserMisc->GetHeapAlignment;
1065 * pUserMisc->GetSysmemBltStatus; */
1066
1067 /* Windows XP never repot back the true return value,
1068 * it only report back if we have a driver or not
1069 * ReactOS keep this behoir to be compatible with
1070 * Windows XP
1071 */
1072 pData->ddRVal = retValue;
1073 }
1074
1075 /* Misc 2 Callbacks check and setup for DirectX/ ReactX */
1076 else if (IsEqualGUID(&pData->guidInfo, &GUID_Miscellaneous2Callbacks))
1077 {
1078 DDHAL_DDMISCELLANEOUS2CALLBACKS pMisc;
1079 DDHAL_DDMISCELLANEOUS2CALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUS2CALLBACKS *)pData->lpvData;
1080
1081 /* Clear internal out buffer and set it up*/
1082 RtlZeroMemory(&pMisc, DDMISCELLANEOUS2CALLBACKSSIZE);
1083 pMisc.dwSize = DDMISCELLANEOUS2CALLBACKSSIZE;
1084
1085 /* set up internal buffer */
1086 pDrvInfoData.lpvData = (PVOID)&pMisc;
1087 pDrvInfoData.dwExpectedSize = DDMISCELLANEOUS2CALLBACKSSIZE ;
1088
1089 /* Call win32k */
1090 retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData);
1091
1092 pData->dwActualSize = DDMISCELLANEOUS2CALLBACKSSIZE;
1093
1094 pUserMisc->dwFlags = pMisc.dwFlags;
1095
1096 /* This functions are not documneted in MSDN for this struct, here is directx/reactx alpha blend */
1097 if ( pMisc.Reserved )
1098 {
1099 pUserMisc->Reserved = (LPVOID) DdAlphaBlt;
1100 }
1101
1102 if ( pMisc.CreateSurfaceEx )
1103 {
1104 pUserMisc->CreateSurfaceEx = (LPDDHAL_CREATESURFACEEX) DdCreateSurfaceEx;
1105 }
1106
1107 if ( pMisc.GetDriverState )
1108 {
1109 pUserMisc->GetDriverState = (LPDDHAL_GETDRIVERSTATE) NtGdiDdGetDriverState;
1110 }
1111
1112 /* NOTE : pUserMisc->DestroyDDLocal is outdated and are not beign tuch */
1113
1114 /* Windows XP never repot back the true return value,
1115 * it only report back if we have a driver or not
1116 * ReactOS keep this behoir to be compatible with
1117 * Windows XP
1118 */
1119 pData->ddRVal = retValue;
1120 }
1121
1122 /* NT Callbacks check and setup for DirectX/ ReactX */
1123 else if (IsEqualGUID(&pData->guidInfo, &GUID_NTCallbacks))
1124 {
1125 /* MS does not have DHAL_* version of this callbacks
1126 * so we are force using PDD_* callbacks here
1127 */
1128 DD_NTCALLBACKS pNtKernel;
1129 PDD_NTCALLBACKS pUserNtKernel = (PDD_NTCALLBACKS)pData->lpvData;
1130
1131 /* Clear internal out buffer and set it up*/
1132 RtlZeroMemory(&pNtKernel, sizeof(DD_NTCALLBACKS));
1133 pNtKernel.dwSize = sizeof(DD_NTCALLBACKS);
1134
1135 /* set up internal buffer */
1136 pDrvInfoData.lpvData = (PVOID)&pNtKernel;
1137 pDrvInfoData.dwExpectedSize = sizeof(DD_NTCALLBACKS) ;
1138
1139 /* Call win32k */
1140 retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData);
1141
1142 pData->dwActualSize = sizeof(DD_NTCALLBACKS);
1143
1144 pUserNtKernel->dwSize = sizeof(DD_NTCALLBACKS);
1145 pUserNtKernel->dwFlags = pNtKernel.dwFlags;
1146 pUserNtKernel->FreeDriverMemory = 0;
1147
1148 if (pNtKernel.SetExclusiveMode)
1149 {
1150 pUserNtKernel->SetExclusiveMode = (PDD_SETEXCLUSIVEMODE) DdSetExclusiveMode;
1151 }
1152
1153 if (pNtKernel.FlipToGDISurface)
1154 {
1155 pUserNtKernel->FlipToGDISurface = (PDD_FLIPTOGDISURFACE) DdFlipToGDISurface;
1156 }
1157
1158 /* Windows XP never repot back the true return value,
1159 * it only report back if we have a driver or not
1160 * ReactOS keep this behoir to be compatible with
1161 * Windows XP
1162 */
1163 pData->ddRVal = retValue;
1164 }
1165
1166 /* D3D Callbacks version 2 check and setup for DirectX/ ReactX */
1167 else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks2))
1168 {
1169 // FIXME GUID_D3DCallbacks2
1170 }
1171
1172 /* D3D Callbacks version 3 check and setup for DirectX/ ReactX */
1173 else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks3))
1174 {
1175 // FIXME GUID_D3DCallbacks3
1176 }
1177
1178 /* D3DParseUnknownCommand Callbacks check and setup for DirectX/ ReactX */
1179 else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DParseUnknownCommandCallback))
1180 {
1181 // FIXME GUID_D3DParseUnknownCommandCallback
1182 }
1183
1184 /* MotionComp Callbacks check and setup for DirectX/ ReactX */
1185 else if (IsEqualGUID(&pData->guidInfo, &GUID_MotionCompCallbacks))
1186 {
1187 // FIXME GUID_MotionCompCallbacks
1188 }
1189
1190 /* FIXME VPE2 Callbacks check and setup for DirectX/ ReactX */
1191 //else if (IsEqualGUID(&pData->guidInfo, &GUID_VPE2Callbacks))
1192 //{
1193 // FIXME GUID_VPE2Callbacks
1194 //}
1195 else
1196 {
1197 /* set up internal buffer */
1198 pDrvInfoData.dwExpectedSize = pData->dwExpectedSize;
1199 pDrvInfoData.lpvData = pData->lpvData;
1200
1201 /* We do not cover all callbacks for user mode, they are only cover by kmode */
1202 retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData);
1203
1204 /* Setup return data */
1205 pData->dwActualSize = pDrvInfoData.dwActualSize;
1206 pData->lpvData = pDrvInfoData.lpvData;
1207 /* Windows XP never repot back the true return value,
1208 * it only report back if we have a driver or not
1209 * ReactOS keep this behoir to be compatible with
1210 * Windows XP
1211 */
1212 pData->ddRVal = retValue;
1213 }
1214
1215 return retValue;
1216 }
1217
1218
1219 /*
1220 * @implemented
1221 *
1222 * D3dContextCreate
1223 */
1224 BOOL
1225 WINAPI
1226 D3dContextCreate(LPD3DHAL_CONTEXTCREATEDATA pdcci)
1227 {
1228 HANDLE hSurfZ = NULL;
1229
1230 if (pdcci->lpDDSZLcl)
1231 {
1232 hSurfZ = (HANDLE)pdcci->lpDDSZLcl->hDDSurface;
1233 }
1234
1235 return NtGdiD3dContextCreate(GetDdHandle(pdcci->lpDDLcl->hDD),
1236 (HANDLE)pdcci->lpDDSLcl->hDDSurface,
1237 hSurfZ,
1238 (D3DNTHAL_CONTEXTCREATEI *)pdcci);
1239 }
1240
1241 /*
1242 * @implemented
1243 *
1244 * DdCanCreateD3DBuffer
1245 */
1246 DWORD
1247 WINAPI
1248 DdCanCreateD3DBuffer(LPDDHAL_CANCREATESURFACEDATA CanCreateD3DBuffer)
1249 {
1250 /*
1251 * Note : This functions are basic same, in win32k
1252 * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs
1253 * toghter in win32k at end and retrurn same data, it is still sepreated
1254 * at user mode but in kmode it is not.
1255 */
1256
1257 /* Call win32k */
1258 return NtGdiDdCanCreateD3DBuffer(GetDdHandle(CanCreateD3DBuffer->lpDD->hDD),
1259 (PDD_CANCREATESURFACEDATA)CanCreateD3DBuffer);
1260 }
1261
1262
1263 /*
1264 * @implemented
1265 *
1266 * DdCreateD3DBuffer
1267 */
1268 DWORD
1269 WINAPI
1270 DdCreateD3DBuffer(LPDDHAL_CREATESURFACEDATA pCreateSurface)
1271 {
1272 HANDLE puhSurface = 0;
1273 DDRAWI_DDRAWSURFACE_GBL *pSurfGBL;
1274 DDRAWI_DDRAWSURFACE_LCL *pSurfLcl;
1275 DD_SURFACE_GLOBAL puSurfaceGlobalData;
1276 DD_SURFACE_MORE puSurfaceMoreData;
1277 DD_SURFACE_LOCAL puSurfaceLocalData;
1278 DWORD retValue;
1279
1280 /* Zero all local memory pointer */
1281 RtlZeroMemory(&puSurfaceGlobalData, sizeof(DD_SURFACE_GLOBAL) );
1282 RtlZeroMemory(&puSurfaceMoreData, sizeof(DD_SURFACE_MORE) ) ;
1283 RtlZeroMemory(&puSurfaceLocalData, sizeof(DD_SURFACE_LOCAL) );
1284
1285 pCreateSurface->dwSCnt = 1;
1286 pSurfLcl = pCreateSurface->lplpSList[0];
1287 pSurfGBL = pSurfLcl->lpGbl;
1288
1289 /* Convert DDRAWI_DDRAWSURFACE_GBL to DD_SURFACE_GLOBAL */
1290 puSurfaceGlobalData.wWidth = pSurfGBL->wWidth;
1291 puSurfaceGlobalData.wHeight = pSurfGBL->wHeight;
1292 puSurfaceGlobalData.dwLinearSize = pSurfGBL->dwLinearSize;
1293 puSurfaceGlobalData.fpVidMem = pSurfGBL->fpVidMem;
1294 puSurfaceGlobalData.dwBlockSizeX = pSurfGBL->dwBlockSizeX;
1295 puSurfaceGlobalData.dwBlockSizeY = pSurfGBL->dwBlockSizeY;
1296
1297 /* Convert DDRAWI_DDRAWSURFACE_MORE to DD_SURFACE_MORE */
1298 puSurfaceMoreData.dwSurfaceHandle = pSurfLcl->lpSurfMore->dwSurfaceHandle;
1299 puSurfaceMoreData.ddsCapsEx.dwCaps2 = pSurfLcl->lpSurfMore->ddsCapsEx.dwCaps2;
1300 puSurfaceMoreData.ddsCapsEx.dwCaps3 = pSurfLcl->lpSurfMore->ddsCapsEx.dwCaps3;
1301 puSurfaceMoreData.ddsCapsEx.dwCaps4 = pSurfLcl->lpSurfMore->ddsCapsEx.dwCaps4;
1302
1303 /* Convert DDRAWI_DDRAWSURFACE_LCL to DD_SURFACE_LOCAL */
1304 puSurfaceLocalData.dwFlags = pSurfLcl->dwFlags;
1305 puSurfaceLocalData.ddsCaps.dwCaps = pSurfLcl->ddsCaps.dwCaps;
1306
1307 /* Call win32k */
1308 retValue = NtGdiDdCreateD3DBuffer( GetDdHandle(pCreateSurface->lpDD->hDD),
1309 (HANDLE*)&pSurfLcl->hDDSurface,
1310 pCreateSurface->lpDDSurfaceDesc,
1311 &puSurfaceGlobalData,
1312 &puSurfaceLocalData,
1313 &puSurfaceMoreData,
1314 (DD_CREATESURFACEDATA *) pCreateSurface,
1315 &puhSurface);
1316
1317 /* Setup surface handle if we got one back */
1318 if ( puhSurface != NULL )
1319 {
1320 pCreateSurface->lplpSList[0]->hDDSurface = (ULONG_PTR)puhSurface;
1321 }
1322
1323 /* Convert DD_SURFACE_GLOBAL to DDRAWI_DDRAWSURFACE_GBL */
1324 pSurfGBL->dwLinearSize = puSurfaceGlobalData.dwLinearSize;
1325 pSurfGBL->fpVidMem = puSurfaceGlobalData.fpVidMem;
1326 pSurfGBL->dwBlockSizeX = puSurfaceGlobalData.dwBlockSizeX;
1327 pSurfGBL->dwBlockSizeY = puSurfaceGlobalData.dwBlockSizeY;
1328
1329 return retValue;
1330 }
1331
1332 /*
1333 * @implemented
1334 *
1335 * DdDestroyD3DBuffer
1336 */
1337 DWORD
1338 WINAPI
1339 DdDestroyD3DBuffer(LPDDHAL_DESTROYSURFACEDATA pDestroySurface)
1340 {
1341 DWORD retValue = 0;
1342 if ( pDestroySurface->lpDDSurface->hDDSurface)
1343 {
1344 /* Call win32k */
1345 retValue = NtGdiDdDestroyD3DBuffer((HANDLE)pDestroySurface->lpDDSurface->hDDSurface);
1346 }
1347
1348 return retValue;
1349 }
1350
1351 /*
1352 * @implemented
1353 *
1354 * DdLockD3D
1355 */
1356 DWORD
1357 WINAPI
1358 DdLockD3D(LPDDHAL_LOCKDATA Lock)
1359 {
1360
1361 /* Call win32k */
1362 return NtGdiDdLockD3D((HANDLE)Lock->lpDDSurface->hDDSurface, (PDD_LOCKDATA)Lock);
1363 }
1364
1365 /*
1366 * @implemented
1367 *
1368 * DdUnlockD3D
1369 */
1370 DWORD
1371 WINAPI
1372 DdUnlockD3D(LPDDHAL_UNLOCKDATA Unlock)
1373 {
1374 /* Call win32k */
1375 return NtGdiDdUnlock((HANDLE)Unlock->lpDDSurface->hDDSurface,
1376 (PDD_UNLOCKDATA)Unlock);
1377 }
1378
1379
1380 /* PRIVATE FUNCTIONS *********************************************************/
1381
1382 BOOL
1383 WINAPI
1384 bDDCreateSurface(LPDDRAWI_DDRAWSURFACE_LCL pSurface,
1385 BOOL bComplete)
1386 {
1387 DD_SURFACE_LOCAL SurfaceLocal;
1388 DD_SURFACE_GLOBAL SurfaceGlobal;
1389 DD_SURFACE_MORE SurfaceMore;
1390
1391 /* Zero struct */
1392 RtlZeroMemory(&SurfaceLocal, sizeof(DD_SURFACE_LOCAL));
1393 RtlZeroMemory(&SurfaceGlobal, sizeof(DD_SURFACE_GLOBAL));
1394 RtlZeroMemory(&SurfaceMore, sizeof(DD_SURFACE_MORE));
1395
1396 /* Set up SurfaceLocal struct */
1397 SurfaceLocal.ddsCaps.dwCaps = pSurface->ddsCaps.dwCaps;
1398 SurfaceLocal.dwFlags = pSurface->dwFlags;
1399
1400 /* Set up SurfaceMore struct */
1401 RtlMoveMemory(&SurfaceMore.ddsCapsEx,
1402 &pSurface->ddckCKDestBlt,
1403 sizeof(DDSCAPSEX));
1404 SurfaceMore.dwSurfaceHandle = (DWORD)pSurface->dbnOverlayNode.object_int->lpVtbl;
1405
1406 /* Set up SurfaceGlobal struct */
1407 SurfaceGlobal.fpVidMem = pSurface->lpGbl->fpVidMem;
1408 SurfaceGlobal.dwLinearSize = pSurface->lpGbl->dwLinearSize;
1409 SurfaceGlobal.wHeight = pSurface->lpGbl->wHeight;
1410 SurfaceGlobal.wWidth = pSurface->lpGbl->wWidth;
1411
1412 /* Check if we have a pixel format */
1413 if (pSurface->dwFlags & DDSD_PIXELFORMAT)
1414 {
1415 /* Use global one */
1416 SurfaceGlobal.ddpfSurface = pSurface->lpGbl->lpDD->vmiData.ddpfDisplay;
1417 SurfaceGlobal.ddpfSurface.dwSize = sizeof(DDPIXELFORMAT);
1418 }
1419 else
1420 {
1421 /* Use local one */
1422 SurfaceGlobal.ddpfSurface = pSurface->lpGbl->lpDD->vmiData.ddpfDisplay;
1423 }
1424
1425 /* Create the object */
1426 pSurface->hDDSurface = (DWORD)NtGdiDdCreateSurfaceObject(GetDdHandle(pSurface->lpGbl->lpDD->hDD),
1427 (HANDLE)pSurface->hDDSurface,
1428 &SurfaceLocal,
1429 &SurfaceMore,
1430 &SurfaceGlobal,
1431 bComplete);
1432
1433 /* Return status */
1434 if (pSurface->hDDSurface) return TRUE;
1435 return FALSE;
1436 }
1437
1438 /* PUBLIC FUNCTIONS **********************************************************/
1439
1440 /*
1441 * @implemented
1442 *
1443 * GDIEntry 1
1444 */
1445 BOOL
1446 WINAPI
1447 DdCreateDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
1448 HDC hdc)
1449 {
1450 BOOL Return = FALSE;
1451
1452 /* Check if the global hDC (hdc == 0) is being used */
1453 if (!hdc)
1454 {
1455 /* We'll only allow this if the global object doesn't exist yet */
1456 if (!ghDirectDraw)
1457 {
1458 /* Create the DC */
1459 if ((hdc = CreateDCW(L"Display", NULL, NULL, NULL)))
1460 {
1461 /* Create the DDraw Object */
1462 ghDirectDraw = NtGdiDdCreateDirectDrawObject(hdc);
1463
1464 /* Delete our DC */
1465 DeleteDC(hdc);
1466 }
1467 }
1468
1469 /* If we created the object, or had one ...*/
1470 if (ghDirectDraw)
1471 {
1472 /* Increase count and set success */
1473 gcDirectDraw++;
1474 Return = TRUE;
1475 }
1476
1477 /* Zero the handle */
1478 pDirectDrawGlobal->hDD = 0;
1479 }
1480 else
1481 {
1482 /* Using the per-process object, so create it */
1483 pDirectDrawGlobal->hDD = (ULONG_PTR)NtGdiDdCreateDirectDrawObject(hdc);
1484
1485 /* Set the return value */
1486 Return = pDirectDrawGlobal->hDD ? TRUE : FALSE;
1487 }
1488
1489 /* Return to caller */
1490 return Return;
1491 }
1492
1493 /*
1494 * @implemented
1495 *
1496 * GDIEntry 2
1497 */
1498 BOOL
1499 WINAPI
1500 DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
1501 LPDDHALINFO pHalInfo,
1502 LPDDHAL_DDCALLBACKS pDDCallbacks,
1503 LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks,
1504 LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks,
1505 LPD3DHAL_CALLBACKS pD3dCallbacks,
1506 LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData,
1507 LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks,
1508 LPDDSURFACEDESC pD3dTextureFormats,
1509 LPDWORD pdwFourCC,
1510 LPVIDMEM pvmList)
1511 {
1512 PVIDEOMEMORY VidMemList = NULL;
1513 DD_HALINFO HalInfo;
1514 D3DNTHAL_CALLBACKS D3dCallbacks;
1515 D3DNTHAL_GLOBALDRIVERDATA D3dDriverData;
1516 DD_D3DBUFCALLBACKS D3dBufferCallbacks;
1517 DWORD CallbackFlags[3];
1518 DWORD dwNumHeaps=0, FourCCs=0;
1519 DWORD Flags;
1520 BOOL retVal = TRUE;
1521
1522 /* Clear the structures */
1523 RtlZeroMemory(&HalInfo, sizeof(DD_HALINFO));
1524 RtlZeroMemory(&D3dCallbacks, sizeof(D3DNTHAL_CALLBACKS));
1525 RtlZeroMemory(&D3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
1526 RtlZeroMemory(&D3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS));
1527 RtlZeroMemory(CallbackFlags, sizeof(DWORD)*3);
1528
1529 /* Note : XP always alloc 24*sizeof(VIDEOMEMORY) of pvmlist so we change it to it */
1530 if ( (pvmList != NULL) &&
1531 (pHalInfo->vmiData.dwNumHeaps != 0) )
1532 {
1533 VidMemList = (PVIDEOMEMORY) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(VIDEOMEMORY) * 24 ) * pHalInfo->vmiData.dwNumHeaps);
1534 }
1535
1536
1537 /* Do the query */
1538 if (!NtGdiDdQueryDirectDrawObject(GetDdHandle(pDirectDrawGlobal->hDD),
1539 &HalInfo,
1540 CallbackFlags,
1541 &D3dCallbacks,
1542 &D3dDriverData,
1543 &D3dBufferCallbacks,
1544 pD3dTextureFormats,
1545 &dwNumHeaps,
1546 VidMemList,
1547 &FourCCs,
1548 pdwFourCC))
1549 {
1550 /* We failed, free the memory and return */
1551 retVal = FALSE;
1552 goto cleanup;
1553 }
1554
1555 /* Clear the incoming pointer */
1556 RtlZeroMemory(pHalInfo, sizeof(DDHALINFO));
1557
1558 /* Convert all the data */
1559 pHalInfo->dwSize = sizeof(DDHALINFO);
1560 pHalInfo->lpDDCallbacks = pDDCallbacks;
1561 pHalInfo->lpDDSurfaceCallbacks = pDDSurfaceCallbacks;
1562 pHalInfo->lpDDPaletteCallbacks = pDDPaletteCallbacks;
1563
1564 /* Check for NT5+ D3D Data */
1565 if ( (D3dCallbacks.dwSize != 0) &&
1566 (D3dDriverData.dwSize != 0) )
1567 {
1568 /* Write these down */
1569 pHalInfo->lpD3DGlobalDriverData = (ULONG_PTR)pD3dDriverData;
1570 pHalInfo->lpD3DHALCallbacks = (ULONG_PTR)pD3dCallbacks;
1571
1572 /* Check for Buffer Callbacks */
1573 if (D3dBufferCallbacks.dwSize)
1574 {
1575 /* Write this one too */
1576 pHalInfo->lpDDExeBufCallbacks = pD3dBufferCallbacks;
1577 }
1578 }
1579
1580 /* Continue converting the rest */
1581 pHalInfo->vmiData.dwFlags = HalInfo.vmiData.dwFlags;
1582 pHalInfo->vmiData.dwDisplayWidth = HalInfo.vmiData.dwDisplayWidth;
1583 pHalInfo->vmiData.dwDisplayHeight = HalInfo.vmiData.dwDisplayHeight;
1584 pHalInfo->vmiData.lDisplayPitch = HalInfo.vmiData.lDisplayPitch;
1585 pHalInfo->vmiData.fpPrimary = 0;
1586
1587 RtlCopyMemory( &pHalInfo->vmiData.ddpfDisplay,
1588 &HalInfo.vmiData.ddpfDisplay,
1589 sizeof(DDPIXELFORMAT));
1590
1591 pHalInfo->vmiData.dwOffscreenAlign = HalInfo.vmiData.dwOffscreenAlign;
1592 pHalInfo->vmiData.dwOverlayAlign = HalInfo.vmiData.dwOverlayAlign;
1593 pHalInfo->vmiData.dwTextureAlign = HalInfo.vmiData.dwTextureAlign;
1594 pHalInfo->vmiData.dwZBufferAlign = HalInfo.vmiData.dwZBufferAlign;
1595 pHalInfo->vmiData.dwAlphaAlign = HalInfo.vmiData.dwAlphaAlign;
1596
1597 pHalInfo->vmiData.dwNumHeaps = dwNumHeaps;
1598 pHalInfo->vmiData.pvmList = pvmList;
1599
1600 RtlCopyMemory( &pHalInfo->ddCaps,
1601 &HalInfo.ddCaps,
1602 sizeof(DDCORECAPS ));
1603
1604 pHalInfo->ddCaps.dwNumFourCCCodes = FourCCs;
1605 pHalInfo->lpdwFourCC = pdwFourCC;
1606
1607 /* always force rope 0x1000 for hal it mean only source copy is supported */
1608 pHalInfo->ddCaps.dwRops[6] = 0x1000;
1609
1610 /* Set the HAL flags what ReactX got from the driver
1611 * Windows XP force setting DDHALINFO_GETDRIVERINFOSET if the driver does not set it
1612 * and ReactX doing same to keep compatible with drivers, but the driver are
1613 * force support DdGetDriverInfo acoriding MSDN but it seam some driver do not set
1614 * this flag even it is being supported. that is mean. It is small hack to keep
1615 * bad driver working, that trust this is always being setting by it self at end
1616 */
1617 pHalInfo->dwFlags = (HalInfo.dwFlags & ~DDHALINFO_GETDRIVERINFOSET) | DDHALINFO_GETDRIVERINFOSET;
1618 pHalInfo->GetDriverInfo = (LPDDHAL_GETDRIVERINFO) DdGetDriverInfo;
1619
1620 /* Now check if we got any DD callbacks */
1621 if (pDDCallbacks)
1622 {
1623 /* Zero the structure */
1624 RtlZeroMemory(pDDCallbacks, sizeof(DDHAL_DDCALLBACKS));
1625 pDDCallbacks->dwSize = sizeof(DDHAL_DDCALLBACKS);
1626
1627 /* Set the flags for this structure
1628 * Windows XP force setting DDHAL_CB32_CREATESURFACE if the driver does not set it
1629 * and ReactX doing same to keep compatible with drivers, but the driver are
1630 * force support pDDCallbacks acoriding MSDN but it seam some driver do not set
1631 * this flag even it is being supported. that is mean. It is small hack to keep
1632 * bad driver working, that trust this is always being setting by it self at end
1633 */
1634 Flags = (CallbackFlags[0] & ~DDHAL_CB32_CREATESURFACE) | DDHAL_CB32_CREATESURFACE;
1635 pDDCallbacks->dwFlags = Flags;
1636
1637 /* Write the always-on functions */
1638 pDDCallbacks->CreateSurface = DdCreateSurface;
1639
1640 /* Now write the pointers, if applicable */
1641 if (Flags & DDHAL_CB32_WAITFORVERTICALBLANK)
1642 {
1643 pDDCallbacks->WaitForVerticalBlank = DdWaitForVerticalBlank;
1644 }
1645 if (Flags & DDHAL_CB32_CANCREATESURFACE)
1646 {
1647 pDDCallbacks->CanCreateSurface = DdCanCreateSurface;
1648 }
1649 if (Flags & DDHAL_CB32_GETSCANLINE)
1650 {
1651 pDDCallbacks->GetScanLine = DdGetScanLine;
1652 }
1653 }
1654
1655 /* Check for DD Surface Callbacks */
1656 if (pDDSurfaceCallbacks)
1657 {
1658 /* Zero the structures */
1659 RtlZeroMemory(pDDSurfaceCallbacks, sizeof(DDHAL_DDSURFACECALLBACKS));
1660 pDDSurfaceCallbacks->dwSize = sizeof(DDHAL_DDSURFACECALLBACKS);
1661
1662 /* Set the flags for this structure
1663 * Windows XP force setting DDHAL_SURFCB32_LOCK, DDHAL_SURFCB32_UNLOCK,
1664 * DDHAL_SURFCB32_SETCOLORKEY, DDHAL_SURFCB32_DESTROYSURFACE if the driver
1665 * does not set it and ReactX doing same to keep compatible with drivers,
1666 * but the driver are force support pDDSurfaceCallbacks acoriding MSDN but it seam
1667 * some driver do not set this flag even it is being supported. that is mean.
1668 * It is small hack to keep bad driver working, that trust this is always being
1669 * setting by it self at end
1670 */
1671
1672 Flags = (CallbackFlags[1] & ~(DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK |
1673 DDHAL_SURFCB32_SETCOLORKEY | DDHAL_SURFCB32_DESTROYSURFACE)) |
1674 (DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK |
1675 DDHAL_SURFCB32_SETCOLORKEY | DDHAL_SURFCB32_DESTROYSURFACE);
1676
1677 pDDSurfaceCallbacks->dwFlags = Flags;
1678
1679 /* Write the always-on functions */
1680 pDDSurfaceCallbacks->Lock = DdLock;
1681 pDDSurfaceCallbacks->Unlock = DdUnlock;
1682 pDDSurfaceCallbacks->SetColorKey = DdSetColorKey;
1683 pDDSurfaceCallbacks->DestroySurface = DdDestroySurface;
1684
1685 /* Write the optional ones */
1686 if (Flags & DDHAL_SURFCB32_FLIP)
1687 {
1688 pDDSurfaceCallbacks->Flip = DdFlip;
1689 }
1690 if (Flags & DDHAL_SURFCB32_BLT)
1691 {
1692 pDDSurfaceCallbacks->Blt = DdBlt;
1693 }
1694 if (Flags & DDHAL_SURFCB32_GETBLTSTATUS)
1695 {
1696 pDDSurfaceCallbacks->GetBltStatus = DdGetBltStatus;
1697 }
1698 if (Flags & DDHAL_SURFCB32_GETFLIPSTATUS)
1699 {
1700 pDDSurfaceCallbacks->GetFlipStatus = DdGetFlipStatus;
1701 }
1702 if (Flags & DDHAL_SURFCB32_UPDATEOVERLAY)
1703 {
1704 pDDSurfaceCallbacks->UpdateOverlay = DdUpdateOverlay;
1705 }
1706 if (Flags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
1707 {
1708 pDDSurfaceCallbacks->SetOverlayPosition = DdSetOverlayPosition;
1709 }
1710 if (Flags & DDHAL_SURFCB32_ADDATTACHEDSURFACE)
1711 {
1712 pDDSurfaceCallbacks->AddAttachedSurface = DdAddAttachedSurface;
1713 }
1714 }
1715
1716 /* Check for DD Palette Callbacks, This interface are dead for user mode,
1717 * only what it can support are being report back.
1718 */
1719 if (pDDPaletteCallbacks)
1720 {
1721 /* Zero the struct */
1722 RtlZeroMemory(pDDPaletteCallbacks, sizeof(DDHAL_DDPALETTECALLBACKS));
1723
1724 /* Write the header */
1725 pDDPaletteCallbacks->dwSize = sizeof(DDHAL_DDPALETTECALLBACKS);
1726 pDDPaletteCallbacks->dwFlags = CallbackFlags[2];
1727 }
1728
1729 if (pD3dCallbacks)
1730 {
1731 /* Zero the struct */
1732 RtlZeroMemory(pD3dCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
1733
1734 /* Check if we have one */
1735 if (D3dCallbacks.dwSize)
1736 {
1737 /* Write the header */
1738 pD3dCallbacks->dwSize = sizeof(DDHAL_DDEXEBUFCALLBACKS);
1739
1740 /* Now check for each callback */
1741 if (D3dCallbacks.ContextCreate)
1742 {
1743 pD3dCallbacks->ContextCreate = (LPD3DHAL_CONTEXTCREATECB) D3dContextCreate;
1744 }
1745 if (D3dCallbacks.ContextDestroy)
1746 {
1747 pD3dCallbacks->ContextDestroy = (LPD3DHAL_CONTEXTDESTROYCB) NtGdiD3dContextDestroy;
1748 }
1749 if (D3dCallbacks.ContextDestroyAll)
1750 {
1751 pD3dCallbacks->ContextDestroyAll = (LPD3DHAL_CONTEXTDESTROYALLCB) NtGdiD3dContextDestroyAll;
1752 }
1753 }
1754 }
1755
1756 /* Check for D3D Driver Data */
1757 if (pD3dDriverData)
1758 {
1759 /* Copy the struct */
1760 RtlMoveMemory(pD3dDriverData, &D3dDriverData, sizeof(D3DHAL_GLOBALDRIVERDATA));
1761
1762 /* Write the pointer to the texture formats */
1763 pD3dDriverData->lpTextureFormats = pD3dTextureFormats;
1764 }
1765
1766 /* Check for D3D Buffer Callbacks */
1767 if (pD3dBufferCallbacks)
1768 {
1769 /* Zero the struct */
1770 RtlZeroMemory(pD3dBufferCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
1771
1772 if ( D3dBufferCallbacks.dwSize)
1773 {
1774 pD3dBufferCallbacks->dwSize = D3dBufferCallbacks.dwSize;
1775
1776 pD3dBufferCallbacks->dwFlags = D3dBufferCallbacks.dwFlags;
1777 if ( D3dBufferCallbacks.CanCreateD3DBuffer)
1778 {
1779 pD3dBufferCallbacks->CanCreateExecuteBuffer = (LPDDHALEXEBUFCB_CANCREATEEXEBUF)DdCanCreateD3DBuffer;
1780 }
1781
1782 if ( D3dBufferCallbacks.CanCreateD3DBuffer)
1783 {
1784 pD3dBufferCallbacks->CreateExecuteBuffer = (LPDDHALEXEBUFCB_CREATEEXEBUF) DdCreateD3DBuffer;
1785 }
1786
1787 if ( D3dBufferCallbacks.DestroyD3DBuffer )
1788 {
1789 pD3dBufferCallbacks->DestroyExecuteBuffer = (LPDDHALEXEBUFCB_DESTROYEXEBUF) DdDestroyD3DBuffer;
1790 }
1791
1792 if ( D3dBufferCallbacks.LockD3DBuffer )
1793 {
1794 pD3dBufferCallbacks->LockExecuteBuffer = (LPDDHALEXEBUFCB_LOCKEXEBUF) DdLockD3D;
1795 }
1796
1797 if ( D3dBufferCallbacks.UnlockD3DBuffer )
1798 {
1799 pD3dBufferCallbacks->UnlockExecuteBuffer = (LPDDHALEXEBUFCB_UNLOCKEXEBUF) DdUnlockD3D;
1800 }
1801
1802 }
1803 }
1804
1805 /* FIXME VidMemList */
1806
1807 cleanup:
1808 if (VidMemList)
1809 {
1810 HeapFree(GetProcessHeap(), 0, VidMemList);
1811 }
1812
1813 return retVal;
1814 }
1815
1816 /*
1817 * @implemented
1818 *
1819 * GDIEntry 3
1820 */
1821 BOOL
1822 WINAPI
1823 DdDeleteDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal)
1824 {
1825 BOOL Return = FALSE;
1826
1827 /* If this is the global object */
1828 if(pDirectDrawGlobal->hDD)
1829 {
1830 /* Free it */
1831 Return = NtGdiDdDeleteDirectDrawObject((HANDLE)pDirectDrawGlobal->hDD);
1832 if (Return == TRUE)
1833 {
1834 pDirectDrawGlobal->hDD = 0;
1835 }
1836 }
1837 else if (ghDirectDraw)
1838 {
1839 /* Always success here */
1840 Return = TRUE;
1841
1842 /* Make sure this is the last instance */
1843 if (!(--gcDirectDraw))
1844 {
1845 /* Delete the object */
1846 Return = NtGdiDdDeleteDirectDrawObject(ghDirectDraw);
1847 if (Return == TRUE)
1848 {
1849 ghDirectDraw = 0;
1850 }
1851 }
1852 }
1853
1854 /* Return */
1855 return Return;
1856 }
1857
1858 /*
1859 * @implemented
1860 *
1861 * GDIEntry 4
1862 */
1863 BOOL
1864 WINAPI
1865 DdCreateSurfaceObject( LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
1866 BOOL bPrimarySurface)
1867 {
1868 return bDDCreateSurface(pSurfaceLocal, TRUE);
1869 }
1870
1871
1872 /*
1873 * @implemented
1874 *
1875 * GDIEntry 5
1876 */
1877 BOOL
1878 WINAPI
1879 DdDeleteSurfaceObject(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal)
1880 {
1881 BOOL Return = FALSE;
1882
1883 /* Make sure there is one */
1884 if (pSurfaceLocal->hDDSurface)
1885 {
1886 /* Delete it */
1887 Return = NtGdiDdDeleteSurfaceObject((HANDLE)pSurfaceLocal->hDDSurface);
1888 pSurfaceLocal->hDDSurface = 0;
1889 }
1890
1891 return Return;
1892 }
1893
1894 /*
1895 * @implemented
1896 *
1897 * GDIEntry 6
1898 */
1899 BOOL
1900 WINAPI
1901 DdResetVisrgn(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
1902 HWND hWnd)
1903 {
1904 /* Call win32k directly */
1905 return NtGdiDdResetVisrgn((HANDLE) pSurfaceLocal->hDDSurface, hWnd);
1906 }
1907
1908 /*
1909 * @implemented
1910 *
1911 * GDIEntry 7
1912 */
1913 HDC
1914 WINAPI
1915 DdGetDC(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
1916 LPPALETTEENTRY pColorTable)
1917 {
1918 /* Call win32k directly */
1919 return NtGdiDdGetDC(pColorTable, (HANDLE) pSurfaceLocal->hDDSurface);
1920 }
1921
1922 /*
1923 * @implemented
1924 *
1925 * GDIEntry 8
1926 */
1927 BOOL
1928 WINAPI
1929 DdReleaseDC(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal)
1930 {
1931 /* Call win32k directly */
1932 return NtGdiDdReleaseDC((HANDLE) pSurfaceLocal->hDDSurface);
1933 }
1934
1935 /*
1936 * @unimplemented
1937 * GDIEntry 9
1938 */
1939 HBITMAP
1940 WINAPI
1941 DdCreateDIBSection(HDC hdc,
1942 CONST BITMAPINFO *pbmi,
1943 UINT iUsage,
1944 VOID **ppvBits,
1945 HANDLE hSectionApp,
1946 DWORD dwOffset)
1947 {
1948 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1949 return 0;
1950 }
1951
1952 /*
1953 * @implemented
1954 *
1955 * GDIEntry 10
1956 */
1957 BOOL
1958 WINAPI
1959 DdReenableDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
1960 BOOL *pbNewMode)
1961 {
1962 /* Call win32k directly */
1963 return NtGdiDdReenableDirectDrawObject(GetDdHandle(pDirectDrawGlobal->hDD),
1964 pbNewMode);
1965 }
1966
1967
1968 /*
1969 * @implemented
1970 *
1971 * GDIEntry 11
1972 */
1973 BOOL
1974 WINAPI
1975 DdAttachSurface( LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom,
1976 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo)
1977 {
1978 /* Create Surface if it does not exits one */
1979 if (!pSurfaceFrom->hDDSurface)
1980 {
1981 if (!bDDCreateSurface(pSurfaceFrom, FALSE))
1982 {
1983 return FALSE;
1984 }
1985 }
1986
1987 /* Create Surface if it does not exits one */
1988 if (!pSurfaceTo->hDDSurface)
1989 {
1990 if (!bDDCreateSurface(pSurfaceTo, FALSE))
1991 {
1992 return FALSE;
1993 }
1994 }
1995
1996 /* Call win32k */
1997 return NtGdiDdAttachSurface((HANDLE)pSurfaceFrom->hDDSurface,
1998 (HANDLE)pSurfaceTo->hDDSurface);
1999 }
2000
2001 /*
2002 * @implemented
2003 *
2004 * GDIEntry 12
2005 */
2006 VOID
2007 WINAPI
2008 DdUnattachSurface(LPDDRAWI_DDRAWSURFACE_LCL pSurface,
2009 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceAttached)
2010 {
2011 /* Call win32k */
2012 NtGdiDdUnattachSurface((HANDLE)pSurface->hDDSurface,
2013 (HANDLE)pSurfaceAttached->hDDSurface);
2014 }
2015
2016 /*
2017 * @implemented
2018 *
2019 * GDIEntry 13
2020 */
2021 ULONG
2022 WINAPI
2023 DdQueryDisplaySettingsUniqueness()
2024 {
2025 return GdiSharedHandleTable->flDeviceUniq;
2026 }
2027
2028 /*
2029 * @implemented
2030 *
2031 * GDIEntry 14
2032 */
2033 HANDLE
2034 WINAPI
2035 DdGetDxHandle(LPDDRAWI_DIRECTDRAW_LCL pDDraw,
2036 LPDDRAWI_DDRAWSURFACE_LCL pSurface,
2037 BOOL bRelease)
2038 {
2039 HANDLE hDD = NULL;
2040 HANDLE hSurface = (HANDLE)pSurface->hDDSurface;
2041
2042 /* Check if we already have a surface */
2043 if (!pSurface)
2044 {
2045 /* We don't have one, use the DirectDraw Object handle instead */
2046 hSurface = NULL;
2047 hDD = GetDdHandle(pDDraw->lpGbl->hDD);
2048 }
2049
2050 /* Call the API */
2051 return (HANDLE)NtGdiDdGetDxHandle(hDD, hSurface, bRelease);
2052 }
2053
2054 /*
2055 * @implemented
2056 *
2057 * GDIEntry 15
2058 */
2059 BOOL
2060 WINAPI
2061 DdSetGammaRamp(LPDDRAWI_DIRECTDRAW_LCL pDDraw,
2062 HDC hdc,
2063 LPVOID lpGammaRamp)
2064 {
2065 /* Call win32k directly */
2066 return NtGdiDdSetGammaRamp(GetDdHandle(pDDraw->lpGbl->hDD),
2067 hdc,
2068 lpGammaRamp);
2069 }
2070
2071
2072
2073
2074
A free Windows-compatible Operating System