VirtualBox

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

Last change on this file was 98103, checked in by vboxsync, 16 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use