VBoxDispDbg.h@ 69498

Last change on this file since 69498 was 69498, checked in by vboxsync, 7 years ago
backed out r118835 as it incorrectly updated the 'This file is based on' file headers.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.0 KB

Line
1	/* $Id: VBoxDispDbg.h 69498 2017-10-28 15:07:25Z vboxsync $ */
2	/** @file
3	* VBoxVideo Display D3D User mode dll
4	*/
5
6	/*
7	* Copyright (C) 2011-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef ___VBoxDispDbg_h__
19	#define ___VBoxDispDbg_h__
20
21	#define VBOX_VIDEO_LOG_NAME "VBoxD3D"
22	#define VBOX_VIDEO_LOG_LOGGER vboxVDbgInternalLogLogger
23	#define VBOX_VIDEO_LOGREL_LOGGER vboxVDbgInternalLogRelLogger
24	#define VBOX_VIDEO_LOGFLOW_LOGGER vboxVDbgInternalLogFlowLogger
25	#define VBOX_VIDEO_LOG_FN_FMT "%s"
26
27	#include "../../common/VBoxVideoLog.h"
28
29	#ifdef DEBUG
30	/* debugging configuration flags */
31
32	/* generic debugging facilities & extra data checks */
33	# define VBOXWDDMDISP_DEBUG
34	# if defined(DEBUG_misha) \|\| defined(DEBUG_leo)
35	/* for some reason when debugging with VirtualKD, user-mode DbgPrint's are discarded
36	* the workaround so far is to pass the log info to the kernel driver and DbgPrint'ed from there,
37	* which is enabled by this define */
38	//# define VBOXWDDMDISP_DEBUG_PRINTDRV
39	/* use OutputDebugString */
40	//# define VBOXWDDMDISP_DEBUG_PRINT
41	/* adds vectored exception handler to be able to catch non-debug UM exceptions in kernel debugger */
42	//# define VBOXWDDMDISP_DEBUG_VEHANDLER
43	/* disable shared resource creation with wine */
44	//# define VBOXWDDMDISP_DEBUG_NOSHARED
45
46	//# define VBOXWDDMDISP_DEBUG_PRINT_SHARED_CREATE
47
48	//# define VBOXWDDMDISP_DEBUG_TIMER
49	# endif
50
51	# ifndef IN_VBOXCRHGSMI
52	/* debug config vars */
53	extern DWORD g_VBoxVDbgFDumpSetTexture;
54	extern DWORD g_VBoxVDbgFDumpDrawPrim;
55	extern DWORD g_VBoxVDbgFDumpTexBlt;
56	extern DWORD g_VBoxVDbgFDumpBlt;
57	extern DWORD g_VBoxVDbgFDumpRtSynch;
58	extern DWORD g_VBoxVDbgFDumpFlush;
59	extern DWORD g_VBoxVDbgFDumpShared;
60	extern DWORD g_VBoxVDbgFDumpLock;
61	extern DWORD g_VBoxVDbgFDumpUnlock;
62	extern DWORD g_VBoxVDbgFDumpPresentEnter;
63	extern DWORD g_VBoxVDbgFDumpPresentLeave;
64	extern DWORD g_VBoxVDbgFDumpScSync;
65
66	extern DWORD g_VBoxVDbgFBreakShared;
67	extern DWORD g_VBoxVDbgFBreakDdi;
68
69	extern DWORD g_VBoxVDbgFCheckSysMemSync;
70	extern DWORD g_VBoxVDbgFCheckBlt;
71	extern DWORD g_VBoxVDbgFCheckTexBlt;
72	extern DWORD g_VBoxVDbgFCheckScSync;
73
74	extern DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate;
75
76	extern DWORD g_VBoxVDbgCfgMaxDirectRts;
77	extern DWORD g_VBoxVDbgCfgForceDummyDevCreate;
78
79	extern struct VBOXWDDMDISP_DEVICE *g_VBoxVDbgInternalDevice;
80	extern struct VBOXWDDMDISP_RESOURCE *g_VBoxVDbgInternalRc;
81
82	extern DWORD g_VBoxVDbgCfgCreateSwapchainOnDdiOnce;
83
84	# endif /* #ifndef IN_VBOXCRHGSMI */
85	#endif
86
87	#if defined(VBOXWDDMDISP_DEBUG) \|\| defined(VBOX_WDDMDISP_WITH_PROFILE)
88	/* log enable flags */
89	extern DWORD g_VBoxVDbgFLogRel;
90	extern DWORD g_VBoxVDbgFLog;
91	extern DWORD g_VBoxVDbgFLogFlow;
92	#endif
93
94	#ifdef VBOXWDDMDISP_DEBUG_VEHANDLER
95	void vboxVDbgVEHandlerRegister();
96	void vboxVDbgVEHandlerUnregister();
97	#endif
98
99	#if defined(LOG_TO_BACKDOOR_DRV) \|\| defined(VBOXWDDMDISP_DEBUG_PRINTDRV)
100	# define DbgPrintDrv(_m) do { vboxDispLogDrvF _m; } while (0)
101	# define DbgPrintDrvRel(_m) do { vboxDispLogDrvF _m; } while (0)
102	# define DbgPrintDrvFlow(_m) do { vboxDispLogDrvF _m; } while (0)
103	#else
104	# define DbgPrintDrv(_m) do { } while (0)
105	# define DbgPrintDrvRel(_m) do { } while (0)
106	# define DbgPrintDrvFlow(_m) do { } while (0)
107	#endif
108
109	#ifdef VBOXWDDMDISP_DEBUG_PRINT
110	# define DbgPrintUsr(_m) do { vboxDispLogDbgPrintF _m; } while (0)
111	# define DbgPrintUsrRel(_m) do { vboxDispLogDbgPrintF _m; } while (0)
112	# define DbgPrintUsrFlow(_m) do { vboxDispLogDbgPrintF _m; } while (0)
113	#else
114	# define DbgPrintUsr(_m) do { } while (0)
115	# define DbgPrintUsrRel(_m) do { } while (0)
116	# define DbgPrintUsrFlow(_m) do { } while (0)
117	#endif
118
119	#if defined(VBOXWDDMDISP_DEBUG) \|\| defined(VBOX_WDDMDISP_WITH_PROFILE)
120	#define vboxVDbgInternalLog(_p) if (g_VBoxVDbgFLog) { _p }
121	#define vboxVDbgInternalLogFlow(_p) if (g_VBoxVDbgFLogFlow) { _p }
122	#define vboxVDbgInternalLogRel(_p) if (g_VBoxVDbgFLogRel) { _p }
123	#else
124	#define vboxVDbgInternalLog(_p) do {} while (0)
125	#define vboxVDbgInternalLogFlow(_p) do {} while (0)
126	#define vboxVDbgInternalLogRel(_p) do { _p } while (0)
127	#endif
128
129	/* @todo: remove these from the code and from here */
130	#define vboxVDbgPrint(_m) LOG_EXACT(_m)
131	#define vboxVDbgPrintF(_m) LOGF_EXACT(_m)
132	#define vboxVDbgPrintR(_m) LOGREL_EXACT(_m)
133
134	#define vboxVDbgInternalLogLogger(_m) do { \
135	vboxVDbgInternalLog( \
136	Log(_m); \
137	DbgPrintUsr(_m); \
138	DbgPrintDrv(_m); \
139	); \
140	} while (0)
141
142	#define vboxVDbgInternalLogFlowLogger(_m) do { \
143	vboxVDbgInternalLogFlow( \
144	LogFlow(_m); \
145	DbgPrintUsrFlow(_m); \
146	DbgPrintDrvFlow(_m); \
147	); \
148	} while (0)
149
150	#define vboxVDbgInternalLogRelLogger(_m) do { \
151	vboxVDbgInternalLogRel( \
152	LogRel(_m); \
153	DbgPrintUsrRel(_m); \
154	DbgPrintDrvRel(_m); \
155	); \
156	} while (0)
157
158	#if defined(VBOXWDDMDISP_DEBUG) \|\| defined(VBOX_WDDMDISP_WITH_PROFILE)
159	extern DWORD g_VBoxVDbgPid;
160	extern LONG g_VBoxVDbgFIsDwm;
161	#define VBOXVDBG_CHECK_EXE(_pszName) (vboxVDbgDoCheckExe(_pszName))
162	#define VBOXVDBG_IS_DWM() (!!(g_VBoxVDbgFIsDwm >=0 ? g_VBoxVDbgFIsDwm : (g_VBoxVDbgFIsDwm = VBOXVDBG_CHECK_EXE("dwm.exe"))))
163	BOOL vboxVDbgDoCheckExe(const char * pszName);
164	#endif
165	#if defined(VBOXWDDMDISP_DEBUG) \|\| defined(LOG_TO_BACKDOOR_DRV)
166
167	#define VBOXVDBG_STRCASE(_t) \
168	case _t: return #_t;
169	#define VBOXVDBG_STRCASE_UNKNOWN() \
170	default: Assert(0); return "Unknown";
171
172	DECLINLINE(const char*) vboxDispLogD3DRcType(D3DRESOURCETYPE enmType)
173	{
174	switch (enmType)
175	{
176	VBOXVDBG_STRCASE(D3DRTYPE_SURFACE);
177	VBOXVDBG_STRCASE(D3DRTYPE_VOLUME);
178	VBOXVDBG_STRCASE(D3DRTYPE_TEXTURE);
179	VBOXVDBG_STRCASE(D3DRTYPE_VOLUMETEXTURE);
180	VBOXVDBG_STRCASE(D3DRTYPE_CUBETEXTURE);
181	VBOXVDBG_STRCASE(D3DRTYPE_VERTEXBUFFER);
182	VBOXVDBG_STRCASE(D3DRTYPE_INDEXBUFFER);
183	VBOXVDBG_STRCASE_UNKNOWN();
184	}
185	}
186
187	#include <VBoxDispMpLogger.h>
188
189	VBOXDISPMPLOGGER_DECL(void) VBoxDispMpLoggerDumpD3DCAPS9(struct _D3DCAPS9 *pCaps);
190
191	void vboxDispLogDrvF(char * szString, ...);
192
193	# define vboxDispDumpD3DCAPS9(_pCaps) do { VBoxDispMpLoggerDumpD3DCAPS9(_pCaps); } while (0)
194	#else
195	# define vboxDispDumpD3DCAPS9(_pCaps) do { } while (0)
196	#endif
197
198	#ifdef VBOXWDDMDISP_DEBUG
199
200	void vboxDispLogDbgPrintF(char * szString, ...);
201
202	# ifndef IN_VBOXCRHGSMI
203	typedef struct VBOXWDDMDISP_ALLOCATION *PVBOXWDDMDISP_ALLOCATION;
204	typedef struct VBOXWDDMDISP_RESOURCE *PVBOXWDDMDISP_RESOURCE;
205
206	#define VBOXVDBG_DUMP_TYPEF_FLOW 0x00000001
207	#define VBOXVDBG_DUMP_TYPEF_CONTENTS 0x00000002
208	#define VBOXVDBG_DUMP_TYPEF_DONT_BREAK_ON_CONTENTS 0x00000004
209	#define VBOXVDBG_DUMP_TYPEF_BREAK_ON_FLOW 0x00000008
210	#define VBOXVDBG_DUMP_TYPEF_SHARED_ONLY 0x00000010
211
212	#define VBOXVDBG_DUMP_FLAGS_IS_SETANY(_fFlags, _Value) (((_fFlags) & (_Value)) != 0)
213	#define VBOXVDBG_DUMP_FLAGS_IS_SET(_fFlags, _Value) (((_fFlags) & (_Value)) == (_Value))
214	#define VBOXVDBG_DUMP_FLAGS_IS_CLEARED(_fFlags, _Value) (((_fFlags) & (_Value)) == 0)
215	#define VBOXVDBG_DUMP_FLAGS_CLEAR(_fFlags, _Value) ((_fFlags) & (~(_Value)))
216	#define VBOXVDBG_DUMP_FLAGS_SET(_fFlags, _Value) ((_fFlags) \| (_Value))
217
218	#define VBOXVDBG_DUMP_TYPE_ENABLED(_fFlags) (VBOXVDBG_DUMP_FLAGS_IS_SETANY(_fFlags, VBOXVDBG_DUMP_TYPEF_FLOW \| VBOXVDBG_DUMP_TYPEF_CONTENTS))
219	#define VBOXVDBG_DUMP_TYPE_ENABLED_FOR_INFO(_pInfo, _fFlags) ( \
220	VBOXVDBG_DUMP_TYPE_ENABLED(_fFlags) \
221	&& ( \
222	VBOXVDBG_DUMP_FLAGS_IS_CLEARED(_fFlags, VBOXVDBG_DUMP_TYPEF_SHARED_ONLY) \
223	\|\| ((_pInfo)->pAlloc && (_pInfo)->pAlloc->pRc->aAllocations[0].hSharedHandle) \
224	))
225
226	#define VBOXVDBG_DUMP_TYPE_FLOW_ONLY(_fFlags) (VBOXVDBG_DUMP_FLAGS_IS_SET(_fFlags, VBOXVDBG_DUMP_TYPEF_FLOW) \
227	&& VBOXVDBG_DUMP_FLAGS_IS_CLEARED(_fFlags, VBOXVDBG_DUMP_TYPEF_CONTENTS))
228	#define VBOXVDBG_DUMP_TYPE_CONTENTS(_fFlags) (VBOXVDBG_DUMP_FLAGS_IS_SET(_fFlags, VBOXVDBG_DUMP_TYPEF_CONTENTS))
229	#define VBOXVDBG_DUMP_TYPE_GET_FLOW_ONLY(_fFlags) ( \
230	VBOXVDBG_DUMP_FLAGS_SET( \
231	VBOXVDBG_DUMP_FLAGS_CLEAR(_fFlags, VBOXVDBG_DUMP_TYPEF_CONTENTS), \
232	VBOXVDBG_DUMP_TYPEF_FLOW) \
233	)
234
235	VOID vboxVDbgDoDumpAllocRect(const char * pPrefix, PVBOXWDDMDISP_ALLOCATION pAlloc, RECT pRect, const char pSuffix, DWORD fFlags);
236	VOID vboxVDbgDoDumpRcRect(const char * pPrefix, PVBOXWDDMDISP_ALLOCATION pAlloc, IDirect3DResource9 pD3DRc, RECT pRect, const char * pSuffix, DWORD fFlags);
237	VOID vboxVDbgDoDumpLockUnlockSurfTex(const char * pPrefix, const VBOXWDDMDISP_ALLOCATION pAlloc, const char pSuffix, DWORD fFlags);
238	VOID vboxVDbgDoDumpRt(const char * pPrefix, struct VBOXWDDMDISP_DEVICE pDevice, const char pSuffix, DWORD fFlags);
239	VOID vboxVDbgDoDumpBb(const char * pPrefix, IDirect3DSwapChain9 pSwapchainIf, const char pSuffix, DWORD fFlags);
240	VOID vboxVDbgDoDumpFb(const char * pPrefix, IDirect3DSwapChain9 pSwapchainIf, const char pSuffix, DWORD fFlags);
241	VOID vboxVDbgDoDumpSamplers(const char * pPrefix, struct VBOXWDDMDISP_DEVICE pDevice, const char pSuffix, DWORD fFlags);
242
243	void vboxVDbgDoPrintRect(const char * pPrefix, const RECT pRect, const char pSuffix);
244	void vboxVDbgDoPrintAlloc(const char * pPrefix, const VBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const char pSuffix);
245
246	VOID vboxVDbgDoDumpLockSurfTex(const char * pPrefix, const D3DDDIARG_LOCK* pData, const char * pSuffix, DWORD fFlags);
247	VOID vboxVDbgDoDumpUnlockSurfTex(const char * pPrefix, const D3DDDIARG_UNLOCK* pData, const char * pSuffix, DWORD fFlags);
248
249	BOOL vboxVDbgDoCheckRectsMatch(const VBOXWDDMDISP_RESOURCE *pDstRc, uint32_t iDstAlloc,
250	const VBOXWDDMDISP_RESOURCE *pSrcRc, uint32_t iSrcAlloc,
251	const RECT *pDstRect,
252	const RECT *pSrcRect,
253	BOOL fBreakOnMismatch);
254
255	VOID vboxVDbgDoPrintLopLastCmd(const char* pszDesc);
256
257	HRESULT vboxVDbgTimerStart(HANDLE hTimerQueue, HANDLE *phTimer, DWORD msTimeout);
258	HRESULT vboxVDbgTimerStop(HANDLE hTimerQueue, HANDLE hTimer);
259
260	#define VBOXVDBG_IS_PID(_pid) ((_pid) == (g_VBoxVDbgPid ? g_VBoxVDbgPid : (g_VBoxVDbgPid = GetCurrentProcessId())))
261	#define VBOXVDBG_IS_DUMP_ALLOWED_PID(_pid) (((int)(_pid)) > 0 ? VBOXVDBG_IS_PID(_pid) : !VBOXVDBG_IS_PID(-((int)(_pid))))
262
263	#define VBOXVDBG_ASSERT_IS_DWM(_bDwm) do { \
264	Assert((!VBOXVDBG_IS_DWM()) == (!(_bDwm))); \
265	} while (0)
266
267	#define VBOXVDBG_DUMP_FLAGS_FOR_TYPE(_type) g_VBoxVDbgFDump##_type
268	#define VBOXVDBG_BREAK_FLAGS_FOR_TYPE(_type) g_VBoxVDbgFBreak##_type
269	#define VBOXVDBG_CHECK_FLAGS_FOR_TYPE(_type) g_VBoxVDbgFCheck##_type
270	#define VBOXVDBG_IS_DUMP_ALLOWED(_type) ( VBOXVDBG_DUMP_TYPE_ENABLED(VBOXVDBG_DUMP_FLAGS_FOR_TYPE(_type)) )
271
272	#define VBOXVDBG_IS_BREAK_ALLOWED(_type) ( !!VBOXVDBG_BREAK_FLAGS_FOR_TYPE(_type) )
273
274	#define VBOXVDBG_IS_CHECK_ALLOWED(_type) ( !!VBOXVDBG_CHECK_FLAGS_FOR_TYPE(_type) )
275
276	#define VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pRc) (\
277	(_pRc)->RcDesc.fFlags.SharedResource \
278	&& VBOXVDBG_IS_DUMP_ALLOWED(Shared) \
279	)
280
281	#define VBOXVDBG_IS_BREAK_SHARED_ALLOWED(_pRc) (\
282	(_pRc)->RcDesc.fFlags.SharedResource \
283	&& VBOXVDBG_IS_BREAK_ALLOWED(Shared) \
284	)
285
286	#define VBOXVDBG_BREAK_SHARED(_pRc) do { \
287	if (VBOXVDBG_IS_BREAK_SHARED_ALLOWED(_pRc)) { \
288	vboxVDbgPrint(("Break on shared access: Rc(0x%p), SharedHandle(0x%p)\n", (_pRc), (_pRc)->aAllocations[0].hSharedHandle)); \
289	AssertFailed(); \
290	} \
291	} while (0)
292
293	#define VBOXVDBG_BREAK_DDI() do { \
294	if (VBOXVDBG_IS_BREAK_ALLOWED(Ddi)) { \
295	AssertFailed(); \
296	} \
297	} while (0)
298
299	#define VBOXVDBG_LOOP_LAST() do { vboxVDbgLoop = 0; } while (0)
300
301	#define VBOXVDBG_LOOP(_op) do { \
302	DWORD vboxVDbgLoop = 1; \
303	do { \
304	_op; \
305	} while (vboxVDbgLoop); \
306	} while (0)
307
308	#define VBOXVDBG_CHECK_SMSYNC(_pRc) do { \
309	if (VBOXVDBG_IS_CHECK_ALLOWED(SysMemSync)) { \
310	vboxWddmDbgRcSynchMemCheck((_pRc)); \
311	} \
312	} while (0)
313
314	#define VBOXVDBG_DUMP_RECTS_INIT(_d) DWORD vboxVDbgDumpRects = _d; NOREF(vboxVDbgDumpRects)
315	#define VBOXVDBG_DUMP_RECTS_FORCE() vboxVDbgDumpRects = 1;
316	#define VBOXVDBG_DUMP_RECTS_FORCED() (!!vboxVDbgDumpRects)
317
318	#define VBOXVDBG_CHECK_RECTS(_opRests, _opDump, _pszOpName, _pDstRc, _iDstAlloc, _pSrcRc, _iSrcAlloc, _pDstRect, _pSrcRect) do { \
319	VBOXVDBG_LOOP(\
320	VBOXVDBG_DUMP_RECTS_INIT(0); \
321	_opRests; \
322	if (vboxVDbgDoCheckRectsMatch(_pDstRc, _iDstAlloc, _pSrcRc, _iSrcAlloc, _pDstRect, _pSrcRect, FALSE)) { \
323	VBOXVDBG_LOOP_LAST(); \
324	} \
325	else \
326	{ \
327	VBOXVDBG_DUMP_RECTS_FORCE(); \
328	vboxVDbgPrint(("vboxVDbgDoCheckRectsMatch failed! The " _pszOpName " will be re-done so it can be debugged\n")); \
329	vboxVDbgDoPrintLopLastCmd("Don't redo the" _pszOpName); \
330	Assert(0); \
331	} \
332	_opDump; \
333	); \
334	} while (0)
335
336	#define VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsShared) do { \
337	*(_pIsShared) = FALSE; \
338	for (UINT i = 0; i < (_pDevice)->cRTs; ++i) { \
339	PVBOXWDDMDISP_ALLOCATION pRtVar = (_pDevice)->apRTs[i]; \
340	if (pRtVar && pRtVar->pRc->RcDesc.fFlags.SharedResource) { *(_pIsShared) = TRUE; break; } \
341	} \
342	if (!*(_pIsShared)) { \
343	for (UINT i = 0, iSampler = 0; iSampler < (_pDevice)->cSamplerTextures; ++i) { \
344	Assert(i < RT_ELEMENTS((_pDevice)->aSamplerTextures)); \
345	if (!(_pDevice)->aSamplerTextures[i]) continue; \
346	++iSampler; \
347	if (!(_pDevice)->aSamplerTextures[i]->RcDesc.fFlags.SharedResource) continue; \
348	*(_pIsShared) = TRUE; break; \
349	} \
350	} \
351	} while (0)
352
353	#define VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, _pIsAllowed) do { \
354	VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsAllowed); \
355	if (*(_pIsAllowed)) \
356	{ \
357	*(_pIsAllowed) = VBOXVDBG_IS_DUMP_ALLOWED(Shared); \
358	} \
359	} while (0)
360
361	#define VBOXVDBG_IS_BREAK_SHARED_ALLOWED_DEV(_pDevice, _pIsAllowed) do { \
362	VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsAllowed); \
363	if (*(_pIsAllowed)) \
364	{ \
365	*(_pIsAllowed) = VBOXVDBG_IS_BREAK_ALLOWED(Shared); \
366	} \
367	} while (0)
368
369	#define VBOXVDBG_DUMP_DRAWPRIM_ENTER(_pDevice) do { \
370	BOOL fDumpShaded = FALSE; \
371	VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, &fDumpShaded); \
372	if (fDumpShaded \
373	\|\| VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \
374	{ \
375	vboxVDbgDoDumpRt("==>"__FUNCTION__": Rt: ", (_pDevice), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim)); \
376	vboxVDbgDoDumpSamplers("==>"__FUNCTION__": Sl: ", (_pDevice), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim)); \
377	}\
378	} while (0)
379
380	#define VBOXVDBG_DUMP_DRAWPRIM_LEAVE(_pDevice) do { \
381	BOOL fDumpShaded = FALSE; \
382	VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, &fDumpShaded); \
383	if (fDumpShaded \
384	\|\| VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \
385	{ \
386	vboxVDbgDoDumpRt("<=="__FUNCTION__": Rt: ", (_pDevice), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim)); \
387	vboxVDbgDoDumpSamplers("<=="__FUNCTION__": Sl: ", (_pDevice), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim)); \
388	}\
389	} while (0)
390
391	#define VBOXVDBG_BREAK_SHARED_DEV(_pDevice) do { \
392	BOOL fBreakShaded = FALSE; \
393	VBOXVDBG_IS_BREAK_SHARED_ALLOWED_DEV(_pDevice, &fBreakShaded); \
394	if (fBreakShaded) { \
395	vboxVDbgPrint((__FUNCTION__"== Break on shared access\n")); \
396	AssertFailed(); \
397	} \
398	} while (0)
399
400	#define VBOXVDBG_DUMP_SETTEXTURE(_pRc) do { \
401	if (VBOXVDBG_IS_DUMP_ALLOWED(SetTexture) \
402	\|\| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pRc) \
403	) \
404	{ \
405	vboxVDbgDoDumpRcRect("== "__FUNCTION__": ", &(_pRc)->aAllocations[0], NULL, NULL, "", \
406	VBOXVDBG_DUMP_FLAGS_FOR_TYPE(SetTexture) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \
407	} \
408	} while (0)
409
410	#define VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \
411	if (VBOXVDBG_IS_DUMP_ALLOWED(TexBlt) \
412	\|\| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pSrcRc) \
413	\|\| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pDstRc) \
414	) \
415	{ \
416	RECT SrcRect = *(_pSrcRect); \
417	RECT _DstRect; \
418	vboxWddmRectMoved(&_DstRect, &SrcRect, (_pDstPoint)->x, (_pDstPoint)->y); \
419	vboxVDbgDoDumpRcRect("==> "__FUNCTION__": Src: ", &(_pSrcRc)->aAllocations[0], NULL, &SrcRect, "", \
420	VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \
421	vboxVDbgDoDumpRcRect("==> "__FUNCTION__": Dst: ", &(_pDstRc)->aAllocations[0], NULL, &_DstRect, "", \
422	VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \
423	} \
424	} while (0)
425
426	#define VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \
427	if (VBOXVDBG_DUMP_RECTS_FORCED() \
428	\|\| VBOXVDBG_IS_DUMP_ALLOWED(TexBlt) \
429	\|\| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pSrcRc) \
430	\|\| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pDstRc) \
431	) \
432	{ \
433	RECT SrcRect = *(_pSrcRect); \
434	RECT _DstRect; \
435	vboxWddmRectMoved(&_DstRect, &SrcRect, (_pDstPoint)->x, (_pDstPoint)->y); \
436	vboxVDbgDoDumpRcRect("<== "__FUNCTION__": Src: ", &(_pSrcRc)->aAllocations[0], NULL, &SrcRect, "", \
437	VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \
438	vboxVDbgDoDumpRcRect("<== "__FUNCTION__": Dst: ", &(_pDstRc)->aAllocations[0], NULL, &_DstRect, "", \
439	VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \
440	} \
441	} while (0)
442
443	#define VBOXVDBG_DUMP_STRETCH_RECT(_type, _str, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { \
444	if (VBOXVDBG_IS_DUMP_ALLOWED(_type) \
445	\|\| VBOXVDBG_IS_DUMP_SHARED_ALLOWED((_pSrcAlloc)->pRc) \
446	\|\| VBOXVDBG_IS_DUMP_SHARED_ALLOWED((_pDstAlloc)->pRc) \
447	) \
448	{ \
449	DWORD fFlags = VBOXVDBG_DUMP_FLAGS_FOR_TYPE(_type) \| VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared); \
450	if (VBOXVDBG_DUMP_TYPE_CONTENTS(fFlags) && \
451	((_pSrcSurf) == (_pDstSurf) \
452	&& ( ((_pSrcRect) && (_pDstRect) && !memcmp((_pSrcRect), (_pDstRect), sizeof (_pDstRect))) \
453	\|\| ((_pSrcRect) == (_pDstRect)) \
454	)) ) \
455	{ \
456	vboxVDbgPrint((_str #_type ": skipping content dump of the same rect for one surfcace\n")); \
457	fFlags = VBOXVDBG_DUMP_TYPE_GET_FLOW_ONLY(fFlags); \
458	} \
459	RECT Rect, *pRect; \
460	if (_pSrcRect) \
461	{ \
462	Rect = ((RECT)(_pSrcRect)); \
463	pRect = &Rect; \
464	} \
465	else \
466	pRect = NULL; \
467	vboxVDbgDoDumpRcRect(_str __FUNCTION__" Src: ", (_pSrcAlloc), (_pSrcSurf), pRect, "", fFlags); \
468	if (_pDstRect) \
469	{ \
470	Rect = ((RECT)(_pDstRect)); \
471	pRect = &Rect; \
472	} \
473	else \
474	pRect = NULL; \
475	vboxVDbgDoDumpRcRect(_str __FUNCTION__" Dst: ", (_pDstAlloc), (_pDstSurf), pRect, "", fFlags); \
476	} \
477	} while (0)
478
479	#define VBOXVDBG_DUMP_BLT_ENTER(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \
480	VBOXVDBG_DUMP_STRETCH_RECT(Blt, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)
481
482	#define VBOXVDBG_DUMP_BLT_LEAVE(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \
483	VBOXVDBG_DUMP_STRETCH_RECT(Blt, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)
484
485	#define VBOXVDBG_DUMP_SWAPCHAIN_SYNC_ENTER(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \
486	VBOXVDBG_DUMP_STRETCH_RECT(ScSync, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)
487
488	#define VBOXVDBG_DUMP_SWAPCHAIN_SYNC_LEAVE(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \
489	VBOXVDBG_DUMP_STRETCH_RECT(ScSync, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)
490
491	#define VBOXVDBG_IS_SKIP_DWM_WND_UPDATE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) ( \
492	g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate \
493	&& ( \
494	VBOXVDBG_IS_DWM() \
495	&& (_pSrcRc)->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM \
496	&& (_pSrcRc)->RcDesc.enmFormat == D3DDDIFMT_A8R8G8B8 \
497	&& (_pSrcRc)->cAllocations == 1 \
498	&& (_pDstRc)->RcDesc.enmPool == D3DDDIPOOL_VIDEOMEMORY \
499	&& (_pDstRc)->RcDesc.enmFormat == D3DDDIFMT_A8R8G8B8 \
500	&& (_pDstRc)->RcDesc.fFlags.RenderTarget \
501	&& (_pDstRc)->RcDesc.fFlags.NotLockable \
502	&& (_pDstRc)->cAllocations == 1 \
503	&& (_pSrcRc)->aAllocations[0].SurfDesc.width == (_pDstRc)->aAllocations[0].SurfDesc.width \
504	&& (_pSrcRc)->aAllocations[0].SurfDesc.height == (_pDstRc)->aAllocations[0].SurfDesc.height \
505	) \
506	)
507
508	#define VBOXVDBG_CHECK_TEXBLT(_opTexBlt, _pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \
509	if (VBOXVDBG_IS_CHECK_ALLOWED(TexBlt)) { \
510	if (VBOXVDBG_IS_SKIP_DWM_WND_UPDATE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint)) \
511	{ \
512	vboxVDbgPrint(("TEXBLT: skipping check for dwm wnd update\n")); \
513	} \
514	else \
515	{ \
516	RECT DstRect; \
517	DstRect.left = (_pDstPoint)->x; \
518	DstRect.right = (_pDstPoint)->x + (_pSrcRect)->right - (_pSrcRect)->left; \
519	DstRect.top = (_pDstPoint)->y; \
520	DstRect.bottom = (_pDstPoint)->y + (_pSrcRect)->bottom - (_pSrcRect)->top; \
521	VBOXVDBG_CHECK_RECTS(\
522	VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \
523	_opTexBlt ,\
524	VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint), \
525	"TexBlt", \
526	_pDstRc, 0, _pSrcRc, 0, &DstRect, _pSrcRect); \
527	break; \
528	} \
529	} \
530	VBOXVDBG_DUMP_RECTS_INIT(0); \
531	VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \
532	_opTexBlt;\
533	VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \
534	} while (0)
535
536	#define VBOXVDBG_CHECK_STRETCH_RECT(_type, _op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { \
537	if (VBOXVDBG_IS_CHECK_ALLOWED(_type)) { \
538	VBOXVDBG_CHECK_RECTS(\
539	VBOXVDBG_DUMP_STRETCH_RECT(_type, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \
540	_op ,\
541	VBOXVDBG_DUMP_STRETCH_RECT(_type, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect), \
542	#_type , \
543	_pDstAlloc->pRc, _pDstAlloc->iAlloc, _pSrcAlloc->pRc, _pSrcAlloc->iAlloc, _pDstRect, _pSrcRect); \
544	} \
545	else \
546	{ \
547	VBOXVDBG_DUMP_RECTS_INIT(0); \
548	VBOXVDBG_DUMP_STRETCH_RECT(_type, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \
549	_op;\
550	VBOXVDBG_DUMP_STRETCH_RECT(_type, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \
551	} \
552	} while (0)
553
554	#define VBOXVDBG_CHECK_BLT(_opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \
555	VBOXVDBG_CHECK_STRETCH_RECT(Blt, _opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)
556
557	#define VBOXVDBG_CHECK_SWAPCHAIN_SYNC(_op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \
558	VBOXVDBG_CHECK_STRETCH_RECT(ScSync, _op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)
559
560	#define VBOXVDBG_DUMP_SYNC_RT(_pBbSurf) do { \
561	if (VBOXVDBG_IS_DUMP_ALLOWED(RtSynch)) \
562	{ \
563	vboxVDbgDoDumpRcRect("== "__FUNCTION__" Bb:\n", NULL, (_pBbSurf), NULL, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(RtSynch)); \
564	} \
565	} while (0)
566
567	#define VBOXVDBG_DUMP_PRESENT_ENTER(_pDevice, _pSwapchain) do { \
568	if (VBOXVDBG_IS_DUMP_ALLOWED(PresentEnter)) { \
569	if (!(_pSwapchain)->fFlags.bRtReportingPresent) { \
570	vboxVDbgDoDumpBb("==>"__FUNCTION__" Bb:\n", (_pSwapchain)->pSwapChainIf, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(PresentEnter)); \
571	} \
572	else { \
573	PVBOXWDDMDISP_ALLOCATION pCurBb = vboxWddmSwapchainGetBb((_pSwapchain))->pAlloc; \
574	IDirect3DSurface9 *pSurf; \
575	HRESULT hr = vboxWddmSwapchainSurfGet(_pDevice, _pSwapchain, pCurBb, &pSurf); \
576	Assert(hr == S_OK); \
577	vboxVDbgDoDumpRcRect("== "__FUNCTION__" Bb:\n", pCurBb, pSurf, NULL, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(PresentEnter)); \
578	pSurf->Release(); \
579	} \
580	} \
581	} while (0)
582
583	#define VBOXVDBG_DUMP_PRESENT_LEAVE(_pDevice, _pSwapchain) do { \
584	if (VBOXVDBG_IS_DUMP_ALLOWED(PresentLeave)) { \
585	if (!(_pSwapchain)->fFlags.bRtReportingPresent) { \
586	vboxVDbgDoDumpFb("<=="__FUNCTION__" Fb:\n", (_pSwapchain)->pSwapChainIf, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(PresentLeave)); \
587	} \
588	else { \
589	vboxVDbgPrint(("PRESENT_LEAVE: unsupported for Rt Reporting mode\n")); \
590	} \
591	} \
592	} while (0)
593
594
595	#define VBOXVDBG_DUMP_FLUSH(_pDevice) do { \
596	if (VBOXVDBG_IS_DUMP_ALLOWED(Flush)) \
597	{ \
598	vboxVDbgDoDumpRt("== "__FUNCTION__": Rt: ", (_pDevice), "", \
599	VBOXVDBG_DUMP_FLAGS_CLEAR(VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Flush), VBOXVDBG_DUMP_TYPEF_SHARED_ONLY)); \
600	}\
601	} while (0)
602
603	#define VBOXVDBG_DUMP_LOCK_ST(_pData) do { \
604	if (VBOXVDBG_IS_DUMP_ALLOWED(Lock) \
605	\|\| VBOXVDBG_IS_DUMP_ALLOWED(Unlock) \
606	) \
607	{ \
608	vboxVDbgDoDumpLockSurfTex("== "__FUNCTION__": ", (_pData), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Lock)); \
609	} \
610	} while (0)
611
612	#define VBOXVDBG_DUMP_UNLOCK_ST(_pData) do { \
613	if (VBOXVDBG_IS_DUMP_ALLOWED(Unlock) \
614	) \
615	{ \
616	vboxVDbgDoDumpUnlockSurfTex("== "__FUNCTION__": ", (_pData), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Unlock)); \
617	} \
618	} while (0)
619
620
621	#define VBOXVDBG_CREATE_CHECK_SWAPCHAIN() do { \
622	if (g_VBoxVDbgCfgCreateSwapchainOnDdiOnce && g_VBoxVDbgInternalRc) { \
623	PVBOXWDDMDISP_SWAPCHAIN pSwapchain; \
624	HRESULT hr = vboxWddmSwapchainCreateIfForRc(g_VBoxVDbgInternalDevice, g_VBoxVDbgInternalRc, &pSwapchain); \
625	Assert(hr == S_OK); \
626	g_VBoxVDbgInternalRc = NULL; \
627	g_VBoxVDbgCfgCreateSwapchainOnDdiOnce = 0; \
628	} \
629	} while (0)
630
631	# endif /* # ifndef IN_VBOXCRHGSMI */
632	#else
633	#define VBOXVDBG_DUMP_DRAWPRIM_ENTER(_pDevice) do { } while (0)
634	#define VBOXVDBG_DUMP_DRAWPRIM_LEAVE(_pDevice) do { } while (0)
635	#define VBOXVDBG_DUMP_SETTEXTURE(_pRc) do { } while (0)
636	#define VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { } while (0)
637	#define VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { } while (0)
638	#define VBOXVDBG_DUMP_BLT_ENTER(_pSrcRc, _pSrcSurf, _pSrcRect, _pDstRc, _pDstSurf, _pDstRect) do { } while (0)
639	#define VBOXVDBG_DUMP_BLT_LEAVE(_pSrcRc, _pSrcSurf, _pSrcRect, _pDstRc, _pDstSurf, _pDstRect) do { } while (0)
640	#define VBOXVDBG_DUMP_SYNC_RT(_pBbSurf) do { } while (0)
641	#define VBOXVDBG_DUMP_FLUSH(_pDevice) do { } while (0)
642	#define VBOXVDBG_DUMP_LOCK_ST(_pData) do { } while (0)
643	#define VBOXVDBG_DUMP_UNLOCK_ST(_pData) do { } while (0)
644	#define VBOXVDBG_DUMP_PRESENT_ENTER(_pDevice, _pSwapchain) do { } while (0)
645	#define VBOXVDBG_DUMP_PRESENT_LEAVE(_pDevice, _pSwapchain) do { } while (0)
646	#define VBOXVDBG_BREAK_SHARED(_pRc) do { } while (0)
647	#define VBOXVDBG_BREAK_SHARED_DEV(_pDevice) do { } while (0)
648	#define VBOXVDBG_BREAK_DDI() do { } while (0)
649	#define VBOXVDBG_CHECK_SMSYNC(_pRc) do { } while (0)
650	#define VBOXVDBG_CHECK_BLT(_opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { _opBlt; } while (0)
651	#define VBOXVDBG_CHECK_TEXBLT(_opTexBlt, _pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { _opTexBlt; } while (0)
652	#define VBOXVDBG_ASSERT_IS_DWM(_bDwm) do { } while (0)
653	#define VBOXVDBG_CHECK_SWAPCHAIN_SYNC(_op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { _op; } while (0)
654	#define VBOXVDBG_CREATE_CHECK_SWAPCHAIN() do { } while (0)
655	#endif
656
657
658	#endif /* #ifndef ___VBoxDispDbg_h__ */

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

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.h@ 69498

Download in other formats: