a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync#ifndef ___VBoxDispDbg_h__

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync#define ___VBoxDispDbg_h__

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#define VBOX_VIDEO_LOG_NAME "VBoxD3D"

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#define VBOX_VIDEO_LOG_LOGGER vboxVDbgInternalLogLogger

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define VBOX_VIDEO_LOGREL_LOGGER vboxVDbgInternalLogRelLogger

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync#define VBOX_VIDEO_LOGFLOW_LOGGER vboxVDbgInternalLogFlowLogger

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync#define VBOX_VIDEO_LOG_FN_FMT "%s"

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync#include "../../common/VBoxVideoLog.h"

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#ifdef DEBUG

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# define VBOXWDDMDISP_DEBUG

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# if defined(DEBUG_misha) || defined(DEBUG_leo)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# endif

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsyncextern DWORD g_VBoxVDbgFDumpSetTexture;

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsyncextern DWORD g_VBoxVDbgFDumpDrawPrim;

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsyncextern DWORD g_VBoxVDbgFDumpTexBlt;

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsyncextern DWORD g_VBoxVDbgFDumpBlt;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFDumpRtSynch;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFDumpFlush;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFDumpShared;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFDumpLock;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFDumpUnlock;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFDumpPresentEnter;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFDumpPresentLeave;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFDumpScSync;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsync

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFBreakShared;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFBreakDdi;

7d913420297c8662dd9523fbf927125b3ed48814vboxsync

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFCheckSysMemSync;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgFCheckBlt;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFCheckTexBlt;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFCheckScSync;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFLogRel;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFLog;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFLogFlow;

1cee507a10df8208ebb4a36db7073b312dff343fvboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern DWORD g_VBoxVDbgFIsModuleNameInited;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern char g_VBoxVDbgModuleName[];

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncextern LONG g_VBoxVDbgFIsDwm;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsync

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgCfgMaxDirectRts;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern DWORD g_VBoxVDbgCfgForceDummyDevCreate;

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsync

2c7402dd06f73977076fdbc86bb9f1c0c2be17f9vboxsyncextern struct VBOXWDDMDISP_DEVICE *g_VBoxVDbgInternalDevice;

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsyncextern struct VBOXWDDMDISP_RESOURCE *g_VBoxVDbgInternalRc;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsyncextern DWORD g_VBoxVDbgCfgCreateSwapchainOnDdiOnce;

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#endif

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync#if 0

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# ifdef Assert

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# undef Assert

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# define Assert(_a) do{}while(0)

c2590a722c15520a45551ed7dc02d4831fb1a48evboxsync# endif

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# ifdef AssertBreakpoint

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# undef AssertBreakpoint

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# define AssertBreakpoint() do{}while(0)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# endif

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# ifdef AssertFailed

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# undef AssertFailed

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# define AssertFailed() do{}while(0)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# endif

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#endif

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#ifdef VBOXWDDMDISP_DEBUG_VEHANDLER

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncvoid vboxVDbgVEHandlerRegister();

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsyncvoid vboxVDbgVEHandlerUnregister();

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#endif

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#if defined(LOG_TO_BACKDOOR_DRV) || defined(VBOXWDDMDISP_DEBUG_PRINTDRV)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# define DbgPrintDrv(_m) do { vboxDispLogDrvF _m; } while (0)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# define DbgPrintDrvRel(_m) do { vboxDispLogDrvF _m; } while (0)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# define DbgPrintDrvFlow(_m) do { vboxDispLogDrvF _m; } while (0)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#else

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# define DbgPrintDrv(_m) do { } while (0)

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync# define DbgPrintDrvRel(_m) do { } while (0)

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# define DbgPrintDrvFlow(_m) do { } while (0)

40e7dd58e01abf2e1b9df9588ea22f58846bf886vboxsync#endif

40e7dd58e01abf2e1b9df9588ea22f58846bf886vboxsync

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync#ifdef VBOXWDDMDISP_DEBUG_PRINT

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync# define DbgPrintUsr(_m) do { vboxDispLogDbgPrintF _m; } while (0)

8532fcd8b260a1648f09ab3df65e5353aa148825vboxsync# define DbgPrintUsrRel(_m) do { vboxDispLogDbgPrintF _m; } while (0)

8532fcd8b260a1648f09ab3df65e5353aa148825vboxsync# define DbgPrintUsrFlow(_m) do { vboxDispLogDbgPrintF _m; } while (0)

8532fcd8b260a1648f09ab3df65e5353aa148825vboxsync#else

7d913420297c8662dd9523fbf927125b3ed48814vboxsync# define DbgPrintUsr(_m) do { } while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync# define DbgPrintUsrRel(_m) do { } while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync# define DbgPrintUsrFlow(_m) do { } while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#endif

7d913420297c8662dd9523fbf927125b3ed48814vboxsync

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#ifdef VBOXWDDMDISP_DEBUG

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLog(_p) if (g_VBoxVDbgFLog) { _p }

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLogFlow(_p) if (g_VBoxVDbgFLogFlow) { _p }

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLogRel(_p) if (g_VBoxVDbgFLogRel) { _p }

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#else

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLog(_p) do {} while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLogFlow(_p) do {} while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLogRel(_p) do { _p } while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#endif

7d913420297c8662dd9523fbf927125b3ed48814vboxsync

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgPrint(_m) LOG_EXACT(_m)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgPrintF(_m) LOGF_EXACT(_m)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgPrintR(_m) LOGREL_EXACT(_m)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLogLogger(_m) do { \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync vboxVDbgInternalLog( \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync Log(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync DbgPrintUsr(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync DbgPrintDrv(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync ); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync } while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLogFlowLogger(_m) do { \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync vboxVDbgInternalLogFlow( \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync LogFlow(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync DbgPrintUsrFlow(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync DbgPrintDrvFlow(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync ); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync } while (0)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#define vboxVDbgInternalLogRelLogger(_m) do { \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync vboxVDbgInternalLogRel( \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync LogRel(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync DbgPrintUsrRel(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync DbgPrintDrvRel(_m); \

7d913420297c8662dd9523fbf927125b3ed48814vboxsync ); \

1cee507a10df8208ebb4a36db7073b312dff343fvboxsync } while (0)

8532fcd8b260a1648f09ab3df65e5353aa148825vboxsync

7d913420297c8662dd9523fbf927125b3ed48814vboxsync#if defined(VBOXWDDMDISP_DEBUG) || defined(LOG_TO_BACKDOOR_DRV)

7d913420297c8662dd9523fbf927125b3ed48814vboxsync

8532fcd8b260a1648f09ab3df65e5353aa148825vboxsync#define VBOXVDBG_STRCASE(_t) \

8532fcd8b260a1648f09ab3df65e5353aa148825vboxsync case _t: return #_t;

0d0253c4c63a28f67509d37a41df855173e94ee1vboxsync#define VBOXVDBG_STRCASE_UNKNOWN() \

a7d389fbff436fb217a78d48fab17adcaf43dc54vboxsync default: Assert(0); return "Unknown";

static DECLINLINE(const char*) vboxDispLogD3DRcType(D3DRESOURCETYPE enmType)

{

switch (enmType)

{

VBOXVDBG_STRCASE(D3DRTYPE_SURFACE);

VBOXVDBG_STRCASE(D3DRTYPE_VOLUME);

VBOXVDBG_STRCASE(D3DRTYPE_TEXTURE);

VBOXVDBG_STRCASE(D3DRTYPE_VOLUMETEXTURE);

VBOXVDBG_STRCASE(D3DRTYPE_CUBETEXTURE);

VBOXVDBG_STRCASE(D3DRTYPE_VERTEXBUFFER);

VBOXVDBG_STRCASE(D3DRTYPE_INDEXBUFFER);

VBOXVDBG_STRCASE_UNKNOWN();

}

}

#include "VBoxDispMpLogger.h"

VBOXDISPMPLOGGER_DECL(void) VBoxDispMpLoggerDumpD3DCAPS9(struct _D3DCAPS9 *pCaps);

void vboxDispLogDrvF(char * szString, ...);

# define vboxDispDumpD3DCAPS9(_pCaps) do { VBoxDispMpLoggerDumpD3DCAPS9(_pCaps); } while (0)

#else

# define vboxDispDumpD3DCAPS9(_pCaps) do { } while (0)

#endif

#ifdef VBOXWDDMDISP_DEBUG

void vboxDispLogDbgPrintF(char * szString, ...);

typedef struct VBOXWDDMDISP_ALLOCATION *PVBOXWDDMDISP_ALLOCATION;

typedef struct VBOXWDDMDISP_RESOURCE *PVBOXWDDMDISP_RESOURCE;

#define VBOXVDBG_DUMP_TYPEF_FLOW 0x00000001

#define VBOXVDBG_DUMP_TYPEF_CONTENTS 0x00000002

#define VBOXVDBG_DUMP_TYPEF_DONT_BREAK_ON_CONTENTS 0x00000004

#define VBOXVDBG_DUMP_TYPEF_BREAK_ON_FLOW 0x00000008

#define VBOXVDBG_DUMP_TYPEF_SHARED_ONLY 0x00000010

#define VBOXVDBG_DUMP_FLAGS_IS_SETANY(_fFlags, _Value) (((_fFlags) & (_Value)) != 0)

#define VBOXVDBG_DUMP_FLAGS_IS_SET(_fFlags, _Value) (((_fFlags) & (_Value)) == (_Value))

#define VBOXVDBG_DUMP_FLAGS_IS_CLEARED(_fFlags, _Value) (((_fFlags) & (_Value)) == 0)

#define VBOXVDBG_DUMP_FLAGS_CLEAR(_fFlags, _Value) ((_fFlags) & (~(_Value)))

#define VBOXVDBG_DUMP_FLAGS_SET(_fFlags, _Value) ((_fFlags) | (_Value))

#define VBOXVDBG_DUMP_TYPE_ENABLED(_fFlags) (VBOXVDBG_DUMP_FLAGS_IS_SETANY(_fFlags, VBOXVDBG_DUMP_TYPEF_FLOW | VBOXVDBG_DUMP_TYPEF_CONTENTS))

#define VBOXVDBG_DUMP_TYPE_ENABLED_FOR_INFO(_pInfo, _fFlags) ( \

VBOXVDBG_DUMP_TYPE_ENABLED(_fFlags) \

&& ( \

!(_pInfo)->pAlloc \

|| (_pInfo)->pAlloc->pRc->aAllocations[0].hSharedHandle \

|| VBOXVDBG_DUMP_FLAGS_IS_CLEARED(_fFlags, VBOXVDBG_DUMP_TYPEF_SHARED_ONLY) \

))

#define VBOXVDBG_DUMP_TYPE_FLOW_ONLY(_fFlags) (VBOXVDBG_DUMP_FLAGS_IS_SET(_fFlags, VBOXVDBG_DUMP_TYPEF_FLOW) \

&& VBOXVDBG_DUMP_FLAGS_IS_CLEARED(_fFlags, VBOXVDBG_DUMP_TYPEF_CONTENTS))

#define VBOXVDBG_DUMP_TYPE_CONTENTS(_fFlags) (VBOXVDBG_DUMP_FLAGS_IS_SET(_fFlags, VBOXVDBG_DUMP_TYPEF_CONTENTS))

#define VBOXVDBG_DUMP_TYPE_GET_FLOW_ONLY(_fFlags) ( \

VBOXVDBG_DUMP_FLAGS_SET( \

VBOXVDBG_DUMP_FLAGS_CLEAR(_fFlags, VBOXVDBG_DUMP_TYPEF_CONTENTS), \

VBOXVDBG_DUMP_TYPEF_FLOW) \

)

VOID vboxVDbgDoDumpAllocRect(const char * pPrefix, PVBOXWDDMDISP_ALLOCATION pAlloc, RECT *pRect, const char* pSuffix, DWORD fFlags);

VOID vboxVDbgDoDumpRcRect(const char * pPrefix, PVBOXWDDMDISP_ALLOCATION pAlloc, IDirect3DResource9 *pD3DRc, RECT *pRect, const char * pSuffix, DWORD fFlags);

VOID vboxVDbgDoDumpLockUnlockSurfTex(const char * pPrefix, const PVBOXWDDMDISP_ALLOCATION pAlloc, const char * pSuffix, DWORD fFlags);

VOID vboxVDbgDoDumpRt(const char * pPrefix, struct VBOXWDDMDISP_DEVICE *pDevice, const char * pSuffix, DWORD fFlags);

VOID vboxVDbgDoDumpBb(const char * pPrefix, IDirect3DSwapChain9 *pSwapchainIf, const char * pSuffix, DWORD fFlags);

VOID vboxVDbgDoDumpFb(const char * pPrefix, IDirect3DSwapChain9 *pSwapchainIf, const char * pSuffix, DWORD fFlags);

VOID vboxVDbgDoDumpSamplers(const char * pPrefix, struct VBOXWDDMDISP_DEVICE *pDevice, const char * pSuffix, DWORD fFlags);

void vboxVDbgDoPrintRect(const char * pPrefix, const RECT *pRect, const char * pSuffix);

void vboxVDbgDoPrintAlloc(const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const char * pSuffix);

VOID vboxVDbgDoDumpLockSurfTex(const char * pPrefix, const D3DDDIARG_LOCK* pData, const char * pSuffix, DWORD fFlags);

VOID vboxVDbgDoDumpUnlockSurfTex(const char * pPrefix, const D3DDDIARG_UNLOCK* pData, const char * pSuffix, DWORD fFlags);

BOOL vboxVDbgDoCheckRectsMatch(const PVBOXWDDMDISP_RESOURCE pDstRc, uint32_t iDstAlloc,

const PVBOXWDDMDISP_RESOURCE pSrcRc, uint32_t iSrcAlloc,

const RECT *pDstRect,

const RECT *pSrcRect,

BOOL fBreakOnMismatch);

BOOL vboxVDbgDoCheckExe(const char * pszName);

VOID vboxVDbgDoPrintLopLastCmd(const char* pszDesc);

extern DWORD g_VBoxVDbgPid;

#define VBOXVDBG_IS_PID(_pid) ((_pid) == (g_VBoxVDbgPid ? g_VBoxVDbgPid : (g_VBoxVDbgPid = GetCurrentProcessId())))

#define VBOXVDBG_IS_DUMP_ALLOWED_PID(_pid) (((int)(_pid)) > 0 ? VBOXVDBG_IS_PID(_pid) : !VBOXVDBG_IS_PID(-((int)(_pid))))

#define VBOXVDBG_CHECK_EXE(_pszName) (vboxVDbgDoCheckExe(_pszName))

#define VBOXVDBG_IS_DWM() (!!(g_VBoxVDbgFIsDwm >=0 ? g_VBoxVDbgFIsDwm : (g_VBoxVDbgFIsDwm = VBOXVDBG_CHECK_EXE("dwm.exe"))))

#define VBOXVDBG_ASSERT_IS_DWM(_bDwm) do { \

Assert((!VBOXVDBG_IS_DWM()) == (!(_bDwm))); \

} while (0)

#define VBOXVDBG_DUMP_FLAGS_FOR_TYPE(_type) g_VBoxVDbgFDump##_type

#define VBOXVDBG_BREAK_FLAGS_FOR_TYPE(_type) g_VBoxVDbgFBreak##_type

#define VBOXVDBG_CHECK_FLAGS_FOR_TYPE(_type) g_VBoxVDbgFCheck##_type

#define VBOXVDBG_IS_DUMP_ALLOWED(_type) ( VBOXVDBG_DUMP_TYPE_ENABLED(VBOXVDBG_DUMP_FLAGS_FOR_TYPE(_type)) )

#define VBOXVDBG_IS_BREAK_ALLOWED(_type) ( !!VBOXVDBG_BREAK_FLAGS_FOR_TYPE(_type) )

#define VBOXVDBG_IS_CHECK_ALLOWED(_type) ( !!VBOXVDBG_CHECK_FLAGS_FOR_TYPE(_type) )

#define VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pRc) (\

(_pRc)->RcDesc.fFlags.SharedResource \

&& VBOXVDBG_IS_DUMP_ALLOWED(Shared) \

)

#define VBOXVDBG_IS_BREAK_SHARED_ALLOWED(_pRc) (\

(_pRc)->RcDesc.fFlags.SharedResource \

&& VBOXVDBG_IS_BREAK_ALLOWED(Shared) \

)

#define VBOXVDBG_BREAK_SHARED(_pRc) do { \

if (VBOXVDBG_IS_BREAK_SHARED_ALLOWED(_pRc)) { \

vboxVDbgPrint(("Break on shared access: Rc(0x%p), SharedHandle(0x%p)\n", (_pRc), (_pRc)->aAllocations[0].hSharedHandle)); \

AssertFailed(); \

} \

} while (0)

#define VBOXVDBG_BREAK_DDI() do { \

if (VBOXVDBG_IS_BREAK_ALLOWED(Ddi)) { \

AssertFailed(); \

} \

} while (0)

#define VBOXVDBG_LOOP_LAST() do { vboxVDbgLoop = 0; } while (0)

#define VBOXVDBG_LOOP(_op) do { \

DWORD vboxVDbgLoop = 1; \

do { \

_op; \

} while (vboxVDbgLoop); \

} while (0)

#define VBOXVDBG_CHECK_SMSYNC(_pRc) do { \

if (VBOXVDBG_IS_CHECK_ALLOWED(SysMemSync)) { \

vboxWddmDbgRcSynchMemCheck((_pRc)); \

} \

} while (0)

#define VBOXVDBG_DUMP_RECTS_INIT(_d) DWORD vboxVDbgDumpRects = _d;

#define VBOXVDBG_DUMP_RECTS_FORCE() vboxVDbgDumpRects = 1;

#define VBOXVDBG_DUMP_RECTS_FORCED() (!!vboxVDbgDumpRects)

#define VBOXVDBG_CHECK_RECTS(_opRests, _opDump, _pszOpName, _pDstRc, _iDstAlloc, _pSrcRc, _iSrcAlloc, _pDstRect, _pSrcRect) do { \

VBOXVDBG_LOOP(\

VBOXVDBG_DUMP_RECTS_INIT(0); \

_opRests; \

if (vboxVDbgDoCheckRectsMatch(_pDstRc, _iDstAlloc, _pSrcRc, _iSrcAlloc, _pDstRect, _pSrcRect, FALSE)) { \

VBOXVDBG_LOOP_LAST(); \

} \

else \

{ \

VBOXVDBG_DUMP_RECTS_FORCE(); \

vboxVDbgPrint(("vboxVDbgDoCheckRectsMatch failed! The " _pszOpName " will be re-done so it can be debugged\n")); \

vboxVDbgDoPrintLopLastCmd("Don't redo the" _pszOpName); \

Assert(0); \

} \

_opDump; \

); \

} while (0)

#define VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsShared) do { \

*(_pIsShared) = FALSE; \

for (UINT i = 0; i < (_pDevice)->cRTs; ++i) { \

PVBOXWDDMDISP_ALLOCATION pRtVar = (_pDevice)->apRTs[i]; \

if (pRtVar->pRc->RcDesc.fFlags.SharedResource) { *(_pIsShared) = TRUE; break; } \

} \

if (!*(_pIsShared)) { \

for (UINT i = 0, iSampler = 0; iSampler < (_pDevice)->cSamplerTextures; ++i) { \

Assert(i < RT_ELEMENTS((_pDevice)->aSamplerTextures)); \

if (!(_pDevice)->aSamplerTextures[i]) continue; \

++iSampler; \

if (!(_pDevice)->aSamplerTextures[i]->RcDesc.fFlags.SharedResource) continue; \

*(_pIsShared) = TRUE; break; \

} \

} \

} while (0)

#define VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, _pIsAllowed) do { \

VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsAllowed); \

if (*(_pIsAllowed)) \

{ \

*(_pIsAllowed) = VBOXVDBG_IS_DUMP_ALLOWED(Shared); \

} \

} while (0)

#define VBOXVDBG_IS_BREAK_SHARED_ALLOWED_DEV(_pDevice, _pIsAllowed) do { \

VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsAllowed); \

if (*(_pIsAllowed)) \

{ \

*(_pIsAllowed) = VBOXVDBG_IS_BREAK_ALLOWED(Shared); \

} \

} while (0)

#define VBOXVDBG_DUMP_DRAWPRIM_ENTER(_pDevice) do { \

BOOL fDumpShaded = FALSE; \

VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, &fDumpShaded); \

if (fDumpShaded \

|| VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \

{ \

vboxVDbgDoDumpRt("==>"__FUNCTION__": Rt: ", (_pDevice), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Flush) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim)); \

vboxVDbgDoDumpSamplers("==>"__FUNCTION__": Sl: ", (_pDevice), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Flush) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim)); \

}\

} while (0)

#define VBOXVDBG_DUMP_DRAWPRIM_LEAVE(_pDevice) do { \

BOOL fDumpShaded = FALSE; \

VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, &fDumpShaded); \

if (fDumpShaded \

|| VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \

{ \

vboxVDbgDoDumpRt("<=="__FUNCTION__": Rt: ", (_pDevice), "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

vboxVDbgDoDumpSamplers("<=="__FUNCTION__": Sl: ", (_pDevice), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Flush) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(DrawPrim)); \

}\

} while (0)

#define VBOXVDBG_BREAK_SHARED_DEV(_pDevice) do { \

BOOL fBreakShaded = FALSE; \

VBOXVDBG_IS_BREAK_SHARED_ALLOWED_DEV(_pDevice, &fBreakShaded); \

if (fBreakShaded) { \

vboxVDbgPrint((__FUNCTION__"== Break on shared access\n")); \

AssertFailed(); \

} \

} while (0)

#define VBOXVDBG_DUMP_SETTEXTURE(_pRc) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(SetTexture) \

|| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pRc) \

) \

{ \

vboxVDbgDoDumpRcRect("== "__FUNCTION__": ", &(_pRc)->aAllocations[0], NULL, NULL, "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(SetTexture) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

} \

} while (0)

#define VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(TexBlt) \

|| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pSrcRc) \

|| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pDstRc) \

) \

{ \

RECT SrcRect = *(_pSrcRect); \

RECT _DstRect; \

vboxWddmRectMoved(&_DstRect, &SrcRect, (_pDstPoint)->x, (_pDstPoint)->y); \

vboxVDbgDoDumpRcRect("==> "__FUNCTION__": Src: ", &(_pSrcRc)->aAllocations[0], NULL, &SrcRect, "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

vboxVDbgDoDumpRcRect("==> "__FUNCTION__": Dst: ", &(_pDstRc)->aAllocations[0], NULL, &_DstRect, "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

} \

} while (0)

#define VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \

if (VBOXVDBG_DUMP_RECTS_FORCED() \

|| VBOXVDBG_IS_DUMP_ALLOWED(TexBlt) \

|| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pSrcRc) \

|| VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pDstRc) \

) \

{ \

RECT SrcRect = *(_pSrcRect); \

RECT _DstRect; \

vboxWddmRectMoved(&_DstRect, &SrcRect, (_pDstPoint)->x, (_pDstPoint)->y); \

vboxVDbgDoDumpRcRect("<== "__FUNCTION__": Src: ", &(_pSrcRc)->aAllocations[0], NULL, &SrcRect, "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

vboxVDbgDoDumpRcRect("<== "__FUNCTION__": Dst: ", &(_pDstRc)->aAllocations[0], NULL, &_DstRect, "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(TexBlt) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

} \

} while (0)

#define VBOXVDBG_DUMP_STRETCH_RECT(_type, _str, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(_type) \

|| VBOXVDBG_IS_DUMP_SHARED_ALLOWED((_pSrcAlloc)->pRc) \

|| VBOXVDBG_IS_DUMP_SHARED_ALLOWED((_pDstAlloc)->pRc) \

) \

{ \

DWORD fFlags = VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Blt) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared); \

if (VBOXVDBG_DUMP_TYPE_CONTENTS(fFlags) && \

((_pSrcSurf) == (_pDstSurf) \

&& ( ((_pSrcRect) && (_pDstRect) && !memcmp((_pSrcRect), (_pDstRect), sizeof (_pDstRect))) \

|| ((_pSrcRect) == (_pDstRect)) \

)) ) \

{ \

vboxVDbgPrint((_str #_type ": skipping content dump of the same rect for one surfcace\n")); \

fFlags = VBOXVDBG_DUMP_TYPE_GET_FLOW_ONLY(fFlags); \

} \

RECT Rect, *pRect; \

if (_pSrcRect) \

{ \

Rect = *((RECT*)(_pSrcRect)); \

pRect = &Rect; \

} \

else \

pRect = NULL; \

vboxVDbgDoDumpRcRect(_str __FUNCTION__" Src: ", (_pSrcAlloc), (_pSrcSurf), pRect, "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(_type) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

if (_pDstRect) \

{ \

Rect = *((RECT*)(_pDstRect)); \

pRect = &Rect; \

} \

else \

pRect = NULL; \

vboxVDbgDoDumpRcRect(_str __FUNCTION__" Dst: ", (_pDstAlloc), (_pDstSurf), pRect, "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(_type) | VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Shared)); \

} \

} while (0)

#define VBOXVDBG_DUMP_BLT_ENTER(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \

VBOXVDBG_DUMP_STRETCH_RECT(Blt, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)

#define VBOXVDBG_DUMP_BLT_LEAVE(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \

VBOXVDBG_DUMP_STRETCH_RECT(Blt, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)

#define VBOXVDBG_DUMP_SWAPCHAIN_SYNC_ENTER(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \

VBOXVDBG_DUMP_STRETCH_RECT(ScSync, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)

#define VBOXVDBG_DUMP_SWAPCHAIN_SYNC_LEAVE(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \

VBOXVDBG_DUMP_STRETCH_RECT(ScSync, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)

#define VBOXVDBG_IS_SKIP_DWM_WND_UPDATE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) ( \

g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate \

&& ( \

VBOXVDBG_IS_DWM() \

&& (_pSrcRc)->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM \

&& (_pSrcRc)->RcDesc.enmFormat == D3DDDIFMT_A8R8G8B8 \

&& (_pSrcRc)->cAllocations == 1 \

&& (_pDstRc)->RcDesc.enmPool == D3DDDIPOOL_VIDEOMEMORY \

&& (_pDstRc)->RcDesc.enmFormat == D3DDDIFMT_A8R8G8B8 \

&& (_pDstRc)->RcDesc.fFlags.RenderTarget \

&& (_pDstRc)->RcDesc.fFlags.NotLockable \

&& (_pDstRc)->cAllocations == 1 \

&& (_pSrcRc)->aAllocations[0].SurfDesc.width == (_pDstRc)->aAllocations[0].SurfDesc.width \

&& (_pSrcRc)->aAllocations[0].SurfDesc.height == (_pDstRc)->aAllocations[0].SurfDesc.height \

) \

)

#define VBOXVDBG_CHECK_TEXBLT(_opTexBlt, _pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \

if (VBOXVDBG_IS_CHECK_ALLOWED(TexBlt)) { \

if (VBOXVDBG_IS_SKIP_DWM_WND_UPDATE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint)) \

{ \

vboxVDbgPrint(("TEXBLT: skipping check for dwm wnd update\n")); \

} \

else \

{ \

RECT DstRect; \

DstRect.left = (_pDstPoint)->x; \

DstRect.right = (_pDstPoint)->x + (_pSrcRect)->right - (_pSrcRect)->left; \

DstRect.top = (_pDstPoint)->y; \

DstRect.bottom = (_pDstPoint)->y + (_pSrcRect)->bottom - (_pSrcRect)->top; \

VBOXVDBG_CHECK_RECTS(\

VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \

_opTexBlt ,\

VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint), \

"TexBlt", \

_pDstRc, 0, _pSrcRc, 0, &DstRect, _pSrcRect); \

break; \

} \

} \

VBOXVDBG_DUMP_RECTS_INIT(0); \

VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \

_opTexBlt;\

VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \

} while (0)

#define VBOXVDBG_CHECK_STRETCH_RECT(_type, _op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { \

if (VBOXVDBG_IS_CHECK_ALLOWED(_type)) { \

VBOXVDBG_CHECK_RECTS(\

VBOXVDBG_DUMP_STRETCH_RECT(_type, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \

_op ,\

VBOXVDBG_DUMP_STRETCH_RECT(_type, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect), \

#_type , \

_pDstAlloc->pRc, _pDstAlloc->iAlloc, _pSrcAlloc->pRc, _pSrcAlloc->iAlloc, _pDstRect, _pSrcRect); \

} \

else \

{ \

VBOXVDBG_DUMP_RECTS_INIT(0); \

VBOXVDBG_DUMP_STRETCH_RECT(_type, "==>", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \

_op;\

VBOXVDBG_DUMP_STRETCH_RECT(_type, "<==", _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \

} \

} while (0)

#define VBOXVDBG_CHECK_BLT(_opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \

VBOXVDBG_CHECK_STRETCH_RECT(Blt, _opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)

#define VBOXVDBG_CHECK_SWAPCHAIN_SYNC(_op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) \

VBOXVDBG_CHECK_STRETCH_RECT(ScSync, _op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect)

#define VBOXVDBG_DUMP_SYNC_RT(_pBbSurf) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(RtSynch)) \

{ \

vboxVDbgDoDumpRcRect("== "__FUNCTION__" Bb:\n", NULL, (_pBbSurf), NULL, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(RtSynch)); \

} \

} while (0)

#define VBOXVDBG_DUMP_PRESENT_ENTER(_pDevice, _pSwapchain) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(PresentEnter)) { \

if (!(_pSwapchain)->fFlags.bRtReportingPresent) { \

vboxVDbgDoDumpBb("==>"__FUNCTION__" Bb:\n", (_pSwapchain)->pSwapChainIf, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(PresentEnter)); \

} \

else { \

PVBOXWDDMDISP_ALLOCATION pCurBb = vboxWddmSwapchainGetBb((_pSwapchain))->pAlloc; \

IDirect3DSurface9 *pSurf; \

HRESULT hr = vboxWddmSwapchainSurfGet(_pDevice, _pSwapchain, pCurBb, &pSurf); \

Assert(hr == S_OK); \

vboxVDbgDoDumpRcRect("== "__FUNCTION__" Bb:\n", pCurBb, pSurf, NULL, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(PresentEnter)); \

pSurf->Release(); \

} \

} \

} while (0)

#define VBOXVDBG_DUMP_PRESENT_LEAVE(_pDevice, _pSwapchain) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(PresentLeave)) { \

if (!(_pSwapchain)->fFlags.bRtReportingPresent) { \

vboxVDbgDoDumpFb("<=="__FUNCTION__" Fb:\n", (_pSwapchain)->pSwapChainIf, "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(PresentLeave)); \

} \

else { \

vboxVDbgPrint(("PRESENT_LEAVE: unsupported for Rt Reporting mode\n")); \

} \

} \

} while (0)

#define VBOXVDBG_DUMP_FLUSH(_pDevice) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(Flush)) \

{ \

vboxVDbgDoDumpRt("== "__FUNCTION__": Rt: ", (_pDevice), "", \

VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Flush)); \

}\

} while (0)

#define VBOXVDBG_DUMP_LOCK_ST(_pData) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(Lock) \

|| VBOXVDBG_IS_DUMP_ALLOWED(Unlock) \

) \

{ \

vboxVDbgDoDumpLockSurfTex("== "__FUNCTION__": ", (_pData), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Lock)); \

} \

} while (0)

#define VBOXVDBG_DUMP_UNLOCK_ST(_pData) do { \

if (VBOXVDBG_IS_DUMP_ALLOWED(Unlock) \

) \

{ \

vboxVDbgDoDumpUnlockSurfTex("== "__FUNCTION__": ", (_pData), "", VBOXVDBG_DUMP_FLAGS_FOR_TYPE(Unlock)); \

} \

} while (0)

#define VBOXVDBG_CREATE_CHECK_SWAPCHAIN() do { \

if (g_VBoxVDbgCfgCreateSwapchainOnDdiOnce && g_VBoxVDbgInternalRc) { \

PVBOXWDDMDISP_SWAPCHAIN pSwapchain; \

HRESULT hr = vboxWddmSwapchainCreateIfForRc(g_VBoxVDbgInternalDevice, g_VBoxVDbgInternalRc, &pSwapchain); \

Assert(hr == S_OK); \

g_VBoxVDbgInternalRc = NULL; \

g_VBoxVDbgCfgCreateSwapchainOnDdiOnce = 0; \

} \

} while (0)

#else

#define VBOXVDBG_DUMP_DRAWPRIM_ENTER(_pDevice) do { } while (0)

#define VBOXVDBG_DUMP_DRAWPRIM_LEAVE(_pDevice) do { } while (0)

#define VBOXVDBG_DUMP_SETTEXTURE(_pRc) do { } while (0)

#define VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { } while (0)

#define VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { } while (0)

#define VBOXVDBG_DUMP_BLT_ENTER(_pSrcRc, _pSrcSurf, _pSrcRect, _pDstRc, _pDstSurf, _pDstRect) do { } while (0)

#define VBOXVDBG_DUMP_BLT_LEAVE(_pSrcRc, _pSrcSurf, _pSrcRect, _pDstRc, _pDstSurf, _pDstRect) do { } while (0)

#define VBOXVDBG_DUMP_SYNC_RT(_pBbSurf) do { } while (0)

#define VBOXVDBG_DUMP_FLUSH(_pDevice) do { } while (0)

#define VBOXVDBG_DUMP_LOCK_ST(_pData) do { } while (0)

#define VBOXVDBG_DUMP_UNLOCK_ST(_pData) do { } while (0)

#define VBOXVDBG_DUMP_PRESENT_ENTER(_pDevice, _pSwapchain) do { } while (0)

#define VBOXVDBG_DUMP_PRESENT_LEAVE(_pDevice, _pSwapchain) do { } while (0)

#define VBOXVDBG_BREAK_SHARED(_pRc) do { } while (0)

#define VBOXVDBG_BREAK_SHARED_DEV(_pDevice) do { } while (0)

#define VBOXVDBG_BREAK_DDI() do { } while (0)

#define VBOXVDBG_CHECK_SMSYNC(_pRc) do { } while (0)

#define VBOXVDBG_CHECK_BLT(_opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { _opBlt; } while (0)

#define VBOXVDBG_CHECK_TEXBLT(_opTexBlt, _pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { _opTexBlt; } while (0)

#define VBOXVDBG_ASSERT_IS_DWM(_bDwm) do { } while (0)

#define VBOXVDBG_CHECK_SWAPCHAIN_SYNC(_op, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { _op; } while (0)

#define VBOXVDBG_CREATE_CHECK_SWAPCHAIN() do { } while (0)

#endif

#endif /* #ifndef ___VBoxDispDbg_h__ */