projects / reactos.git / blob
? search:


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