VBoxDispDbg.h@ 77046

Last change on this file since 77046 was 76563, checked in by vboxsync, 6 years ago
Additions: Use GA_INCLUDED_ and variations_ as header guard prefixes with scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.2 KB

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

Download in other formats: