VBoxDispDDrawVHWA.cpp@ 102295

Last change on this file since 102295 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.3 KB

Line
1	/* $Id: VBoxDispDDrawVHWA.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VBox XPDM Display driver, DirectDraw callbacks VHWA related
4	*/
5
6	/*
7	* Copyright (C) 2011-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#include "VBoxDisp.h"
29	#include "VBoxDispDDraw.h"
30	#include <iprt/asm.h>
31
32	/** @callback_method_impl{FNVBOXVHWACMDCOMPLETION} */
33	static DECLCALLBACK(void)
34	VBoxDispVHWASurfBltCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST pCmd, void pvContext)
35	{
36	RT_NOREF(pvContext);
37	VBOXVHWACMD_SURF_BLT RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
38	PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->SrcGuestSurfInfo;
39	PVBOXVHWASURFDESC pDestDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->DstGuestSurfInfo;
40
41	ASMAtomicDecU32(&pSrcDesc->cPendingBltsSrc);
42	ASMAtomicDecU32(&pDestDesc->cPendingBltsDst);
43
44	VBoxDispVHWACommandRelease(pDev, pCmd);
45	}
46
47	/** @callback_method_impl{FNVBOXVHWACMDCOMPLETION} */
48	static DECLCALLBACK(void)
49	VBoxDispVHWASurfFlipCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST pCmd, void pvContext)
50	{
51	RT_NOREF(pvContext);
52	VBOXVHWACMD_SURF_FLIP RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP);
53	PVBOXVHWASURFDESC pCurrDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->CurrGuestSurfInfo;
54	PVBOXVHWASURFDESC pTargDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->TargGuestSurfInfo;
55
56	ASMAtomicDecU32(&pCurrDesc->cPendingFlipsCurr);
57	ASMAtomicDecU32(&pTargDesc->cPendingFlipsTarg);
58
59	VBoxDispVHWACommandRelease(pDev, pCmd);
60	}
61
62	#define VBOXVHWA_CAP(_pdev, _cap) ((_pdev)->vhwa.caps & (_cap))
63	#define ROP_INDEX(_rop) ((BYTE)((_rop)>>16))
64	#define SET_SUPPORT_ROP(_aRops, _rop) _aRops[ROP_INDEX(_rop)/32] \|= 1L << ((DWORD)(ROP_INDEX(_rop)%32))
65
66	int VBoxDispVHWAUpdateDDHalInfo(PVBOXDISPDEV pDev, DD_HALINFO *pHalInfo)
67	{
68	if (!VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT) && !VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY))
69	{
70	return VERR_NOT_SUPPORTED;
71	}
72
73	pHalInfo->ddCaps.dwCaps \|= VBoxDispVHWAToDDCAPS(pDev->vhwa.caps);
74	if (VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT))
75	{
76	/* we only support simple dst=src copy
77	* Note: search "ternary raster operations" on msdn for more info
78	*/
79	SET_SUPPORT_ROP(pHalInfo->ddCaps.dwRops, SRCCOPY);
80	}
81
82	pHalInfo->ddCaps.ddsCaps.dwCaps \|= VBoxDispVHWAToDDSCAPS(pDev->vhwa.surfaceCaps);
83	pHalInfo->ddCaps.dwCaps2 \|= VBoxDispVHWAToDDCAPS2(pDev->vhwa.caps2);
84
85	if (VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT) && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLTSTRETCH))
86	{
87	pHalInfo->ddCaps.dwFXCaps \|= DDFXCAPS_BLTSTRETCHX \| DDFXCAPS_BLTSTRETCHY
88	\| DDFXCAPS_BLTSTRETCHXN \| DDFXCAPS_BLTSTRETCHYN
89	\| DDFXCAPS_BLTSHRINKX \| DDFXCAPS_BLTSHRINKY
90	\| DDFXCAPS_BLTSHRINKXN \| DDFXCAPS_BLTSHRINKYN
91	\| DDFXCAPS_BLTARITHSTRETCHY;
92	}
93
94	if (VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY) && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAYSTRETCH))
95	{
96	pHalInfo->ddCaps.dwFXCaps \|= DDFXCAPS_OVERLAYSTRETCHX \| DDFXCAPS_OVERLAYSTRETCHY
97	\| DDFXCAPS_OVERLAYSTRETCHXN \| DDFXCAPS_OVERLAYSTRETCHYN
98	\| DDFXCAPS_OVERLAYSHRINKX \| DDFXCAPS_OVERLAYSHRINKY
99	\| DDFXCAPS_OVERLAYSHRINKXN \| DDFXCAPS_OVERLAYSHRINKYN
100	\| DDFXCAPS_OVERLAYARITHSTRETCHY;
101	}
102
103	pHalInfo->ddCaps.dwCKeyCaps = VBoxDispVHWAToDDCKEYCAPS(pDev->vhwa.colorKeyCaps);
104
105	if (VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY))
106	{
107	pHalInfo->ddCaps.dwMaxVisibleOverlays = pDev->vhwa.numOverlays;
108	pHalInfo->ddCaps.dwCurrVisibleOverlays = 0;
109	pHalInfo->ddCaps.dwMinOverlayStretch = 1;
110	pHalInfo->ddCaps.dwMaxOverlayStretch = 32000;
111	}
112
113	return VINF_SUCCESS;
114	}
115
116	/*
117	* DirectDraw callbacks.
118	*/
119
120	#define IF_NOT_SUPPORTED(_guid) \
121	if (IsEqualIID(&lpData->guidInfo, &(_guid))) \
122	{ \
123	LOG((#_guid)); \
124	}
125
126	DWORD APIENTRY VBoxDispDDGetDriverInfo(DD_GETDRIVERINFODATA *lpData)
127	{
128	LOGF_ENTER();
129
130	lpData->ddRVal = DDERR_CURRENTLYNOTAVAIL;
131
132	if (IsEqualIID(&lpData->guidInfo, &GUID_NTPrivateDriverCaps))
133	{
134	LOG(("GUID_NTPrivateDriverCaps"));
135
136	DD_NTPRIVATEDRIVERCAPS caps;
137	memset(&caps, 0, sizeof(caps));
138	caps.dwSize = sizeof(DD_NTPRIVATEDRIVERCAPS);
139	caps.dwPrivateCaps = DDHAL_PRIVATECAP_NOTIFYPRIMARYCREATION;
140
141	lpData->dwActualSize = sizeof(DD_NTPRIVATEDRIVERCAPS);
142	lpData->ddRVal = DD_OK;
143	memcpy(lpData->lpvData, &caps, min(lpData->dwExpectedSize, sizeof(DD_NTPRIVATEDRIVERCAPS)));
144	}
145	else IF_NOT_SUPPORTED(GUID_NTCallbacks)
146	else IF_NOT_SUPPORTED(GUID_D3DCallbacks2)
147	else IF_NOT_SUPPORTED(GUID_D3DCallbacks3)
148	else IF_NOT_SUPPORTED(GUID_D3DExtendedCaps)
149	else IF_NOT_SUPPORTED(GUID_ZPixelFormats)
150	else IF_NOT_SUPPORTED(GUID_D3DParseUnknownCommandCallback)
151	else IF_NOT_SUPPORTED(GUID_Miscellaneous2Callbacks)
152	else IF_NOT_SUPPORTED(GUID_UpdateNonLocalHeap)
153	else IF_NOT_SUPPORTED(GUID_GetHeapAlignment)
154	else IF_NOT_SUPPORTED(GUID_DDStereoMode)
155	else IF_NOT_SUPPORTED(GUID_NonLocalVidMemCaps)
156	else IF_NOT_SUPPORTED(GUID_KernelCaps)
157	else IF_NOT_SUPPORTED(GUID_KernelCallbacks)
158	else IF_NOT_SUPPORTED(GUID_MotionCompCallbacks)
159	else IF_NOT_SUPPORTED(GUID_VideoPortCallbacks)
160	else IF_NOT_SUPPORTED(GUID_ColorControlCallbacks)
161	else IF_NOT_SUPPORTED(GUID_VideoPortCaps)
162	else IF_NOT_SUPPORTED(GUID_DDMoreSurfaceCaps)
163	else
164	{
165	LOG(("unknown guid"));
166	}
167
168
169	LOGF_LEAVE();
170	return DDHAL_DRIVER_HANDLED;
171	}
172
173	DWORD APIENTRY VBoxDispDDSetColorKey(PDD_SETCOLORKEYDATA lpSetColorKey)
174	{
175	PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpSetColorKey->lpDD->dhpdev;
176	LOGF_ENTER();
177
178	DD_SURFACE_LOCAL *pSurf = lpSetColorKey->lpDDSurface;
179	PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)pSurf->lpGbl->dwReserved1;
180
181	lpSetColorKey->ddRVal = DD_OK;
182
183	if (pDesc)
184	{
185	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd =
186	VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_COLORKEY_SET, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET));
187	if (pCmd)
188	{
189	VBOXVHWACMD_SURF_COLORKEY_SET RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET);
190
191	pBody->u.in.offSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSurf->lpGbl->fpVidMem);
192	pBody->u.in.hSurf = pDesc->hHostHandle;
193	pBody->u.in.flags = VBoxDispVHWAFromDDCKEYs(lpSetColorKey->dwFlags);
194	VBoxDispVHWAFromDDCOLORKEY(&pBody->u.in.CKey, &lpSetColorKey->ckNew);
195
196	VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
197	}
198	else
199	{
200	WARN(("VBoxDispVHWACommandCreate failed!"));
201	lpSetColorKey->ddRVal = DDERR_GENERIC;
202	}
203	}
204	else
205	{
206	WARN(("!pDesc"));
207	lpSetColorKey->ddRVal = DDERR_GENERIC;
208	}
209
210	LOGF_LEAVE();
211	return DDHAL_DRIVER_HANDLED;
212	}
213
214	DWORD APIENTRY VBoxDispDDAddAttachedSurface(PDD_ADDATTACHEDSURFACEDATA lpAddAttachedSurface)
215	{
216	LOGF_ENTER();
217
218	lpAddAttachedSurface->ddRVal = DD_OK;
219
220	LOGF_LEAVE();
221	return DDHAL_DRIVER_HANDLED;
222	}
223
224	DWORD APIENTRY VBoxDispDDBlt(PDD_BLTDATA lpBlt)
225	{
226	PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpBlt->lpDD->dhpdev;
227	LOGF_ENTER();
228
229	DD_SURFACE_LOCAL *pSrcSurf = lpBlt->lpDDSrcSurface;
230	DD_SURFACE_LOCAL *pDstSurf = lpBlt->lpDDDestSurface;
231	PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC) pSrcSurf->lpGbl->dwReserved1;
232	PVBOXVHWASURFDESC pDstDesc = (PVBOXVHWASURFDESC) pDstSurf->lpGbl->dwReserved1;
233
234	if (pSrcDesc && pDstDesc)
235	{
236	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd;
237
238	pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_BLT, sizeof(VBOXVHWACMD_SURF_BLT));
239	if (pCmd)
240	{
241	VBOXVHWACMD_SURF_BLT RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
242
243	pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem);
244	pBody->u.in.offDstSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pDstSurf->lpGbl->fpVidMem);
245
246	pBody->u.in.hDstSurf = pDstDesc->hHostHandle;
247	VBoxDispVHWAFromRECTL(&pBody->u.in.dstRect, &lpBlt->rDest);
248	pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
249	VBoxDispVHWAFromRECTL(&pBody->u.in.srcRect, &lpBlt->rSrc);
250	pBody->DstGuestSurfInfo = (uintptr_t)pDstDesc;
251	pBody->SrcGuestSurfInfo = (uintptr_t)pSrcDesc;
252
253	pBody->u.in.flags = VBoxDispVHWAFromDDBLTs(lpBlt->dwFlags);
254	VBoxDispVHWAFromDDBLTFX(&pBody->u.in.desc, &lpBlt->bltFX);
255
256	ASMAtomicIncU32(&pSrcDesc->cPendingBltsSrc);
257	ASMAtomicIncU32(&pDstDesc->cPendingBltsDst);
258
259	VBoxDispVHWARegionAdd(&pDstDesc->NonupdatedMemRegion, &lpBlt->rDest);
260	VBoxDispVHWARegionTrySubstitute(&pDstDesc->UpdatedMemRegion, &lpBlt->rDest);
261
262	if(pSrcDesc->UpdatedMemRegion.bValid)
263	{
264	pBody->u.in.xUpdatedSrcMemValid = 1;
265	VBoxDispVHWAFromRECTL(&pBody->u.in.xUpdatedSrcMemRect, &pSrcDesc->UpdatedMemRegion.Rect);
266	VBoxDispVHWARegionClear(&pSrcDesc->UpdatedMemRegion);
267	}
268
269	VBoxDispVHWACommandSubmitAsynch(pDev, pCmd, VBoxDispVHWASurfBltCompletion, NULL);
270
271	lpBlt->ddRVal = DD_OK;
272	}
273	else
274	{
275	WARN(("VBoxDispVHWACommandCreate failed!"));
276	lpBlt->ddRVal = DDERR_GENERIC;
277	}
278	}
279	else
280	{
281	WARN(("!(pSrcDesc && pDstDesc)"));
282	lpBlt->ddRVal = DDERR_GENERIC;
283	}
284
285	LOGF_LEAVE();
286	return DDHAL_DRIVER_HANDLED;
287	}
288
289	DWORD APIENTRY VBoxDispDDFlip(PDD_FLIPDATA lpFlip)
290	{
291	PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpFlip->lpDD->dhpdev;
292	LOGF_ENTER();
293
294	DD_SURFACE_LOCAL *pCurrSurf = lpFlip->lpSurfCurr;
295	DD_SURFACE_LOCAL *pTargSurf = lpFlip->lpSurfTarg;
296	PVBOXVHWASURFDESC pCurrDesc = (PVBOXVHWASURFDESC) pCurrSurf->lpGbl->dwReserved1;
297	PVBOXVHWASURFDESC pTargDesc = (PVBOXVHWASURFDESC) pTargSurf->lpGbl->dwReserved1;
298
299	if (pCurrDesc && pTargDesc)
300	{
301	if(ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg) \|\| ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
302	\|\| ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg) \|\| ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
303	{
304	VBoxDispVHWACommandCheckHostCmds(pDev);
305
306	if(ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg) \|\| ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
307	\|\| ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg) \|\| ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
308	{
309	lpFlip->ddRVal = DDERR_WASSTILLDRAWING;
310	return DDHAL_DRIVER_HANDLED;
311	}
312	}
313
314	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd
315	= VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_FLIP, sizeof(VBOXVHWACMD_SURF_FLIP));
316	if (pCmd)
317	{
318	VBOXVHWACMD_SURF_FLIP RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP);
319
320	pBody->u.in.offCurrSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pCurrSurf->lpGbl->fpVidMem);
321	pBody->u.in.offTargSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pTargSurf->lpGbl->fpVidMem);
322
323	pBody->u.in.hTargSurf = pTargDesc->hHostHandle;
324	pBody->u.in.hCurrSurf = pCurrDesc->hHostHandle;
325	pBody->TargGuestSurfInfo = (uintptr_t)pTargDesc;
326	pBody->CurrGuestSurfInfo = (uintptr_t)pCurrDesc;
327
328	pTargDesc->bVisible = pCurrDesc->bVisible;
329	pCurrDesc->bVisible = false;
330
331
332	ASMAtomicIncU32(&pCurrDesc->cPendingFlipsCurr);
333	ASMAtomicIncU32(&pTargDesc->cPendingFlipsTarg);
334	#ifdef DEBUG
335	ASMAtomicIncU32(&pCurrDesc->cFlipsCurr);
336	ASMAtomicIncU32(&pTargDesc->cFlipsTarg);
337	#endif
338
339	if(pTargDesc->UpdatedMemRegion.bValid)
340	{
341	pBody->u.in.xUpdatedTargMemValid = 1;
342	VBoxDispVHWAFromRECTL(&pBody->u.in.xUpdatedTargMemRect, &pTargDesc->UpdatedMemRegion.Rect);
343	VBoxDispVHWARegionClear(&pTargDesc->UpdatedMemRegion);
344	}
345
346	VBoxDispVHWACommandSubmitAsynch(pDev, pCmd, VBoxDispVHWASurfFlipCompletion, NULL);
347
348	lpFlip->ddRVal = DD_OK;
349	}
350	else
351	{
352	WARN(("VBoxDispVHWACommandCreate failed!"));
353	lpFlip->ddRVal = DDERR_GENERIC;
354	}
355	}
356	else
357	{
358	WARN(("!(pCurrDesc && pTargDesc)"));
359	lpFlip->ddRVal = DDERR_GENERIC;
360	}
361
362	LOGF_LEAVE();
363	return DDHAL_DRIVER_HANDLED;
364	}
365
366	DWORD APIENTRY VBoxDispDDGetBltStatus(PDD_GETBLTSTATUSDATA lpGetBltStatus)
367	{
368	PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpGetBltStatus->lpDD->dhpdev;
369	PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpGetBltStatus->lpDDSurface->lpGbl->dwReserved1;
370	LOGF_ENTER();
371
372	if(lpGetBltStatus->dwFlags == DDGBS_CANBLT)
373	{
374	lpGetBltStatus->ddRVal = DD_OK;
375	}
376	else /* DDGBS_ISBLTDONE */
377	{
378	if (pDesc)
379	{
380	if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc) \|\| ASMAtomicUoReadU32(&pDesc->cPendingBltsDst))
381	{
382	VBoxDispVHWACommandCheckHostCmds(pDev);
383
384	if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc) \|\| ASMAtomicUoReadU32(&pDesc->cPendingBltsDst))
385	{
386	lpGetBltStatus->ddRVal = DDERR_WASSTILLDRAWING;
387	}
388	else
389	{
390	lpGetBltStatus->ddRVal = DD_OK;
391	}
392	}
393	else
394	{
395	lpGetBltStatus->ddRVal = DD_OK;
396	}
397	}
398	else
399	{
400	WARN(("!pDesc"));
401	lpGetBltStatus->ddRVal = DDERR_GENERIC;
402	}
403	}
404
405
406	LOGF_LEAVE();
407	return DDHAL_DRIVER_HANDLED;
408	}
409
410	DWORD APIENTRY VBoxDispDDGetFlipStatus(PDD_GETFLIPSTATUSDATA lpGetFlipStatus)
411	{
412	PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpGetFlipStatus->lpDD->dhpdev;
413	PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpGetFlipStatus->lpDDSurface->lpGbl->dwReserved1;
414	LOGF_ENTER();
415
416	/can't flip is there's a flip pending, so result is same for DDGFS_CANFLIP/DDGFS_ISFLIPDONE /
417
418	if (pDesc)
419	{
420	if(ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg) \|\| ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr))
421	{
422	VBoxDispVHWACommandCheckHostCmds(pDev);
423
424	if(ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg) \|\| ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr))
425	{
426	lpGetFlipStatus->ddRVal = DDERR_WASSTILLDRAWING;
427	}
428	else
429	{
430	lpGetFlipStatus->ddRVal = DD_OK;
431	}
432	}
433	else
434	{
435	lpGetFlipStatus->ddRVal = DD_OK;
436	}
437	}
438	else
439	{
440	WARN(("!pDesc"));
441	lpGetFlipStatus->ddRVal = DDERR_GENERIC;
442	}
443
444	LOGF_LEAVE();
445	return DDHAL_DRIVER_HANDLED;
446	}
447
448	DWORD APIENTRY VBoxDispDDSetOverlayPosition(PDD_SETOVERLAYPOSITIONDATA lpSetOverlayPosition)
449	{
450	PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpSetOverlayPosition->lpDD->dhpdev;
451	DD_SURFACE_LOCAL *pSrcSurf = lpSetOverlayPosition->lpDDSrcSurface;
452	DD_SURFACE_LOCAL *pDstSurf = lpSetOverlayPosition->lpDDDestSurface;
453	PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC) pSrcSurf->lpGbl->dwReserved1;
454	PVBOXVHWASURFDESC pDstDesc = (PVBOXVHWASURFDESC) pDstSurf->lpGbl->dwReserved1;
455
456	LOGF_ENTER();
457
458	if (pSrcDesc && pDstDesc)
459	{
460	if (!pSrcDesc->bVisible)
461	{
462	WARN(("!pSrcDesc->bVisible"));
463	lpSetOverlayPosition->ddRVal = DDERR_GENERIC;
464	return DDHAL_DRIVER_HANDLED;
465	}
466
467	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd
468	= VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION));
469	if (pCmd)
470	{
471	VBOXVHWACMD_SURF_OVERLAY_SETPOSITION RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION);
472
473	pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem);
474	pBody->u.in.offDstSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pDstSurf->lpGbl->fpVidMem);
475
476	pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
477	pBody->u.in.hDstSurf = pDstDesc->hHostHandle;
478
479	pBody->u.in.xPos = lpSetOverlayPosition->lXPos;
480	pBody->u.in.yPos = lpSetOverlayPosition->lYPos;
481
482	VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
483
484	lpSetOverlayPosition->ddRVal = DD_OK;
485	}
486	else
487	{
488	WARN(("VBoxDispVHWACommandCreate failed!"));
489	lpSetOverlayPosition->ddRVal = DDERR_GENERIC;
490	}
491	}
492	else
493	{
494	WARN(("!(pSrcDesc && pDstDesc)"));
495	lpSetOverlayPosition->ddRVal = DDERR_GENERIC;
496	}
497
498	LOGF_LEAVE();
499	return DDHAL_DRIVER_HANDLED;
500	}
501
502	DWORD APIENTRY VBoxDispDDUpdateOverlay(PDD_UPDATEOVERLAYDATA lpUpdateOverlay)
503	{
504	PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpUpdateOverlay->lpDD->dhpdev;
505	DD_SURFACE_LOCAL* pSrcSurf = lpUpdateOverlay->lpDDSrcSurface;
506	DD_SURFACE_LOCAL* pDstSurf = lpUpdateOverlay->lpDDDestSurface;
507	PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC) pSrcSurf->lpGbl->dwReserved1;
508
509	LOGF_ENTER();
510
511	if (pSrcDesc)
512	{
513	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd
514	= VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE));
515	if (pCmd)
516	{
517	VBOXVHWACMD_SURF_OVERLAY_UPDATE RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);
518
519	pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem);
520
521	pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
522
523	VBoxDispVHWAFromRECTL(&pBody->u.in.dstRect, &lpUpdateOverlay->rDest);
524	VBoxDispVHWAFromRECTL(&pBody->u.in.srcRect, &lpUpdateOverlay->rSrc);
525
526	pBody->u.in.flags = VBoxDispVHWAFromDDOVERs(lpUpdateOverlay->dwFlags);
527	VBoxDispVHWAFromDDOVERLAYFX(&pBody->u.in.desc, &lpUpdateOverlay->overlayFX);
528
529	if (lpUpdateOverlay->dwFlags & DDOVER_HIDE)
530	{
531	pSrcDesc->bVisible = false;
532	}
533	else if(lpUpdateOverlay->dwFlags & DDOVER_SHOW)
534	{
535	pSrcDesc->bVisible = true;
536	if(pSrcDesc->UpdatedMemRegion.bValid)
537	{
538	pBody->u.in.xFlags = VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT;
539	VBoxDispVHWAFromRECTL(&pBody->u.in.xUpdatedSrcMemRect, &pSrcDesc->UpdatedMemRegion.Rect);
540	VBoxDispVHWARegionClear(&pSrcDesc->UpdatedMemRegion);
541	}
542	}
543
544	if(pDstSurf)
545	{
546	PVBOXVHWASURFDESC pDstDesc = (PVBOXVHWASURFDESC) pDstSurf->lpGbl->dwReserved1;
547
548	if (!pDstDesc)
549	{
550	WARN(("!pDstDesc"));
551	lpUpdateOverlay->ddRVal = DDERR_GENERIC;
552	return DDHAL_DRIVER_HANDLED;
553	}
554
555	pBody->u.in.hDstSurf = pDstDesc->hHostHandle;
556	pBody->u.in.offDstSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pDstSurf->lpGbl->fpVidMem);
557	}
558
559	VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
560
561	lpUpdateOverlay->ddRVal = DD_OK;
562	}
563	else
564	{
565	WARN(("VBoxDispVHWACommandCreate failed!"));
566	lpUpdateOverlay->ddRVal = DDERR_GENERIC;
567	}
568	}
569	else
570	{
571	WARN(("!pSrcDesc"));
572	lpUpdateOverlay->ddRVal = DDERR_GENERIC;
573	}
574
575	LOGF_LEAVE();
576	return DDHAL_DRIVER_HANDLED;
577	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDrawVHWA.cpp@ 102295

Download in other formats: