VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h@ 49591

Last change on this file since 49591 was 49591, checked in by vboxsync, 12 years ago

wddm: more on new comand mechanism, guest side almost done, some cleanup
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 32.4 KB
Line 
1/* Copyright (c) 2001, Stanford University
2 * All rights reserved.
3 *
4 * See the file LICENSE.txt for information on redistributing this software.
5 */
6
7#ifndef CR_SERVER_H
8#define CR_SERVER_H
9
10#include "cr_protocol.h"
11#include "cr_glstate.h"
12#include "spu_dispatch_table.h"
13
14#include "state/cr_currentpointers.h"
15
16#include "cr_server.h"
17
18#ifdef VBOX_WITH_CRHGSMI
19# include <VBox/VBoxVideo.h>
20
21#include <iprt/cdefs.h>
22
23RT_C_DECLS_BEGIN
24
25extern uint8_t* g_pvVRamBase;
26extern uint32_t g_cbVRam;
27extern HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion;
28extern PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion;
29
30#define VBOXCRHGSMI_PTR(_off, _t) ((_t*)(g_pvVRamBase + (_off)))
31#define VBOXCRHGSMI_PTR_SAFE(_off, _cb, _t) ((_t*)crServerCrHgsmiPtrGet(_off, _cb))
32
33DECLINLINE(void*) crServerCrHgsmiPtrGet(VBOXVIDEOOFFSET offBuffer, uint32_t cbBuffer)
34{
35 return ((offBuffer) + (cbBuffer) <= g_cbVRam ? VBOXCRHGSMI_PTR(offBuffer, void) : NULL);
36}
37
38DECLINLINE(void) crServerCrHgsmiCmdComplete(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, int cmdProcessingRc)
39{
40 g_pfnCrHgsmiCompletion(g_hCrHgsmiCompletion, pCmd, cmdProcessingRc);
41}
42
43#define VBOXCRHGSMI_CMD_COMPLETE(_pData, _rc) do { \
44 Assert(CRVBOXHGSMI_CMDDATA_IS_HGSMICMD(_pData)); \
45 CRVBOXHGSMI_CMDDATA_ASSERT_ISSET(_pData); \
46 CRVBOXHGSMI_CMDDATA_RC(_pData, _rc); \
47 crServerCrHgsmiCmdComplete((_pData)->pHgsmiCmd, VINF_SUCCESS); \
48 } while (0)
49
50#define VBOXCRHGSMI_CMD_CHECK_COMPLETE(_pData, _rc) do { \
51 Assert(CRVBOXHGSMI_CMDDATA_IS_HGSMICMD(_pData)); \
52 if (CRVBOXHGSMI_CMDDATA_IS_SET(_pData)) { \
53 VBOXCRHGSMI_CMD_COMPLETE(_pData, _rc); \
54 } \
55 } while (0)
56
57#endif
58
59/*
60 * This is the base number for window and context IDs
61 */
62#define MAGIC_OFFSET 5000
63
64extern CRServer cr_server;
65
66/* Semaphore wait queue node */
67typedef struct _wqnode {
68 RunQueue *q;
69 struct _wqnode *next;
70} wqnode;
71
72typedef struct {
73 GLuint count;
74 GLuint num_waiting;
75 RunQueue **waiting;
76} CRServerBarrier;
77
78typedef struct {
79 GLuint count;
80 wqnode *waiting, *tail;
81} CRServerSemaphore;
82
83typedef struct {
84 GLuint id;
85 GLint projParamStart;
86 GLfloat projMat[16]; /* projection matrix, accumulated via calls to */
87 /* glProgramLocalParameterARB, glProgramParameterNV */
88} CRServerProgram;
89
90void crServerSetVBoxConfiguration();
91void crServerSetVBoxConfigurationHGCM();
92void crServerInitDispatch(void);
93void crServerReturnValue( const void *payload, unsigned int payload_len );
94void crServerWriteback(void);
95int crServerRecv( CRConnection *conn, CRMessage *msg, unsigned int len );
96void crServerSerializeRemoteStreams(void);
97void crServerAddToRunQueue( CRClient *client );
98void crServerDeleteClient( CRClient *client );
99
100
101void crServerApplyBaseProjection( const CRmatrix *baseProj );
102void crServerApplyViewMatrix( const CRmatrix *view );
103void crServerSetOutputBounds( const CRMuralInfo *mural, int extNum );
104void crServerComputeViewportBounds( const CRViewportState *v, CRMuralInfo *mural );
105
106GLboolean crServerInitializeBucketing(CRMuralInfo *mural);
107
108void crComputeOverlapGeom(double *quads, int nquad, CRPoly ***res);
109void crComputeKnockoutGeom(double *quads, int nquad, int my_quad_idx, CRPoly **res);
110
111int crServerGetCurrentEye(void);
112
113GLboolean crServerClientInBeginEnd(const CRClient *client);
114
115GLint crServerDispatchCreateContextEx(const char *dpyName, GLint visualBits, GLint shareCtx, GLint preloadCtxID, int32_t internalID);
116GLint crServerDispatchWindowCreateEx(const char *dpyName, GLint visBits, GLint preloadWinID);
117GLint crServerMuralInit(CRMuralInfo *mural, const char *dpyName, GLint visBits, GLint preloadWinID, GLboolean fUseDefaultDEntry);
118void crServerMuralTerm(CRMuralInfo *mural);
119GLboolean crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height);
120void crServerMuralPosition(CRMuralInfo *mural, GLint x, GLint y, GLboolean fSkipCheckGeometry);
121void crServerMuralVisibleRegion( CRMuralInfo *mural, GLint cRects, const GLint *pRects );
122void crServerMuralShow( CRMuralInfo *mural, GLint state );
123int crServerMuralSynchRootVr(CRMuralInfo *mural, bool *pfChanged);
124
125GLint crServerGenerateID(GLint *pCounter);
126
127GLint crServerSPUWindowID(GLint serverWindow);
128
129GLuint crServerTranslateProgramID(GLuint id);
130
131CRMuralInfo * crServerGetDummyMural(GLint visualBits);
132
133void crServerPresentOutputRedirect(CRMuralInfo *pMural);
134void crServerOutputRedirectCheckEnableDisable(CRMuralInfo *pMural);
135
136void crServerCheckMuralGeometry(CRMuralInfo *mural);
137GLboolean crServerSupportRedirMuralFBO(void);
138
139void crVBoxServerNotifyEvent(int32_t idScreen, uint32_t uEvent, void*pvData);
140void crVBoxServerCheckVisibilityEvent(int32_t idScreen);
141
142void crServerDisplayTermAll();
143
144void crServerWindowSize(CRMuralInfo *pMural);
145void crServerWindowShow(CRMuralInfo *pMural);
146void crServerWindowVisibleRegion(CRMuralInfo *pMural);
147void crServerWindowReparent(CRMuralInfo *pMural);
148
149void crServerWindowSetIsVisible(CRMuralInfo *pMural, GLboolean fIsVisible);
150void crServerWindowCheckIsVisible(CRMuralInfo *pMural);
151
152int crVBoxServerUpdateMuralRootVisibleRegion(CRMuralInfo *pMI);
153
154#define CR_SERVER_REDIR_F_NONE 0x00
155/* the data should be displayed on host (unset when is on or when CR_SERVER_REDIR_F_FBO_RAM_VMFB is set) */
156#define CR_SERVER_REDIR_F_DISPLAY 0x01
157/* guest window data get redirected to FBO on host */
158#define CR_SERVER_REDIR_F_FBO 0x02
159/* used with CR_SERVER_REDIR_F_FBO only
160 * indicates that FBO data should be copied to RAM for further processing */
161#define CR_SERVER_REDIR_F_FBO_RAM 0x04
162/* used with CR_SERVER_REDIR_F_FBO_RAM only
163 * indicates that FBO data should be passed to VRDP backend */
164#define CR_SERVER_REDIR_F_FBO_RAM_VRDP 0x08
165/* used with CR_SERVER_REDIR_F_FBO_RAM only
166 * indicates that FBO data should be passed to VM Framebuffer */
167#define CR_SERVER_REDIR_F_FBO_RAM_VMFB 0x10
168/* used with CR_SERVER_REDIR_F_FBO_RAM only
169 * makes the RPW (Read Pixels Worker) mechanism to be used for GPU memory aquisition */
170#define CR_SERVER_REDIR_F_FBO_RPW 0x20
171
172
173#define CR_SERVER_REDIR_F_ALL 0x3f
174
175#define CR_SERVER_REDIR_FGROUP_REQUIRE_FBO (CR_SERVER_REDIR_F_ALL & ~CR_SERVER_REDIR_F_DISPLAY)
176#define CR_SERVER_REDIR_FGROUP_REQUIRE_FBO_RAM (CR_SERVER_REDIR_F_FBO_RAM_VRDP | CR_SERVER_REDIR_F_FBO_RAM_VMFB | CR_SERVER_REDIR_F_FBO_RPW)
177
178DECLINLINE(GLuint) crServerRedirModeAdjust(GLuint value)
179{
180 /* sanitize values */
181 value &= CR_SERVER_REDIR_F_ALL;
182
183 if (value & CR_SERVER_REDIR_FGROUP_REQUIRE_FBO)
184 value |= CR_SERVER_REDIR_F_FBO;
185 if (value & CR_SERVER_REDIR_FGROUP_REQUIRE_FBO_RAM)
186 value |= CR_SERVER_REDIR_F_FBO_RAM;
187
188 return value;
189}
190
191int32_t crServerSetOffscreenRenderingMode(GLuint value);
192void crServerRedirMuralFBO(CRMuralInfo *mural, GLuint redir);
193void crServerDeleteMuralFBO(CRMuralInfo *mural);
194void crServerPresentFBO(CRMuralInfo *mural);
195GLboolean crServerIsRedirectedToFBO();
196GLint crServerMuralFBOIdxFromBufferName(CRMuralInfo *mural, GLenum buffer);
197void crServerMuralFBOSwapBuffers(CRMuralInfo *mural);
198
199void crServerVBoxCompositionDisableEnter(CRMuralInfo *mural);
200void crServerVBoxCompositionDisableLeave(CRMuralInfo *mural, GLboolean fForcePresentOnEnabled);
201void crServerVBoxCompositionPresent(CRMuralInfo *mural);
202DECLINLINE(GLboolean) crServerVBoxCompositionPresentNeeded(CRMuralInfo *mural)
203{
204 return mural->bVisible
205 && mural->width
206 && mural->height
207 && !mural->fRootVrOn ? !CrVrScrCompositorIsEmpty(&mural->Compositor) : !CrVrScrCompositorIsEmpty(&mural->RootVrCompositor);
208}
209
210#define CR_SERVER_FBO_BB_IDX(_mural) ((_mural)->iBbBuffer)
211#define CR_SERVER_FBO_FB_IDX(_mural) (((_mural)->iBbBuffer + 1) % ((_mural)->cBuffers))
212/* returns a valid index to be used for negative _idx, i.e. for GL_NONE cases */
213//#define CR_SERVER_FBO_ADJUST_IDX(_mural, _idx) ((_idx) >= 0 ? (_idx) : CR_SERVER_FBO_BB_IDX(_mural))
214/* just a helper that uses CR_SERVER_FBO_ADJUST_IDX for getting mural's FBO id for buffer index*/
215//#define CR_SERVER_FBO_FOR_IDX(_mural, _idx) ((_mural)->aidFBOs[CR_SERVER_FBO_ADJUST_IDX((_mural), (_idx))])
216//#define CR_SERVER_FBO_TEX_FOR_IDX(_mural, _idx) ((_mural)->aidColorTexs[CR_SERVER_FBO_ADJUST_IDX((_mural), (_idx))])
217#define CR_SERVER_FBO_FOR_IDX(_mural, _idx) ((_idx) >= 0 ? (_mural)->aidFBOs[(_idx)] : 0)
218#define CR_SERVER_FBO_TEX_FOR_IDX(_mural, _idx) ((_idx) >= 0 ? (_mural)->aidColorTexs[(_idx)] : 0)
219
220int32_t crVBoxServerInternalClientRead(CRClient *pClient, uint8_t *pBuffer, uint32_t *pcbBuffer);
221
222PCR_DISPLAY crServerDisplayGetInitialized(uint32_t idScreen);
223
224void crServerPerformMakeCurrent( CRMuralInfo *mural, CRContextInfo *ctxInfo );
225
226PCR_BLITTER crServerVBoxBlitterGet();
227
228DECLINLINE(void) crServerVBoxBlitterWinInit(CR_BLITTER_WINDOW *win, CRMuralInfo *mural)
229{
230 win->Base.id = mural->spuWindow;
231 win->Base.visualBits = mural->CreateInfo.visualBits;
232 win->width = mural->width;
233 win->height = mural->height;
234}
235
236DECLINLINE(void) crServerVBoxBlitterCtxInit(CR_BLITTER_CONTEXT *ctx, CRContextInfo *ctxInfo)
237{
238 ctx->Base.id = ctxInfo->SpuContext;
239 if (ctx->Base.id < 0)
240 ctx->Base.id = cr_server.MainContextInfo.SpuContext;
241 ctx->Base.visualBits = cr_server.curClient->currentCtxInfo->CreateInfo.visualBits;
242}
243
244/* display worker thread.
245 * see comments for CR_SERVER_RPW struct definition in cr_server.h */
246DECLINLINE(void) crServerXchgI8(int8_t *pu8Val1, int8_t *pu8Val2)
247{
248 int8_t tmp;
249 tmp = *pu8Val1;
250 *pu8Val1 = *pu8Val2;
251 *pu8Val2 = tmp;
252}
253
254#ifdef DEBUG_misha
255# define CR_SERVER_RPW_DEBUG
256#endif
257/* *
258 * _name : Draw, Submitted, Worker, Gpu
259 */
260
261#ifdef CR_SERVER_RPW_DEBUG
262# define crServerRpwEntryDbgVerify(_pE) crServerRpwEntryDbgDoVerify(_pE)
263#else
264# define crServerRpwEntryDbgVerify(_pE) do {} while (0)
265#endif
266
267
268#define CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _name) ((_pEntry)->iTex##_name > 0)
269
270#define CR_SERVER_RPW_ENTRY_TEX_INVALIDATE(_pEntry, _name) do { \
271 crServerRpwEntryDbgVerify(_pEntry); \
272 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _name)); \
273 (_pEntry)->iTex##_name = -(_pEntry)->iTex##_name; \
274 crServerRpwEntryDbgVerify(_pEntry); \
275 } while (0)
276
277#define CR_SERVER_RPW_ENTRY_TEX_PROMOTE(_pEntry, _fromName, _toName) do { \
278 crServerRpwEntryDbgVerify(_pEntry); \
279 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
280 Assert(!CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
281 crServerXchgI8(&(_pEntry)->iTex##_fromName, &(_pEntry)->iTex##_toName); \
282 crServerRpwEntryDbgVerify(_pEntry); \
283 } while (0)
284
285#define CR_SERVER_RPW_ENTRY_TEX_XCHG_VALID(_pEntry, _fromName, _toName) do { \
286 crServerRpwEntryDbgVerify(_pEntry); \
287 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
288 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
289 crServerXchgI8(&(_pEntry)->iTex##_fromName, &(_pEntry)->iTex##_toName); \
290 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
291 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
292 crServerRpwEntryDbgVerify(_pEntry); \
293 } while (0)
294
295
296#define CR_SERVER_RPW_ENTRY_TEX_PROMOTE_KEEPVALID(_pEntry, _fromName, _toName) do { \
297 crServerRpwEntryDbgVerify(_pEntry); \
298 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
299 Assert(!CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
300 crServerXchgI8(&(_pEntry)->iTex##_fromName, &(_pEntry)->iTex##_toName); \
301 (_pEntry)->iTex##_fromName = -(_pEntry)->iTex##_fromName; \
302 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
303 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
304 crServerRpwEntryDbgVerify(_pEntry); \
305 } while (0)
306
307#define CR_SERVER_RPW_ENTRY_TEX(_pEntry, _name) ((_pEntry)->aidWorkerTexs[(_pEntry)->iTex##_name - 1])
308
309#define CR_SERVER_RPW_ENTRY_PBO_NEXT_ID(_i) (((_i) + 1) % 2)
310#define CR_SERVER_RPW_ENTRY_PBO_IS_ACTIVE(_pEntry) ((_pEntry)->iCurPBO >= 0)
311#define CR_SERVER_RPW_ENTRY_PBO_CUR(_pEntry) ((_pEntry)->aidPBOs[(_pEntry)->iCurPBO])
312#define CR_SERVER_RPW_ENTRY_PBO_COMPLETED(_pEntry) ((_pEntry)->aidPBOs[CR_SERVER_RPW_ENTRY_PBO_NEXT_ID((_pEntry)->iCurPBO)])
313#define CR_SERVER_RPW_ENTRY_PBO_FLIP(_pEntry) do { \
314 (_pEntry)->iCurPBO = CR_SERVER_RPW_ENTRY_PBO_NEXT_ID((_pEntry)->iCurPBO); \
315 } while (0)
316
317#ifdef CR_SERVER_RPW_DEBUG
318DECLINLINE(void) crServerRpwEntryDbgDoVerify(CR_SERVER_RPW_ENTRY *pEntry)
319{
320 int tstMask = 0;
321 int8_t iVal;
322 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(pEntry, Draw));
323
324#define CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(_v) do { \
325 iVal = RT_ABS(_v); \
326 Assert(iVal > 0); \
327 Assert(iVal < 5); \
328 Assert(!(tstMask & (1 << iVal))); \
329 tstMask |= (1 << iVal); \
330 } while (0)
331
332 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexDraw);
333 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexSubmitted);
334 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexWorker);
335 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexGpu);
336 Assert(tstMask == 0x1E);
337}
338#endif
339
340DECLINLINE(bool) crServerRpwIsInitialized(const CR_SERVER_RPW *pWorker)
341{
342 return !!pWorker->ctxId;
343}
344int crServerRpwInit(CR_SERVER_RPW *pWorker);
345int crServerRpwTerm(CR_SERVER_RPW *pWorker);
346DECLINLINE(bool) crServerRpwEntryIsInitialized(const CR_SERVER_RPW_ENTRY *pEntry)
347{
348 return !!pEntry->pfnData;
349}
350int crServerRpwEntryInit(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry, uint32_t width, uint32_t height, PFNCR_SERVER_RPW_DATA pfnData);
351int crServerRpwEntryCleanup(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
352int crServerRpwEntryResize(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry, uint32_t width, uint32_t height);
353int crServerRpwEntrySubmit(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
354int crServerRpwEntryWaitComplete(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
355int crServerRpwEntryCancel(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
356DECLINLINE(void) crServerRpwEntryDrawSettingsToTex(const CR_SERVER_RPW_ENTRY *pEntry, VBOXVR_TEXTURE *pTex)
357{
358 pTex->width = pEntry->Size.cx;
359 pTex->height = pEntry->Size.cy;
360 pTex->target = GL_TEXTURE_2D;
361 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(pEntry, Draw));
362 pTex->hwid = CR_SERVER_RPW_ENTRY_TEX(pEntry, Draw);
363}
364/**/
365
366typedef struct CR_SERVER_CTX_SWITCH
367{
368 GLuint idDrawFBO, idReadFBO;
369 CRContext *pNewCtx;
370 CRContext *pOldCtx;
371} CR_SERVER_CTX_SWITCH;
372
373DECLINLINE(void) crServerCtxSwitchPrepare(CR_SERVER_CTX_SWITCH *pData, CRContext *pNewCtx)
374{
375 CRMuralInfo *pCurrentMural = cr_server.currentMural;
376 CRContextInfo *pCurCtxInfo = cr_server.currentCtxInfo;
377 GLuint idDrawFBO, idReadFBO;
378 CRContext *pCurCtx = pCurCtxInfo ? pCurCtxInfo->pContext : NULL;
379
380 CRASSERT(pCurCtx == crStateGetCurrent());
381
382 if (pCurrentMural)
383 {
384 idDrawFBO = CR_SERVER_FBO_FOR_IDX(pCurrentMural, pCurrentMural->iCurDrawBuffer);
385 idReadFBO = CR_SERVER_FBO_FOR_IDX(pCurrentMural, pCurrentMural->iCurReadBuffer);
386 }
387 else
388 {
389 idDrawFBO = 0;
390 idReadFBO = 0;
391 }
392
393 crStateSwitchPrepare(pNewCtx, pCurCtx, idDrawFBO, idReadFBO);
394
395 pData->idDrawFBO = idDrawFBO;
396 pData->idReadFBO = idReadFBO;
397 pData->pNewCtx = pNewCtx;
398 pData->pOldCtx = pCurCtx;
399}
400
401DECLINLINE(void) crServerCtxSwitchPostprocess(CR_SERVER_CTX_SWITCH *pData)
402{
403 crStateSwitchPostprocess(pData->pOldCtx, pData->pNewCtx, pData->idDrawFBO, pData->idReadFBO);
404}
405
406void crServerInitTmpCtxDispatch();
407
408int crServerVBoxParseNumerics(const char *pszStr, const int defaultVal);
409
410void CrDpRootUpdate(PCR_DISPLAY pDisplay);
411void CrDpEnter(PCR_DISPLAY pDisplay);
412void CrDpLeave(PCR_DISPLAY pDisplay);
413int CrDpInit(PCR_DISPLAY pDisplay);
414void CrDpTerm(PCR_DISPLAY pDisplay);
415
416DECLINLINE(bool) CrDpIsEmpty(PCR_DISPLAY pDisplay)
417{
418 return CrVrScrCompositorIsEmpty(&pDisplay->Mural.Compositor);
419}
420
421int CrDpSaveState(PCR_DISPLAY pDisplay, PSSMHANDLE pSSM);
422int CrDpLoadState(PCR_DISPLAY pDisplay, PSSMHANDLE pSSM, uint32_t version);
423
424void CrDpReparent(PCR_DISPLAY pDisplay, CRScreenInfo *pScreen);
425
426void CrDpResize(PCR_DISPLAY pDisplay, int32_t xPos, int32_t yPos, uint32_t width, uint32_t height);
427void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const VBOXVR_TEXTURE *pTextureData, uint32_t fFlags, PFNVBOXVRSCRCOMPOSITOR_ENTRY_RELEASED pfnEntryReleased);
428void CrDpEntryCleanup(PCR_DISPLAY_ENTRY pEntry);
429int CrDpEntryRegionsSet(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
430int CrDpEntryRegionsAdd(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, CR_DISPLAY_ENTRY_MAP *pMap);
431void CrDpRegionsClear(PCR_DISPLAY pDisplay);
432DECLINLINE(bool) CrDpEntryIsUsed(PCR_DISPLAY_ENTRY pEntry)
433{
434 return CrVrScrCompositorEntryIsInList(&pEntry->CEntry);
435}
436
437DECLINLINE(CRMuralInfo*) CrDpGetMural(PCR_DISPLAY pDisplay)
438{
439 return &pDisplay->Mural;
440}
441
442int CrDemGlobalInit();
443void CrDemTeGlobalTerm();
444void CrDemEnter(PCR_DISPLAY_ENTRY_MAP pMap);
445void CrDemLeave(PCR_DISPLAY_ENTRY_MAP pMap, PCR_DISPLAY_ENTRY pNewEntry, PCR_DISPLAY_ENTRY pReplacedEntry);
446int CrDemInit(PCR_DISPLAY_ENTRY_MAP pMap);
447void CrDemTerm(PCR_DISPLAY_ENTRY_MAP pMap);
448PCR_DISPLAY_ENTRY CrDemEntryAcquire(PCR_DISPLAY_ENTRY_MAP pMap, GLuint idTexture, uint32_t fFlags);
449void CrDemEntryRelease(PCR_DISPLAY_ENTRY pEntry);
450int CrDemEntrySaveState(PCR_DISPLAY_ENTRY pEntry, PSSMHANDLE pSSM);
451int CrDemEntryLoadState(PCR_DISPLAY_ENTRY_MAP pMap, PCR_DISPLAY_ENTRY *ppEntry, PSSMHANDLE pSSM);
452
453int crServerDisplaySaveState(PSSMHANDLE pSSM);
454int crServerDisplayLoadState(PSSMHANDLE pSSM, uint32_t u32Version);
455
456
457void crServerDEntryResized(CRMuralInfo *pMural, CR_DISPLAY_ENTRY *pDEntry);
458void crServerDEntryMoved(CRMuralInfo *pMural, CR_DISPLAY_ENTRY *pDEntry);
459void crServerDEntryVibleRegions(CRMuralInfo *pMural, CR_DISPLAY_ENTRY *pDEntry);
460void crServerDEntryCheckFBO(CRMuralInfo *pMural, CR_DISPLAY_ENTRY *pDEntry, CRContext *ctx);
461
462void crServerDEntryAllResized(CRMuralInfo *pMural);
463void crServerDEntryAllMoved(CRMuralInfo *pMural);
464void crServerDEntryAllVibleRegions(CRMuralInfo *pMural);
465
466//#define VBOX_WITH_CRSERVER_DUMPER
467#ifdef VBOX_WITH_CRSERVER_DUMPER
468void crServerDumpCheckTerm();
469int crServerDumpCheckInit();
470void crServerDumpBuffer(int idx);
471void crServerDumpTextures();
472void crServerDumpTexture(const VBOXVR_TEXTURE *pTex);
473void crServerDumpShader(GLint id);
474void crServerDumpProgram(GLint id);
475void crServerDumpCurrentProgram();
476void crServerDumpRecompileDumpCurrentProgram();
477void crServerRecompileCurrentProgram();
478void crServerDumpCurrentProgramUniforms();
479void crServerDumpCurrentProgramAttribs();
480void crServerDumpFramesCheck();
481void crServerDumpState();
482void crServerDumpDrawel(const char*pszFormat, ...);
483void crServerDumpDrawelv(GLuint idx, const char*pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal);
484
485extern int64_t g_CrDbgDumpPid;
486extern unsigned long g_CrDbgDumpEnabled;
487extern unsigned long g_CrDbgDumpDraw;
488extern unsigned long g_CrDbgDumpDrawFramesSettings;
489extern unsigned long g_CrDbgDumpDrawFramesAppliedSettings;
490extern unsigned long g_CrDbgDumpDrawFramesCount;
491
492extern uint32_t g_CrDbgDumpVertattrFixupOn;
493
494bool crServerDumpFilterDmp(unsigned long event, CR_DUMPER *pDumper);
495bool crServerDumpFilterOpEnter(unsigned long event, CR_DUMPER *pDumper);
496void crServerDumpFilterOpLeave(unsigned long event, CR_DUMPER *pDumper);
497
498//#define CR_SERVER_DUMP_MASK_OP 0x0000fffc
499//#define CR_SERVER_DUMP_OFF_OP 2
500//
501//#define CR_SERVER_DUMP_MASK_DIR 0x00000003
502//#define CR_SERVER_DUMP_OFF_DIR 0
503//
504//#define CR_SERVER_DUMP_MASK_DMP 0xffff0000
505//#define CR_SERVER_DUMP_OFF_DMP 16
506//
507//#define CR_SERVER_DUMP_MAKE_OP(_v) (1 << ((_v) + CR_SERVER_DUMP_OFF_OP))
508//#define CR_SERVER_DUMP_MAKE_DIR(_v) (1 << ((_v) + CR_SERVER_DUMP_OFF_DIR))
509//#define CR_SERVER_DUMP_MAKE_DMP(_v) (1 << ((_v) + CR_SERVER_DUMP_OFF_DMP))
510//
511//#define CR_SERVER_DUMP_GET_OP(_v) ((_v) & CR_SERVER_DUMP_MASK_OP)
512//#define CR_SERVER_DUMP_GET_DMP(_v) ((_v) & CR_SERVER_DUMP_MASK_DMP)
513//#define CR_SERVER_DUMP_GET_DIR(_v) ((_v) & CR_SERVER_DUMP_MASK_DIR)
514//
515//#define CR_SERVER_DUMP_ISANY_OP(_v1, _v2) (!!(CR_SERVER_DUMP_GET_OP(_v1) & CR_SERVER_DUMP_GET_OP(_v2)))
516//#define CR_SERVER_DUMP_ISANY_DIR(_v1, _v2) (!!(CR_SERVER_DUMP_GET_DIR(_v1) & CR_SERVER_DUMP_GET_DIR(_v2)))
517//#define CR_SERVER_DUMP_ISANY_DMP(_v1, _v2) (!!(CR_SERVER_DUMP_GET_DMP(_v1) & CR_SERVER_DUMP_GET_DMP(_v2)))
518//
519//#define CR_SERVER_DUMP_ISANY_OP(_v1, _v2) ((CR_SERVER_DUMP_GET_OP(_v1) & CR_SERVER_DUMP_GET_OP(_v2)) == CR_SERVER_DUMP_GET_OP(_v2))
520//#define CR_SERVER_DUMP_ISANY_DIR(_v1, _v2) ((CR_SERVER_DUMP_GET_DIR(_v1) & CR_SERVER_DUMP_GET_DIR(_v2)) == CR_SERVER_DUMP_GET_DIR(_v2))
521//#define CR_SERVER_DUMP_ISANY_DMP(_v1, _v2) ((CR_SERVER_DUMP_GET_DMP(_v1) & CR_SERVER_DUMP_GET_DMP(_v2)) == CR_SERVER_DUMP_GET_DMP(_v2))
522//
523//#define CR_SERVER_DUMP_F_DIR_ENTER CR_SERVER_DUMP_MAKE_DIR(0)
524//#define CR_SERVER_DUMP_F_DIR_LEAVE CR_SERVER_DUMP_MAKE_DIR(1)
525//
526//#define CR_SERVER_DUMP_F_OP_DRAW CR_SERVER_DUMP_MAKE_OP(0)
527//#define CR_SERVER_DUMP_F_OP_SWAPBUFFERS CR_SERVER_DUMP_MAKE_OP(1)
528//#define CR_SERVER_DUMP_F_OP_LINK_PROGRAM CR_SERVER_DUMP_MAKE_OP(2)
529//#define CR_SERVER_DUMP_F_OP_COMPILE_PROGRAM CR_SERVER_DUMP_MAKE_OP(3)
530//
531//#define CR_SERVER_DUMP_F_DMP_BUFF CR_SERVER_DUMP_MAKE_DMP(0)
532//#define CR_SERVER_DUMP_F_DMP_TEX CR_SERVER_DUMP_MAKE_DMP(0)
533//#define CR_SERVER_DUMP_F_DMP_PROGRAM CR_SERVER_DUMP_MAKE_DMP(0)
534//#define CR_SERVER_DUMP_F_DMP_PROGRAM_UNIFORMS CR_SERVER_DUMP_MAKE_DMP(0)
535//#define CR_SERVER_DUMP_F_DMP_STATE CR_SERVER_DUMP_MAKE_DMP(0)
536//
537//#define CR_SERVER_DUMP_GET_OP(_v) ((_v) & CR_SERVER_DUMP_MASK_OP)
538//#define CR_SERVER_DUMP_GET_DMP(_v) ((_v) & CR_SERVER_DUMP_MASK_DMP)
539//#define CR_SERVER_DUMP_GET_DIR(_v) ((_v) & CR_SERVER_DUMP_MASK_DIR)
540
541#define CR_SERVER_DUMP_F_DRAW_BUFF_ENTER 0x00000001
542#define CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE 0x00000002
543#define CR_SERVER_DUMP_F_DRAW_STATE_ENTER 0x00000004
544#define CR_SERVER_DUMP_F_DRAW_STATE_LEAVE 0x00000008
545#define CR_SERVER_DUMP_F_DRAW_TEX_ENTER 0x00000010
546#define CR_SERVER_DUMP_F_DRAW_TEX_LEAVE 0x00000020
547#define CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER 0x00000040
548#define CR_SERVER_DUMP_F_DRAW_PROGRAM_LEAVE 0x00000080
549#define CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER 0x00000100
550#define CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_LEAVE 0x00000200
551#define CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER 0x00000400
552#define CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_LEAVE 0x00000800
553
554#define CR_SERVER_DUMP_F_DRAW_ENTER_ALL (CR_SERVER_DUMP_F_DRAW_BUFF_ENTER \
555 | CR_SERVER_DUMP_F_DRAW_TEX_ENTER \
556 | CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER \
557 | CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER \
558 | CR_SERVER_DUMP_F_DRAW_STATE_ENTER \
559 | CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER)
560
561#define CR_SERVER_DUMP_F_DRAW_LEAVE_ALL (CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE \
562 | CR_SERVER_DUMP_F_DRAW_TEX_LEAVE \
563 | CR_SERVER_DUMP_F_DRAW_PROGRAM_LEAVE \
564 | CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_LEAVE \
565 | CR_SERVER_DUMP_F_DRAW_STATE_LEAVE \
566 | CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_LEAVE)
567
568#define CR_SERVER_DUMP_F_DRAW_ALL (CR_SERVER_DUMP_F_DRAW_ENTER_ALL | CR_SERVER_DUMP_F_DRAW_LEAVE_ALL)
569
570#define CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER 0x00010000
571#define CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE 0x00020000
572#define CR_SERVER_DUMP_F_TEXPRESENT 0x00040000
573#define CR_SERVER_DUMP_F_DRAWEL 0x00100000
574#define CR_SERVER_DUMP_F_COMPILE_SHADER 0x01000000
575#define CR_SERVER_DUMP_F_SHADER_SOURCE 0x02000000
576#define CR_SERVER_DUMP_F_LINK_PROGRAM 0x04000000
577
578
579#define CR_SERVER_DUMP_DEFAULT_FILTER_OP(_ev) ((((_ev) & g_CrDbgDumpDraw) != 0) \
580 || ((_ev) == CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER && g_CrDbgDumpDrawFramesCount))
581
582#define CR_SERVER_DUMP_DEFAULT_FILTER_DMP(_ev) (((_ev) & g_CrDbgDumpDraw) != 0)
583
584#define CR_SERVER_DUMP_FILTER_OP(_ev, _pDumper) (g_CrDbgDumpEnabled \
585 && (!g_CrDbgDumpPid \
586 || (g_CrDbgDumpPid > 0 && ((uint64_t)g_CrDbgDumpPid) == cr_server.curClient->pid) \
587 || (g_CrDbgDumpPid < 0 && ((uint64_t)(-g_CrDbgDumpPid)) != cr_server.curClient->pid)) \
588 && crServerDumpFilterOpEnter((_ev), (_pDumper)))
589#define CR_SERVER_DUMP_FILTER_DMP(_ev, _pDumper) (crServerDumpFilterDmp((_ev), (_pDumper)))
590
591#define CR_SERVER_DUMP_DRAW_ENTER() do { \
592 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAW_ENTER_ALL, cr_server.Recorder.pDumper)) break; \
593 crServerDumpCheckInit(); \
594 crDmpStrF(cr_server.Recorder.pDumper, "==ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
595 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_STATE_ENTER, cr_server.Recorder.pDumper)) { crServerDumpState(); } \
596 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgram(); } \
597 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramUniforms(); } \
598 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramAttribs(); } \
599 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_TEX_ENTER, cr_server.Recorder.pDumper)) { crServerDumpTextures(); } \
600 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_BUFF_ENTER, cr_server.Recorder.pDumper)) { crServerDumpBuffer(-1); } \
601 crDmpStrF(cr_server.Recorder.pDumper, "==Done ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
602 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAW_ENTER_ALL, cr_server.Recorder.pDumper); \
603 } while (0)
604
605#define CR_SERVER_DUMP_DRAW_LEAVE() do { \
606 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAW_LEAVE_ALL, cr_server.Recorder.pDumper)) break; \
607 crServerDumpCheckInit(); \
608 crDmpStrF(cr_server.Recorder.pDumper, "==LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
609 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_TEX_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpTextures(); } \
610 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpBuffer(-1); } \
611 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramUniforms(); } \
612 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramAttribs(); } \
613 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgram(); } \
614 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_STATE_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpState(); } \
615 crDmpStrF(cr_server.Recorder.pDumper, "==Done LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
616 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAW_LEAVE_ALL, cr_server.Recorder.pDumper); \
617 } while (0)
618
619#define CR_SERVER_DUMP_COMPILE_SHADER(_id) do { \
620 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_COMPILE_SHADER, cr_server.Recorder.pDumper)) break; \
621 crServerDumpCheckInit(); \
622 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
623 crServerDumpShader((_id)); \
624 crDmpStrF(cr_server.Recorder.pDumper, "==Done[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
625 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_COMPILE_SHADER, cr_server.Recorder.pDumper); \
626 } while (0)
627
628#define CR_SERVER_DUMP_SHADER_SOURCE(_id) do { \
629 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SHADER_SOURCE, cr_server.Recorder.pDumper)) break; \
630 crServerDumpCheckInit(); \
631 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
632 crServerDumpShader((_id)); \
633 crDmpStrF(cr_server.Recorder.pDumper, "==Done[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
634 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_SHADER_SOURCE, cr_server.Recorder.pDumper); \
635 } while (0)
636
637#define CR_SERVER_DUMP_LINK_PROGRAM(_id) do { \
638 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_LINK_PROGRAM, cr_server.Recorder.pDumper)) break; \
639 crServerDumpCheckInit(); \
640 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
641 crServerDumpProgram((_id)); \
642 crDmpStrF(cr_server.Recorder.pDumper, "==Done[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
643 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_LINK_PROGRAM, cr_server.Recorder.pDumper); \
644 } while (0)
645
646#define CR_SERVER_DUMP_SWAPBUFFERS_ENTER() do { \
647 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER, cr_server.Recorder.pDumper)) break; \
648 crServerDumpCheckInit(); \
649 crDmpStrF(cr_server.Recorder.pDumper, "==ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
650 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER, cr_server.Recorder.pDumper)) { crServerDumpBuffer(CR_SERVER_FBO_BB_IDX(cr_server.currentMural)); } \
651 if (g_CrDbgDumpDrawFramesCount) { crServerDumpFramesCheck(); } \
652 crDmpStrF(cr_server.Recorder.pDumper, "==Done ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
653 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER, cr_server.Recorder.pDumper); \
654 } while (0)
655
656#define CR_SERVER_DUMP_TEXPRESENT(_pTex) do { \
657 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_TEXPRESENT, cr_server.Recorder.pDumper)) break; \
658 crServerDumpCheckInit(); \
659 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
660 crServerDumpTexture((_pTex)); \
661 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_TEXPRESENT, cr_server.Recorder.pDumper); \
662 } while (0)
663
664#define CR_SERVER_DUMP_SWAPBUFFERS_LEAVE() do { \
665 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE, cr_server.Recorder.pDumper)) break; \
666 crDmpStrF(cr_server.Recorder.pDumper, "==LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
667 crServerDumpCheckInit(); \
668 crDmpStrF(cr_server.Recorder.pDumper, "==Done LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
669 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE, cr_server.Recorder.pDumper); \
670 } while (0)
671
672#define CR_SERVER_DUMP_DRAWEL_F(_msg) do { \
673 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper)) break; \
674 crServerDumpCheckInit(); \
675 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
676 crServerDumpDrawel _msg; \
677 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper); \
678 } while (0)
679
680#define CR_SERVER_DUMP_DRAWEL_V(_index, _pszElFormat, _cbEl, _pvVal, _cVal) do { \
681 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper)) break; \
682 crServerDumpCheckInit(); \
683 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
684 crServerDumpDrawelv((_index), (_pszElFormat), (_cbEl), (_pvVal), (_cVal)); \
685 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper); \
686 } while (0)
687#else /* if !defined VBOX_WITH_CRSERVER_DUMPER */
688#define CR_SERVER_DUMP_DRAW_ENTER() do {} while (0)
689#define CR_SERVER_DUMP_DRAW_LEAVE() do {} while (0)
690#define CR_SERVER_DUMP_COMPILE_SHADER(_id) do {} while (0)
691#define CR_SERVER_DUMP_LINK_PROGRAM(_id) do {} while (0)
692#define CR_SERVER_DUMP_TEXPRESENT(_pTex) do {} while (0)
693#define CR_SERVER_DUMP_SWAPBUFFERS_ENTER() do {} while (0)
694#define CR_SERVER_DUMP_SWAPBUFFERS_LEAVE() do {} while (0)
695#define CR_SERVER_DUMP_SHADER_SOURCE(_id) do {} while (0)
696#define CR_SERVER_DUMP_DRAWEL_F(_msg) do {} while (0)
697#define CR_SERVER_DUMP_DRAWEL_V(_index, _pszElFormat, _cbEl, _pvVal, _cVal) do {} while (0)
698#endif /* !VBOX_WITH_CRSERVER_DUMPER */
699
700RT_C_DECLS_END
701
702#endif /* CR_SERVER_H */
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette