VirtualBox

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

Last change on this file since 50280 was 50280, checked in by vboxsync, 11 years ago

crOpenGL: init/cleanup fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 31.6 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#include <cr_htable.h>
18#include <cr_compositor.h>
19
20#ifdef VBOX_WITH_CRHGSMI
21# include <VBox/VBoxVideo.h>
22
23#include <iprt/cdefs.h>
24
25RT_C_DECLS_BEGIN
26
27extern uint8_t* g_pvVRamBase;
28extern uint32_t g_cbVRam;
29extern HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion;
30extern PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion;
31
32#define VBOXCRHGSMI_PTR(_off, _t) ((_t*)(g_pvVRamBase + (_off)))
33#define VBOXCRHGSMI_PTR_SAFE(_off, _cb, _t) ((_t*)crServerCrHgsmiPtrGet(_off, _cb))
34
35DECLINLINE(void*) crServerCrHgsmiPtrGet(VBOXVIDEOOFFSET offBuffer, uint32_t cbBuffer)
36{
37 return ((offBuffer) + (cbBuffer) <= g_cbVRam ? VBOXCRHGSMI_PTR(offBuffer, void) : NULL);
38}
39
40DECLINLINE(void) crServerCrHgsmiCmdComplete(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, int cmdProcessingRc)
41{
42 g_pfnCrHgsmiCompletion(g_hCrHgsmiCompletion, pCmd, cmdProcessingRc);
43}
44
45#define VBOXCRHGSMI_CMD_COMPLETE(_pData, _rc) do { \
46 Assert(CRVBOXHGSMI_CMDDATA_IS_HGSMICMD(_pData)); \
47 CRVBOXHGSMI_CMDDATA_ASSERT_ISSET(_pData); \
48 CRVBOXHGSMI_CMDDATA_RC(_pData, _rc); \
49 crServerCrHgsmiCmdComplete((_pData)->pHgsmiCmd, VINF_SUCCESS); \
50 } while (0)
51
52#define VBOXCRHGSMI_CMD_CHECK_COMPLETE(_pData, _rc) do { \
53 if (CRVBOXHGSMI_CMDDATA_IS_SET(_pData)) { \
54 VBOXCRHGSMI_CMD_COMPLETE(_pData, _rc); \
55 } \
56 } while (0)
57
58#endif
59
60/*
61 * This is the base number for window and context IDs
62 */
63#define MAGIC_OFFSET 5000
64
65extern CRServer cr_server;
66
67/* Semaphore wait queue node */
68typedef struct _wqnode {
69 RunQueue *q;
70 struct _wqnode *next;
71} wqnode;
72
73typedef struct {
74 GLuint count;
75 GLuint num_waiting;
76 RunQueue **waiting;
77} CRServerBarrier;
78
79typedef struct {
80 GLuint count;
81 wqnode *waiting, *tail;
82} CRServerSemaphore;
83
84typedef struct {
85 GLuint id;
86 GLint projParamStart;
87 GLfloat projMat[16]; /* projection matrix, accumulated via calls to */
88 /* glProgramLocalParameterARB, glProgramParameterNV */
89} CRServerProgram;
90
91void crServerSetVBoxConfiguration();
92void crServerSetVBoxConfigurationHGCM();
93void crServerInitDispatch(void);
94void crServerReturnValue( const void *payload, unsigned int payload_len );
95void crServerWriteback(void);
96int crServerRecv( CRConnection *conn, CRMessage *msg, unsigned int len );
97void crServerSerializeRemoteStreams(void);
98void crServerAddToRunQueue( CRClient *client );
99void crServerDeleteClient( CRClient *client );
100
101
102void crServerApplyBaseProjection( const CRmatrix *baseProj );
103void crServerApplyViewMatrix( const CRmatrix *view );
104void crServerSetOutputBounds( const CRMuralInfo *mural, int extNum );
105void crServerComputeViewportBounds( const CRViewportState *v, CRMuralInfo *mural );
106
107GLboolean crServerInitializeBucketing(CRMuralInfo *mural);
108
109void crComputeOverlapGeom(double *quads, int nquad, CRPoly ***res);
110void crComputeKnockoutGeom(double *quads, int nquad, int my_quad_idx, CRPoly **res);
111
112int crServerGetCurrentEye(void);
113
114GLboolean crServerClientInBeginEnd(const CRClient *client);
115
116GLint crServerDispatchCreateContextEx(const char *dpyName, GLint visualBits, GLint shareCtx, GLint preloadCtxID, int32_t internalID);
117GLint crServerDispatchWindowCreateEx(const char *dpyName, GLint visBits, GLint preloadWinID);
118GLint crServerMuralInit(CRMuralInfo *mural, const char *dpyName, GLint visBits, GLint preloadWinID);
119void crServerMuralTerm(CRMuralInfo *mural);
120GLboolean crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height);
121void crServerMuralPosition(CRMuralInfo *mural, GLint x, GLint y);
122void crServerMuralVisibleRegion( CRMuralInfo *mural, GLint cRects, const GLint *pRects );
123void crServerMuralShow( CRMuralInfo *mural, GLint state );
124
125GLint crServerGenerateID(GLint *pCounter);
126
127GLint crServerSPUWindowID(GLint serverWindow);
128
129GLuint crServerTranslateProgramID(GLuint id);
130
131CRMuralInfo * crServerGetDummyMural(GLint visualBits);
132
133void crServerCheckMuralGeometry(CRMuralInfo *mural);
134void crServerCheckAllMuralGeometry(CRMuralInfo *pMI);
135GLboolean crServerSupportRedirMuralFBO(void);
136
137void crVBoxServerMuralFbResizeBegin(HCR_FRAMEBUFFER hFb);
138void crVBoxServerMuralFbResizeEnd(HCR_FRAMEBUFFER hFb);
139
140void crVBoxServerNotifyEvent(int32_t idScreen, uint32_t uEvent, void*pvData);
141
142void crServerRedirMuralFbClear(CRMuralInfo *mural);
143
144void crServerWindowReparent(CRMuralInfo *pMural);
145
146void crServerRedirMuralFBO(CRMuralInfo *mural, bool fEnabled);
147void crServerDeleteMuralFBO(CRMuralInfo *mural);
148void crServerPresentFBO(CRMuralInfo *mural);
149GLboolean crServerIsRedirectedToFBO();
150GLint crServerMuralFBOIdxFromBufferName(CRMuralInfo *mural, GLenum buffer);
151void crServerMuralFBOSwapBuffers(CRMuralInfo *mural);
152
153HCR_FRAMEBUFFER CrPMgrFbGetFirstEnabled();
154HCR_FRAMEBUFFER CrPMgrFbGetNextEnabled(HCR_FRAMEBUFFER hFb);
155HCR_FRAMEBUFFER CrPMgrFbGetFirstInitialized();
156HCR_FRAMEBUFFER CrPMgrFbGetNextInitialized(HCR_FRAMEBUFFER hFb);
157
158
159#define CR_SERVER_FBO_BB_IDX(_mural) ((_mural)->iBbBuffer)
160#define CR_SERVER_FBO_FB_IDX(_mural) (((_mural)->iBbBuffer + 1) % ((_mural)->cBuffers))
161/* returns a valid index to be used for negative _idx, i.e. for GL_NONE cases */
162//#define CR_SERVER_FBO_ADJUST_IDX(_mural, _idx) ((_idx) >= 0 ? (_idx) : CR_SERVER_FBO_BB_IDX(_mural))
163/* just a helper that uses CR_SERVER_FBO_ADJUST_IDX for getting mural's FBO id for buffer index*/
164//#define CR_SERVER_FBO_FOR_IDX(_mural, _idx) ((_mural)->aidFBOs[CR_SERVER_FBO_ADJUST_IDX((_mural), (_idx))])
165//#define CR_SERVER_FBO_TEX_FOR_IDX(_mural, _idx) ((_mural)->aidColorTexs[CR_SERVER_FBO_ADJUST_IDX((_mural), (_idx))])
166#define CR_SERVER_FBO_FOR_IDX(_mural, _idx) ((_idx) >= 0 ? (_mural)->aidFBOs[(_idx)] : 0)
167#define CR_SERVER_FBO_TEX_FOR_IDX(_mural, _idx) ((_idx) >= 0 ? (_mural)->aidColorTexs[(_idx)] : 0)
168
169int32_t crVBoxServerInternalClientRead(CRClient *pClient, uint8_t *pBuffer, uint32_t *pcbBuffer);
170
171void crServerPerformMakeCurrent( CRMuralInfo *mural, CRContextInfo *ctxInfo );
172
173PCR_BLITTER crServerVBoxBlitterGet();
174PCR_BLITTER crServerVBoxBlitterGetInitialized();
175
176DECLINLINE(void) crServerVBoxBlitterWinInit(CR_BLITTER_WINDOW *win, CRMuralInfo *mural)
177{
178 win->Base.id = mural->spuWindow;
179 win->Base.visualBits = mural->CreateInfo.realVisualBits;
180 win->width = mural->width;
181 win->height = mural->height;
182}
183
184DECLINLINE(void) crServerVBoxBlitterCtxInit(CR_BLITTER_CONTEXT *ctx, CRContextInfo *ctxInfo)
185{
186 ctx->Base.id = ctxInfo->SpuContext;
187 if (ctx->Base.id < 0)
188 ctx->Base.id = cr_server.MainContextInfo.SpuContext;
189 ctx->Base.visualBits = cr_server.curClient->currentCtxInfo->CreateInfo.realVisualBits;
190}
191
192/* display worker thread.
193 * see comments for CR_SERVER_RPW struct definition in cr_server.h */
194DECLINLINE(void) crServerXchgI8(int8_t *pu8Val1, int8_t *pu8Val2)
195{
196 int8_t tmp;
197 tmp = *pu8Val1;
198 *pu8Val1 = *pu8Val2;
199 *pu8Val2 = tmp;
200}
201
202#ifdef DEBUG
203# define CR_GLERR_CHECK(_op) do { \
204 GLenum status; \
205 while ((status = cr_server.head_spu->dispatch_table.GetError()) != GL_NO_ERROR) {/*Assert(0);*/} \
206 _op \
207 while ((status = cr_server.head_spu->dispatch_table.GetError()) != GL_NO_ERROR) {Assert(0);} \
208 } while (0)
209#else
210# define CR_GLERR_CHECK(_op) do { \
211 _op \
212 } while (0)
213#endif
214
215#ifdef DEBUG_misha
216# define CR_SERVER_RPW_DEBUG
217#endif
218/* *
219 * _name : Draw, Submitted, Worker, Gpu
220 */
221
222#ifdef CR_SERVER_RPW_DEBUG
223# define crServerRpwEntryDbgVerify(_pE) crServerRpwEntryDbgDoVerify(_pE)
224#else
225# define crServerRpwEntryDbgVerify(_pE) do {} while (0)
226#endif
227
228
229#define CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _name) ((_pEntry)->iTex##_name > 0)
230
231#define CR_SERVER_RPW_ENTRY_TEX_INVALIDATE(_pEntry, _name) do { \
232 crServerRpwEntryDbgVerify(_pEntry); \
233 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _name)); \
234 (_pEntry)->iTex##_name = -(_pEntry)->iTex##_name; \
235 crServerRpwEntryDbgVerify(_pEntry); \
236 } while (0)
237
238#define CR_SERVER_RPW_ENTRY_TEX_PROMOTE(_pEntry, _fromName, _toName) do { \
239 crServerRpwEntryDbgVerify(_pEntry); \
240 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
241 Assert(!CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
242 crServerXchgI8(&(_pEntry)->iTex##_fromName, &(_pEntry)->iTex##_toName); \
243 crServerRpwEntryDbgVerify(_pEntry); \
244 } while (0)
245
246#define CR_SERVER_RPW_ENTRY_TEX_XCHG_VALID(_pEntry, _fromName, _toName) do { \
247 crServerRpwEntryDbgVerify(_pEntry); \
248 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
249 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
250 crServerXchgI8(&(_pEntry)->iTex##_fromName, &(_pEntry)->iTex##_toName); \
251 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
252 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
253 crServerRpwEntryDbgVerify(_pEntry); \
254 } while (0)
255
256
257#define CR_SERVER_RPW_ENTRY_TEX_PROMOTE_KEEPVALID(_pEntry, _fromName, _toName) do { \
258 crServerRpwEntryDbgVerify(_pEntry); \
259 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
260 Assert(!CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
261 crServerXchgI8(&(_pEntry)->iTex##_fromName, &(_pEntry)->iTex##_toName); \
262 (_pEntry)->iTex##_fromName = -(_pEntry)->iTex##_fromName; \
263 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _fromName)); \
264 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(_pEntry, _toName)); \
265 crServerRpwEntryDbgVerify(_pEntry); \
266 } while (0)
267
268#define CR_SERVER_RPW_ENTRY_TEX(_pEntry, _name) ((_pEntry)->aidWorkerTexs[(_pEntry)->iTex##_name - 1])
269
270#define CR_SERVER_RPW_ENTRY_PBO_NEXT_ID(_i) (((_i) + 1) % 2)
271#define CR_SERVER_RPW_ENTRY_PBO_IS_ACTIVE(_pEntry) ((_pEntry)->iCurPBO >= 0)
272#define CR_SERVER_RPW_ENTRY_PBO_CUR(_pEntry) ((_pEntry)->aidPBOs[(_pEntry)->iCurPBO])
273#define CR_SERVER_RPW_ENTRY_PBO_COMPLETED(_pEntry) ((_pEntry)->aidPBOs[CR_SERVER_RPW_ENTRY_PBO_NEXT_ID((_pEntry)->iCurPBO)])
274#define CR_SERVER_RPW_ENTRY_PBO_FLIP(_pEntry) do { \
275 (_pEntry)->iCurPBO = CR_SERVER_RPW_ENTRY_PBO_NEXT_ID((_pEntry)->iCurPBO); \
276 } while (0)
277
278#ifdef CR_SERVER_RPW_DEBUG
279DECLINLINE(void) crServerRpwEntryDbgDoVerify(CR_SERVER_RPW_ENTRY *pEntry)
280{
281 int tstMask = 0;
282 int8_t iVal;
283 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(pEntry, Draw));
284
285#define CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(_v) do { \
286 iVal = RT_ABS(_v); \
287 Assert(iVal > 0); \
288 Assert(iVal < 5); \
289 Assert(!(tstMask & (1 << iVal))); \
290 tstMask |= (1 << iVal); \
291 } while (0)
292
293 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexDraw);
294 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexSubmitted);
295 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexWorker);
296 CR_VERVER_RPW_ENTRY_DBG_CHECKVAL(pEntry->iTexGpu);
297 Assert(tstMask == 0x1E);
298}
299#endif
300
301DECLINLINE(bool) crServerRpwIsInitialized(const CR_SERVER_RPW *pWorker)
302{
303 return !!pWorker->ctxId;
304}
305int crServerRpwInit(CR_SERVER_RPW *pWorker);
306int crServerRpwTerm(CR_SERVER_RPW *pWorker);
307DECLINLINE(bool) crServerRpwEntryIsInitialized(const CR_SERVER_RPW_ENTRY *pEntry)
308{
309 return !!pEntry->pfnData;
310}
311int crServerRpwEntryInit(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry, uint32_t width, uint32_t height, PFNCR_SERVER_RPW_DATA pfnData);
312int crServerRpwEntryCleanup(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
313int crServerRpwEntryResize(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry, uint32_t width, uint32_t height);
314int crServerRpwEntrySubmit(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
315int crServerRpwEntryWaitComplete(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
316int crServerRpwEntryCancel(CR_SERVER_RPW *pWorker, CR_SERVER_RPW_ENTRY *pEntry);
317DECLINLINE(void) crServerRpwEntryDrawSettingsToTex(const CR_SERVER_RPW_ENTRY *pEntry, VBOXVR_TEXTURE *pTex)
318{
319 pTex->width = pEntry->Size.cx;
320 pTex->height = pEntry->Size.cy;
321 pTex->target = GL_TEXTURE_2D;
322 Assert(CR_SERVER_RPW_ENTRY_TEX_IS_VALID(pEntry, Draw));
323 pTex->hwid = CR_SERVER_RPW_ENTRY_TEX(pEntry, Draw);
324}
325/**/
326
327typedef struct CR_SERVER_CTX_SWITCH
328{
329 GLuint idDrawFBO, idReadFBO;
330 CRContext *pNewCtx;
331 CRContext *pOldCtx;
332} CR_SERVER_CTX_SWITCH;
333
334DECLINLINE(void) crServerCtxSwitchPrepare(CR_SERVER_CTX_SWITCH *pData, CRContext *pNewCtx)
335{
336 CRMuralInfo *pCurrentMural = cr_server.currentMural;
337 CRContextInfo *pCurCtxInfo = cr_server.currentCtxInfo;
338 GLuint idDrawFBO, idReadFBO;
339 CRContext *pCurCtx = pCurCtxInfo ? pCurCtxInfo->pContext : NULL;
340
341 CRASSERT(pCurCtx == crStateGetCurrent());
342
343 if (pCurrentMural)
344 {
345 idDrawFBO = CR_SERVER_FBO_FOR_IDX(pCurrentMural, pCurrentMural->iCurDrawBuffer);
346 idReadFBO = CR_SERVER_FBO_FOR_IDX(pCurrentMural, pCurrentMural->iCurReadBuffer);
347 }
348 else
349 {
350 idDrawFBO = 0;
351 idReadFBO = 0;
352 }
353
354 crStateSwitchPrepare(pNewCtx, pCurCtx, idDrawFBO, idReadFBO);
355
356 pData->idDrawFBO = idDrawFBO;
357 pData->idReadFBO = idReadFBO;
358 pData->pNewCtx = pNewCtx;
359 pData->pOldCtx = pCurCtx;
360}
361
362DECLINLINE(void) crServerCtxSwitchPostprocess(CR_SERVER_CTX_SWITCH *pData)
363{
364 crStateSwitchPostprocess(pData->pOldCtx, pData->pNewCtx, pData->idDrawFBO, pData->idReadFBO);
365}
366
367void crServerInitTmpCtxDispatch();
368
369int crServerVBoxParseNumerics(const char *pszStr, const int defaultVal);
370
371typedef struct CR_FBMAP
372{
373 uint8_t Map[(CR_MAX_GUEST_MONITORS+7)/8];
374} CR_FBMAP;
375
376DECLINLINE(void) CrFBmInit(CR_FBMAP *pMap)
377{
378 memset(pMap, 0, sizeof (*pMap));
379}
380
381DECLINLINE(bool) CrFBmIsSet(CR_FBMAP *pMap, uint32_t i)
382{
383 return ASMBitTest(&pMap->Map, i);
384}
385
386DECLINLINE(void) CrFBmSet(CR_FBMAP *pMap, uint32_t i)
387{
388 return ASMBitSet(&pMap->Map, i);
389}
390
391DECLINLINE(void) CrFBmClear(CR_FBMAP *pMap, uint32_t i)
392{
393 return ASMBitClear(&pMap->Map, i);
394}
395
396/*helper function that calls CrFbUpdateBegin for all enabled framebuffers */
397int CrPMgrHlpGlblUpdateBegin(CR_FBMAP *pMap);
398/*helper function that calls CrFbUpdateEnd for all framebuffers being updated */
399void CrPMgrHlpGlblUpdateEnd(CR_FBMAP *pMap);
400HCR_FRAMEBUFFER CrPMgrFbGetFirstEnabled();
401HCR_FRAMEBUFFER CrPMgrFbGetNextEnabled(HCR_FRAMEBUFFER hFb);
402int CrPMgrModeVrdp(bool fEnable);
403int CrPMgrModeRootVr(bool fEnable);
404int CrPMgrRootVrUpdate();
405int CrPMgrViewportUpdate(uint32_t idScreen);
406int CrPMgrScreenChanged(uint32_t idScreen);
407int CrPMgrNotifyResize(HCR_FRAMEBUFFER hFb);
408int CrPMgrSaveState(PSSMHANDLE pSSM);
409int CrPMgrLoadState(PSSMHANDLE pSSM, uint32_t version);
410HCR_FRAMEBUFFER CrPMgrFbGet(uint32_t idScreen);
411/*cleanup stuff*/
412
413int CrPMgrInit();
414void CrPMgrTerm();
415
416typedef DECLCALLBACKPTR(bool, PFNCR_FRAMEBUFFER_ENTRIES_VISITOR_CB)(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry, void *pvContext);
417
418void CrFbVisitCreatedEntries(HCR_FRAMEBUFFER hFb, PFNCR_FRAMEBUFFER_ENTRIES_VISITOR_CB pfnVisitorCb, void *pvContext);
419int CrFbResize(HCR_FRAMEBUFFER hFb, const struct VBVAINFOSCREEN * pScreen, void *pvVRAM);
420bool CrFbIsEnabled(HCR_FRAMEBUFFER hFb);
421int CrFbEntryCreateForTexId(HCR_FRAMEBUFFER hFb, GLuint idTex, uint32_t fFlags, HCR_FRAMEBUFFER_ENTRY *phEntry);
422int CrFbEntryCreateForTexData(HCR_FRAMEBUFFER hFb, struct CR_TEXDATA *pTex, uint32_t fFlags, HCR_FRAMEBUFFER_ENTRY *phEntry);
423void CrFbEntryAddRef(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry);
424void CrFbEntryRelease(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry);
425const struct VBVAINFOSCREEN* CrFbGetScreenInfo(HCR_FRAMEBUFFER hFb);
426const struct VBOXVR_SCR_COMPOSITOR* CrFbGetCompositor(HCR_FRAMEBUFFER hFb);
427const struct VBOXVR_SCR_COMPOSITOR_ENTRY* CrFbEntryGetCompositorEntry(HCR_FRAMEBUFFER_ENTRY hEntry);
428
429/* start doing modifications to the framebuffer */
430int CrFbUpdateBegin(HCR_FRAMEBUFFER hFb);
431/*below commands can only be used in Framebuffer update mode, i.e. after the CrFbUpdateBegin succeeded */
432int CrFbEntryRegions(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry);
433
434/* complete doing modifications to the framebuffer */
435void CrFbUpdateEnd(HCR_FRAMEBUFFER hFb);
436
437int CrFbEntryRegionsAdd(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated);
438int CrFbEntryRegionsSet(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated);
439
440int CrFbEntryTexDataUpdate(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY pEntry, struct CR_TEXDATA *pTex);
441
442CRHTABLE_HANDLE CrFbDDataAllocSlot(HCR_FRAMEBUFFER hFb);
443
444typedef DECLCALLBACKPTR(void, PFNCR_FRAMEBUFFER_SLOT_RELEASE_CB)(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry, void *pvContext);
445
446void CrFbDDataReleaseSlot(HCR_FRAMEBUFFER hFb, CRHTABLE_HANDLE hSlot, PFNCR_FRAMEBUFFER_SLOT_RELEASE_CB pfnReleaseCb, void *pvContext);
447int CrFbDDataEntryPut(HCR_FRAMEBUFFER_ENTRY hEntry, CRHTABLE_HANDLE hSlot, void *pvData);
448void* CrFbDDataEntryClear(HCR_FRAMEBUFFER_ENTRY hEntry, CRHTABLE_HANDLE hSlot);
449void* CrFbDDataEntryGet(HCR_FRAMEBUFFER_ENTRY hEntry, CRHTABLE_HANDLE hSlot);
450
451CR_TEXDATA* CrFbTexDataCreate(const VBOXVR_TEXTURE *pTex);
452void CrFbTexDataInit(CR_TEXDATA* pFbTex, const VBOXVR_TEXTURE *pTex, PFNCRTEXDATA_RELEASED pfnTextureReleased);
453
454//#define VBOX_WITH_CRSERVER_DUMPER
455#ifdef VBOX_WITH_CRSERVER_DUMPER
456void crServerDumpCheckTerm();
457int crServerDumpCheckInit();
458void crServerDumpBuffer(int idx);
459void crServerDumpTextures();
460void crServerDumpTexture(const VBOXVR_TEXTURE *pTex);
461void crServerDumpShader(GLint id);
462void crServerDumpProgram(GLint id);
463void crServerDumpCurrentProgram();
464void crServerDumpRecompileDumpCurrentProgram();
465void crServerRecompileCurrentProgram();
466void crServerDumpCurrentProgramUniforms();
467void crServerDumpCurrentProgramAttribs();
468void crServerDumpFramesCheck();
469void crServerDumpState();
470void crServerDumpDrawel(const char*pszFormat, ...);
471void crServerDumpDrawelv(GLuint idx, const char*pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal);
472
473extern int64_t g_CrDbgDumpPid;
474extern unsigned long g_CrDbgDumpEnabled;
475extern unsigned long g_CrDbgDumpDraw;
476extern unsigned long g_CrDbgDumpDrawFramesSettings;
477extern unsigned long g_CrDbgDumpDrawFramesAppliedSettings;
478extern unsigned long g_CrDbgDumpDrawFramesCount;
479
480extern uint32_t g_CrDbgDumpVertattrFixupOn;
481
482bool crServerDumpFilterDmp(unsigned long event, CR_DUMPER *pDumper);
483bool crServerDumpFilterOpEnter(unsigned long event, CR_DUMPER *pDumper);
484void crServerDumpFilterOpLeave(unsigned long event, CR_DUMPER *pDumper);
485
486//#define CR_SERVER_DUMP_MASK_OP 0x0000fffc
487//#define CR_SERVER_DUMP_OFF_OP 2
488//
489//#define CR_SERVER_DUMP_MASK_DIR 0x00000003
490//#define CR_SERVER_DUMP_OFF_DIR 0
491//
492//#define CR_SERVER_DUMP_MASK_DMP 0xffff0000
493//#define CR_SERVER_DUMP_OFF_DMP 16
494//
495//#define CR_SERVER_DUMP_MAKE_OP(_v) (1 << ((_v) + CR_SERVER_DUMP_OFF_OP))
496//#define CR_SERVER_DUMP_MAKE_DIR(_v) (1 << ((_v) + CR_SERVER_DUMP_OFF_DIR))
497//#define CR_SERVER_DUMP_MAKE_DMP(_v) (1 << ((_v) + CR_SERVER_DUMP_OFF_DMP))
498//
499//#define CR_SERVER_DUMP_GET_OP(_v) ((_v) & CR_SERVER_DUMP_MASK_OP)
500//#define CR_SERVER_DUMP_GET_DMP(_v) ((_v) & CR_SERVER_DUMP_MASK_DMP)
501//#define CR_SERVER_DUMP_GET_DIR(_v) ((_v) & CR_SERVER_DUMP_MASK_DIR)
502//
503//#define CR_SERVER_DUMP_ISANY_OP(_v1, _v2) (!!(CR_SERVER_DUMP_GET_OP(_v1) & CR_SERVER_DUMP_GET_OP(_v2)))
504//#define CR_SERVER_DUMP_ISANY_DIR(_v1, _v2) (!!(CR_SERVER_DUMP_GET_DIR(_v1) & CR_SERVER_DUMP_GET_DIR(_v2)))
505//#define CR_SERVER_DUMP_ISANY_DMP(_v1, _v2) (!!(CR_SERVER_DUMP_GET_DMP(_v1) & CR_SERVER_DUMP_GET_DMP(_v2)))
506//
507//#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))
508//#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))
509//#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))
510//
511//#define CR_SERVER_DUMP_F_DIR_ENTER CR_SERVER_DUMP_MAKE_DIR(0)
512//#define CR_SERVER_DUMP_F_DIR_LEAVE CR_SERVER_DUMP_MAKE_DIR(1)
513//
514//#define CR_SERVER_DUMP_F_OP_DRAW CR_SERVER_DUMP_MAKE_OP(0)
515//#define CR_SERVER_DUMP_F_OP_SWAPBUFFERS CR_SERVER_DUMP_MAKE_OP(1)
516//#define CR_SERVER_DUMP_F_OP_LINK_PROGRAM CR_SERVER_DUMP_MAKE_OP(2)
517//#define CR_SERVER_DUMP_F_OP_COMPILE_PROGRAM CR_SERVER_DUMP_MAKE_OP(3)
518//
519//#define CR_SERVER_DUMP_F_DMP_BUFF CR_SERVER_DUMP_MAKE_DMP(0)
520//#define CR_SERVER_DUMP_F_DMP_TEX CR_SERVER_DUMP_MAKE_DMP(0)
521//#define CR_SERVER_DUMP_F_DMP_PROGRAM CR_SERVER_DUMP_MAKE_DMP(0)
522//#define CR_SERVER_DUMP_F_DMP_PROGRAM_UNIFORMS CR_SERVER_DUMP_MAKE_DMP(0)
523//#define CR_SERVER_DUMP_F_DMP_STATE CR_SERVER_DUMP_MAKE_DMP(0)
524//
525//#define CR_SERVER_DUMP_GET_OP(_v) ((_v) & CR_SERVER_DUMP_MASK_OP)
526//#define CR_SERVER_DUMP_GET_DMP(_v) ((_v) & CR_SERVER_DUMP_MASK_DMP)
527//#define CR_SERVER_DUMP_GET_DIR(_v) ((_v) & CR_SERVER_DUMP_MASK_DIR)
528
529#define CR_SERVER_DUMP_F_DRAW_BUFF_ENTER 0x00000001
530#define CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE 0x00000002
531#define CR_SERVER_DUMP_F_DRAW_STATE_ENTER 0x00000004
532#define CR_SERVER_DUMP_F_DRAW_STATE_LEAVE 0x00000008
533#define CR_SERVER_DUMP_F_DRAW_TEX_ENTER 0x00000010
534#define CR_SERVER_DUMP_F_DRAW_TEX_LEAVE 0x00000020
535#define CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER 0x00000040
536#define CR_SERVER_DUMP_F_DRAW_PROGRAM_LEAVE 0x00000080
537#define CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER 0x00000100
538#define CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_LEAVE 0x00000200
539#define CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER 0x00000400
540#define CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_LEAVE 0x00000800
541
542#define CR_SERVER_DUMP_F_DRAW_ENTER_ALL (CR_SERVER_DUMP_F_DRAW_BUFF_ENTER \
543 | CR_SERVER_DUMP_F_DRAW_TEX_ENTER \
544 | CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER \
545 | CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER \
546 | CR_SERVER_DUMP_F_DRAW_STATE_ENTER \
547 | CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER)
548
549#define CR_SERVER_DUMP_F_DRAW_LEAVE_ALL (CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE \
550 | CR_SERVER_DUMP_F_DRAW_TEX_LEAVE \
551 | CR_SERVER_DUMP_F_DRAW_PROGRAM_LEAVE \
552 | CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_LEAVE \
553 | CR_SERVER_DUMP_F_DRAW_STATE_LEAVE \
554 | CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_LEAVE)
555
556#define CR_SERVER_DUMP_F_DRAW_ALL (CR_SERVER_DUMP_F_DRAW_ENTER_ALL | CR_SERVER_DUMP_F_DRAW_LEAVE_ALL)
557
558#define CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER 0x00010000
559#define CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE 0x00020000
560#define CR_SERVER_DUMP_F_TEXPRESENT 0x00040000
561#define CR_SERVER_DUMP_F_DRAWEL 0x00100000
562#define CR_SERVER_DUMP_F_COMPILE_SHADER 0x01000000
563#define CR_SERVER_DUMP_F_SHADER_SOURCE 0x02000000
564#define CR_SERVER_DUMP_F_LINK_PROGRAM 0x04000000
565
566
567#define CR_SERVER_DUMP_DEFAULT_FILTER_OP(_ev) ((((_ev) & g_CrDbgDumpDraw) != 0) \
568 || ((_ev) == CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER && g_CrDbgDumpDrawFramesCount))
569
570#define CR_SERVER_DUMP_DEFAULT_FILTER_DMP(_ev) (((_ev) & g_CrDbgDumpDraw) != 0)
571
572#define CR_SERVER_DUMP_FILTER_OP(_ev, _pDumper) (g_CrDbgDumpEnabled \
573 && (!g_CrDbgDumpPid \
574 || (g_CrDbgDumpPid > 0 && ((uint64_t)g_CrDbgDumpPid) == cr_server.curClient->pid) \
575 || (g_CrDbgDumpPid < 0 && ((uint64_t)(-g_CrDbgDumpPid)) != cr_server.curClient->pid)) \
576 && crServerDumpFilterOpEnter((_ev), (_pDumper)))
577#define CR_SERVER_DUMP_FILTER_DMP(_ev, _pDumper) (crServerDumpFilterDmp((_ev), (_pDumper)))
578
579#define CR_SERVER_DUMP_DRAW_ENTER() do { \
580 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAW_ENTER_ALL, cr_server.Recorder.pDumper)) break; \
581 crServerDumpCheckInit(); \
582 crDmpStrF(cr_server.Recorder.pDumper, "==ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
583 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_STATE_ENTER, cr_server.Recorder.pDumper)) { crServerDumpState(); } \
584 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgram(); } \
585 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramUniforms(); } \
586 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramAttribs(); } \
587 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_TEX_ENTER, cr_server.Recorder.pDumper)) { crServerDumpTextures(); } \
588 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_BUFF_ENTER, cr_server.Recorder.pDumper)) { crServerDumpBuffer(-1); } \
589 crDmpStrF(cr_server.Recorder.pDumper, "==Done ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
590 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAW_ENTER_ALL, cr_server.Recorder.pDumper); \
591 } while (0)
592
593#define CR_SERVER_DUMP_DRAW_LEAVE() do { \
594 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAW_LEAVE_ALL, cr_server.Recorder.pDumper)) break; \
595 crServerDumpCheckInit(); \
596 crDmpStrF(cr_server.Recorder.pDumper, "==LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
597 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_TEX_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpTextures(); } \
598 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpBuffer(-1); } \
599 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramUniforms(); } \
600 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramAttribs(); } \
601 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgram(); } \
602 if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_STATE_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpState(); } \
603 crDmpStrF(cr_server.Recorder.pDumper, "==Done LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
604 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAW_LEAVE_ALL, cr_server.Recorder.pDumper); \
605 } while (0)
606
607#define CR_SERVER_DUMP_COMPILE_SHADER(_id) do { \
608 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_COMPILE_SHADER, cr_server.Recorder.pDumper)) break; \
609 crServerDumpCheckInit(); \
610 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
611 crServerDumpShader((_id)); \
612 crDmpStrF(cr_server.Recorder.pDumper, "==Done[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
613 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_COMPILE_SHADER, cr_server.Recorder.pDumper); \
614 } while (0)
615
616#define CR_SERVER_DUMP_SHADER_SOURCE(_id) do { \
617 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SHADER_SOURCE, cr_server.Recorder.pDumper)) break; \
618 crServerDumpCheckInit(); \
619 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
620 crServerDumpShader((_id)); \
621 crDmpStrF(cr_server.Recorder.pDumper, "==Done[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
622 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_SHADER_SOURCE, cr_server.Recorder.pDumper); \
623 } while (0)
624
625#define CR_SERVER_DUMP_LINK_PROGRAM(_id) do { \
626 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_LINK_PROGRAM, cr_server.Recorder.pDumper)) break; \
627 crServerDumpCheckInit(); \
628 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
629 crServerDumpProgram((_id)); \
630 crDmpStrF(cr_server.Recorder.pDumper, "==Done[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
631 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_LINK_PROGRAM, cr_server.Recorder.pDumper); \
632 } while (0)
633
634#define CR_SERVER_DUMP_SWAPBUFFERS_ENTER() do { \
635 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER, cr_server.Recorder.pDumper)) break; \
636 crServerDumpCheckInit(); \
637 crDmpStrF(cr_server.Recorder.pDumper, "==ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
638 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)); } \
639 if (g_CrDbgDumpDrawFramesCount) { crServerDumpFramesCheck(); } \
640 crDmpStrF(cr_server.Recorder.pDumper, "==Done ENTER[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
641 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER, cr_server.Recorder.pDumper); \
642 } while (0)
643
644#define CR_SERVER_DUMP_TEXPRESENT(_pTex) do { \
645 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_TEXPRESENT, cr_server.Recorder.pDumper)) break; \
646 crServerDumpCheckInit(); \
647 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
648 crServerDumpTexture((_pTex)); \
649 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_TEXPRESENT, cr_server.Recorder.pDumper); \
650 } while (0)
651
652#define CR_SERVER_DUMP_SWAPBUFFERS_LEAVE() do { \
653 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE, cr_server.Recorder.pDumper)) break; \
654 crDmpStrF(cr_server.Recorder.pDumper, "==LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
655 crServerDumpCheckInit(); \
656 crDmpStrF(cr_server.Recorder.pDumper, "==Done LEAVE[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
657 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE, cr_server.Recorder.pDumper); \
658 } while (0)
659
660#define CR_SERVER_DUMP_DRAWEL_F(_msg) do { \
661 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper)) break; \
662 crServerDumpCheckInit(); \
663 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
664 crServerDumpDrawel _msg; \
665 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper); \
666 } while (0)
667
668#define CR_SERVER_DUMP_DRAWEL_V(_index, _pszElFormat, _cbEl, _pvVal, _cVal) do { \
669 if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper)) break; \
670 crServerDumpCheckInit(); \
671 crDmpStrF(cr_server.Recorder.pDumper, "==[%d] %s==", (uint32_t)cr_server.curClient->pid, __FUNCTION__); \
672 crServerDumpDrawelv((_index), (_pszElFormat), (_cbEl), (_pvVal), (_cVal)); \
673 crServerDumpFilterOpLeave(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper); \
674 } while (0)
675#else /* if !defined VBOX_WITH_CRSERVER_DUMPER */
676#define CR_SERVER_DUMP_DRAW_ENTER() do {} while (0)
677#define CR_SERVER_DUMP_DRAW_LEAVE() do {} while (0)
678#define CR_SERVER_DUMP_COMPILE_SHADER(_id) do {} while (0)
679#define CR_SERVER_DUMP_LINK_PROGRAM(_id) do {} while (0)
680#define CR_SERVER_DUMP_TEXPRESENT(_pTex) do {} while (0)
681#define CR_SERVER_DUMP_SWAPBUFFERS_ENTER() do {} while (0)
682#define CR_SERVER_DUMP_SWAPBUFFERS_LEAVE() do {} while (0)
683#define CR_SERVER_DUMP_SHADER_SOURCE(_id) do {} while (0)
684#define CR_SERVER_DUMP_DRAWEL_F(_msg) do {} while (0)
685#define CR_SERVER_DUMP_DRAWEL_V(_index, _pszElFormat, _cbEl, _pvVal, _cVal) do {} while (0)
686#endif /* !VBOX_WITH_CRSERVER_DUMPER */
687
688RT_C_DECLS_END
689
690#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