Changeset 46453 in vbox

Timestamp:

Jun 7, 2013 9:27:03 PM (11 years ago)

Author:

vboxsync

Message:

crOpenGL: more dump/debug stuff

Location:

trunk/src/VBox

Files:

• GuestHost/OpenGL/include/cr_dump.h (modified) (2 diffs)
• GuestHost/OpenGL/state_tracker/dump.cpp (modified) (5 diffs)
• GuestHost/OpenGL/state_tracker/dump_gen.py (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server.h (modified) (8 diffs)
• HostServices/SharedOpenGL/crserverlib/server_glsl.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_misc.c (modified) (3 diffs)

trunk/src/VBox/GuestHost/OpenGL/include/cr_dump.h

@@ -85 +85 @@
 }
 
-VBOXDUMPDECL(size_t) crDmpFormatArrayf(char *pString, size_t cbString, const float *pVal, uint32_t cVal);
-VBOXDUMPDECL(size_t) crDmpFormatRawArrayf(char *pString, size_t cbString, const float *pVal, uint32_t cVal);
-VBOXDUMPDECL(size_t) crDmpFormatMatrixArrayf(char *pString, size_t cbString, const float *pVal, uint32_t cX, uint32_t cY);
+VBOXDUMPDECL(size_t) crDmpFormatArray(char *pString, size_t cbString, const char *pszElFormat, uint32_t cbEl, const void *pVal, uint32_t cVal);
+VBOXDUMPDECL(size_t) crDmpFormatRawArray(char *pString, size_t cbString, const char *pszElFormat, uint32_t cbEl, const void *pVal, uint32_t cVal);
+VBOXDUMPDECL(size_t) crDmpFormatMatrixArray(char *pString, size_t cbString, const char *pszElFormat, uint32_t cbEl, const void *pVal, uint32_t cX, uint32_t cY);
 
 typedef struct CR_DBGPRINT_DUMPER
@@ -134 +134 @@
 VBOXDUMPDECL(void) crRecDumpGlGetState(CR_RECORDER *pRec, CRContext *ctx);
 VBOXDUMPDECL(void) crRecDumpGlEnableState(CR_RECORDER *pRec, CRContext *ctx);
+VBOXDUMPDECL(void) crRecDumpVertAttrv(CR_RECORDER *pRec, CRContext *ctx, GLuint idx, const char*pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal);
+VBOXDUMPDECL(void) crRecDumpVertAttrF(CR_RECORDER *pRec, CRContext *ctx, const char*pszFormat, ...);
+VBOXDUMPDECL(void) crRecDumpVertAttrV(CR_RECORDER *pRec, CRContext *ctx, const char*pszFormat, va_list pArgList);
 
 typedef DECLCALLBACKPTR(GLuint, PFNCRDUMPGETHWID)(void *pvObj);

trunk/src/VBox/GuestHost/OpenGL/state_tracker/dump.cpp

@@ -165 +165 @@
 }
 
-VBOXDUMPDECL(size_t) crDmpFormatRawArrayf(char *pString, size_t cbString, const float *pVal, uint32_t cVal)
+DECLINLINE(size_t) crDmpFormatVal(char *pString, size_t cbString, const char *pszElFormat, uint32_t cbVal, const void *pvVal)
+{
+    if (pszElFormat[0] != '%' || pszElFormat[1] == '\0')
+    {
+        crWarning("invalid format %s", pszElFormat);
+        return 0;
+    }
+    switch (cbVal)
+    {
+        case 8:
+            return sprintf_s(pString, cbString, pszElFormat, *((double*)pvVal));
+        case 4:
+        {
+            /* we do not care only about type specifiers, all the rest is not accepted */
+            switch (pszElFormat[1])
+            {
+                case 'f':
+                    /* float would be promoted to double */
+                    return sprintf_s(pString, cbString, pszElFormat, *((float*)pvVal));
+                default:
+                    return sprintf_s(pString, cbString, pszElFormat, *((uint32_t*)pvVal));
+            }
+        }
+        case 2:
+            return sprintf_s(pString, cbString, pszElFormat, *((uint16_t*)pvVal));
+        case 1:
+            return sprintf_s(pString, cbString, pszElFormat, *((uint8_t*)pvVal));
+        default:
+            crWarning("unsupported size %d", cbVal);
+            return 0;
+    }
+}
+
+VBOXDUMPDECL(size_t) crDmpFormatRawArray(char *pString, size_t cbString, const char *pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal)
 {
     if (cbString < 2)
@@ -177 +210 @@
     --cbString;
     size_t cbWritten;
+    const uint8_t *pu8Val = (const uint8_t *)pvVal;
     for (uint32_t i = 0; i < cVal; ++i)
     {
-        cbWritten = sprintf_s(pString, cbString,
-                (i != cVal - 1) ? "%f, " : "%f", *pVal);
+        cbWritten = crDmpFormatVal(pString, cbString, pszElFormat, cbEl, (const void *)pu8Val);
+        pu8Val += cbEl;
         Assert(cbString >= cbWritten);
         pString += cbWritten;
         cbString -= cbWritten;
+        if (i != cVal - 1)
+        {
+            cbWritten = sprintf_s(pString, cbString, ", ");
+            Assert(cbString >= cbWritten);
+            pString += cbWritten;
+            cbString -= cbWritten;
+        }
     }
 
@@ -204 +245 @@
 }
 
-VBOXDUMPDECL(size_t) crDmpFormatMatrixArrayf(char *pString, size_t cbString, const float *pVal, uint32_t cX, uint32_t cY)
+VBOXDUMPDECL(size_t) crDmpFormatMatrixArray(char *pString, size_t cbString, const char *pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cX, uint32_t cY)
 {
     if (cbString < 2)
@@ -216 +257 @@
     --cbString;
     size_t cbWritten;
+    const uint8_t *pu8Val = (const uint8_t *)pvVal;
     for (uint32_t i = 0; i < cY; ++i)
     {
-        cbWritten = crDmpFormatRawArrayf(pString, cbString, pVal, cX);
+        cbWritten = crDmpFormatRawArray(pString, cbString, pszElFormat, cbEl, (const void *)pu8Val, cX);
+        pu8Val += (cbEl * cX);
         Assert(cbString >= cbWritten);
         pString += cbWritten;
@@ -253 +296 @@
 }
 
-VBOXDUMPDECL(size_t) crDmpFormatArrayf(char *pString, size_t cbString, const float *pVal, uint32_t cVal)
+VBOXDUMPDECL(size_t) crDmpFormatArray(char *pString, size_t cbString, const char *pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal)
 {
     switch(cVal)
     {
         case 1:
-            return sprintf_s(pString, cbString, "%f", *pVal);
+            return crDmpFormatVal(pString, cbString, pszElFormat, cbEl, pvVal);
         case 16:
-            return crDmpFormatMatrixArrayf(pString, cbString, pVal, 4, 4);
+            return crDmpFormatMatrixArray(pString, cbString, pszElFormat, cbEl, pvVal, 4, 4);
         case 9:
-            return crDmpFormatMatrixArrayf(pString, cbString, pVal, 3, 3);
+            return crDmpFormatMatrixArray(pString, cbString, pszElFormat, cbEl, pvVal, 3, 3);
         case 0:
             crWarning("value array is empty");
             return 0;
         default:
-            return crDmpFormatRawArrayf(pString, cbString, pVal, cVal);
-    }
+            return crDmpFormatRawArray(pString, cbString, pszElFormat, cbEl, pvVal, cVal);
+    }
+}
+
+VBOXDUMPDECL(void) crRecDumpVertAttrv(CR_RECORDER *pRec, CRContext *ctx, GLuint idx, const char*pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal)
+{
+    char aBuf[1024];
+    crDmpFormatRawArray(aBuf, sizeof (aBuf), pszElFormat, cbEl, pvVal, cVal);
+    crDmpStrF(pRec->pDumper, "(%u, %s)", idx, aBuf);
+}
+
+VBOXDUMPDECL(void) crRecDumpVertAttrV(CR_RECORDER *pRec, CRContext *ctx, const char*pszFormat, va_list pArgList)
+{
+    crDmpStrV(pRec->pDumper, pszFormat, pArgList);
+}
+
+VBOXDUMPDECL(void) crRecDumpVertAttrF(CR_RECORDER *pRec, CRContext *ctx, const char*pszFormat, ...)
+{
+    va_list pArgList;
+    va_start(pArgList, pszFormat);
+    crRecDumpVertAttrV(pRec, ctx, pszFormat, pArgList);
+    va_end(pArgList);
 }
 

trunk/src/VBox/GuestHost/OpenGL/state_tracker/dump_gen.py

@@ -73 +73 @@
 {
     char aBuf[4096];
-    crDmpFormatArrayf(aBuf, sizeof (aBuf), pfData, pDesc->num_values);
+    crDmpFormatArray(aBuf, sizeof (aBuf), "%f", sizeof (float), pfData, pDesc->num_values);
     crDmpStrF(pDumper, "%s = %s;", pDesc->pszName, aBuf);
 }

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

@@ -398 +398 @@
 void crServerDumpFramesCheck();
 void crServerDumpState();
+void crServerDumpDrawel(const char*pszFormat, ...);
+void crServerDumpDrawelv(GLuint idx, const char*pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal);
+
 
 extern unsigned long g_CrDbgDumpEnabled;
@@ -461 +464 @@
 #define CR_SERVER_DUMP_F_DRAW_STATE_ENTER                0x00000004
 #define CR_SERVER_DUMP_F_DRAW_STATE_LEAVE                0x00000008
-
 #define CR_SERVER_DUMP_F_DRAW_ENTER_ALL (CR_SERVER_DUMP_F_DRAW_BUFF_ENTER \
         | CR_SERVER_DUMP_F_DRAW_TEX_ENTER \
@@ -477 +479 @@
 
 #define CR_SERVER_DUMP_F_COMPILE_SHADER         0x00001000
-#define CR_SERVER_DUMP_F_LINK_PROGRAM           0x00002000
+#define CR_SERVER_DUMP_F_SHADER_SOURCE          0x00002000
+#define CR_SERVER_DUMP_F_LINK_PROGRAM           0x00004000
 #define CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER      0x00010000
 #define CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE      0x00020000
+#define CR_SERVER_DUMP_F_DRAWEL                 0x00100000
+
 
 #define CR_SERVER_DUMP_DEFAULT_FILTER_OP(_ev) ((((_ev) & g_CrDbgDumpDraw) != 0) \
@@ -505 +510 @@
             crServerDumpCheckInit(); \
             crDmpStrF(cr_server.Recorder.pDumper, "<== %s", __FUNCTION__); \
+            if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_TEX_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpTextures(); } \
             if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpBuffer(-1); } \
-            if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_TEX_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpTextures(); } \
             if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgramUniforms(); } \
             if (CR_SERVER_DUMP_FILTER_DMP(CR_SERVER_DUMP_F_DRAW_PROGRAM_LEAVE, cr_server.Recorder.pDumper)) { crServerDumpCurrentProgram(); } \
@@ -516 +521 @@
             if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_COMPILE_SHADER, cr_server.Recorder.pDumper)) break; \
             crServerDumpCheckInit(); \
+            crDmpStrF(cr_server.Recorder.pDumper, "== %s", __FUNCTION__); \
             crServerDumpShader((_id)); \
+            crDmpStrF(cr_server.Recorder.pDumper, "====="); \
+        } while (0)
+
+#define CR_SERVER_DUMP_SHADER_SOURCE(_id) do { \
+            if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SHADER_SOURCE, cr_server.Recorder.pDumper)) break; \
+            crServerDumpCheckInit(); \
+            crDmpStrF(cr_server.Recorder.pDumper, "== %s", __FUNCTION__); \
+            crServerDumpShader((_id)); \
+            crDmpStrF(cr_server.Recorder.pDumper, "====="); \
         } while (0)
 
@@ -522 +537 @@
             if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_LINK_PROGRAM, cr_server.Recorder.pDumper)) break; \
             crServerDumpCheckInit(); \
+            crDmpStrF(cr_server.Recorder.pDumper, "== %s", __FUNCTION__); \
             crServerDumpProgram((_id)); \
+            crDmpStrF(cr_server.Recorder.pDumper, "====="); \
         } while (0)
 
@@ -536 +553 @@
             if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_SWAPBUFFERS_LEAVE, cr_server.Recorder.pDumper)) break; \
             crServerDumpCheckInit(); \
-        } while (0)
+            crDmpStrF(cr_server.Recorder.pDumper, "== %s", __FUNCTION__); \
+        } while (0)
+
+#define CR_SERVER_DUMP_DRAWEL_F(_msg) do { \
+        if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper)) break; \
+        crServerDumpCheckInit(); \
+        crDmpStrF(cr_server.Recorder.pDumper, "== %s", __FUNCTION__); \
+        crServerDumpDrawel _msg; \
+    } while (0)
+
+#define CR_SERVER_DUMP_DRAWEL_V(_index, _pszElFormat, _cbEl, _pvVal, _cVal) do { \
+        if (!CR_SERVER_DUMP_FILTER_OP(CR_SERVER_DUMP_F_DRAWEL, cr_server.Recorder.pDumper)) break; \
+        crServerDumpCheckInit(); \
+        crDmpStrF(cr_server.Recorder.pDumper, "== %s", __FUNCTION__); \
+        crServerDumpDrawelv((_index), (_pszElFormat), (_cbEl), (_pvVal), (_cVal)); \
+    } while (0)
 #else /* if !defined VBOX_WITH_CRSERVER_DUMPER */
 #define CR_SERVER_DUMP_DRAW_ENTER() do {} while (0)
@@ -544 +576 @@
 #define CR_SERVER_DUMP_SWAPBUFFERS_ENTER() do {} while (0)
 #define CR_SERVER_DUMP_SWAPBUFFERS_LEAVE() do {} while (0)
+#define CR_SERVER_DUMP_SHADER_SOURCE() do {} while (0)
+#define CR_SERVER_DUMP_DRAWEL_F(_msg) do {} while (0)
+#define CR_SERVER_DUMP_DRAWEL_V(_pszElFormat, _cbEl, _pvVal, _cVal) do {} while (0)
 #endif /* !VBOX_WITH_CRSERVER_DUMPER */
 

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_glsl.c

@@ -38 +38 @@
     CRASSERT(err == GL_NO_ERROR);
 #endif
+    CR_SERVER_DUMP_SHADER_SOURCE(shader);
 }
 

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_misc.c

@@ -1398 +1398 @@
         | CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE
         | CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER
-        | CR_SERVER_DUMP_F_DRAW_TEX_ENTER
+        | CR_SERVER_DUMP_F_DRAW_TEX_LEAVE
         | CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER
         | CR_SERVER_DUMP_F_DRAW_STATE_ENTER
         | CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER
+        | CR_SERVER_DUMP_F_DRAWEL
         ; //CR_SERVER_DUMP_F_DRAW_BUFF_ENTER | CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE;
 unsigned long g_CrDbgDumpDrawFramesSettings = CR_SERVER_DUMP_F_DRAW_BUFF_ENTER
@@ -1495 +1496 @@
 {
     CRContext *ctx = crStateGetCurrent();
-    Assert(0);
     crRecDumpGlGetState(&cr_server.Recorder, ctx);
     crRecDumpGlEnableState(&cr_server.Recorder, ctx);
+}
+
+void crServerDumpDrawel(const char*pszFormat, ...)
+{
+    CRContext *ctx = crStateGetCurrent();
+    va_list pArgList;
+    va_start(pArgList, pszFormat);
+    crRecDumpVertAttrV(&cr_server.Recorder, ctx, pszFormat, pArgList);
+    va_end(pArgList);
+}
+
+void crServerDumpDrawelv(GLuint idx, const char*pszElFormat, uint32_t cbEl, const void *pvVal, uint32_t cVal)
+{
+    CRContext *ctx = crStateGetCurrent();
+    crRecDumpVertAttrv(&cr_server.Recorder, ctx, idx, pszElFormat, cbEl, pvVal, cVal);
 }
 
@@ -1556 +1571 @@
 }
 
-static uint32_t g_VDbgCDraws = 0;
-static uint32_t g_VDbgCFrames = 0;
-static uint32_t g_VDbgDoFrameDump = 0;
-static uint32_t g_VDbgInitFrameDump = 0;
-
-
 bool crServerDumpFilterOp(unsigned long event, CR_DUMPER *pDumper)
 {
-    CRContext *ctx = crStateGetCurrent();
-    if (event & CR_SERVER_DUMP_F_DRAW_ALL)
-    {
-        if(!ctx->glsl.activeProgram || ctx->glsl.activeProgram->id != 21)
-            return false;
-
-        if (event & CR_SERVER_DUMP_F_DRAW_ENTER_ALL)
-        {
-            ++g_VDbgCDraws;
-//            crDmpStrF(cr_server.Recorder.pDumper, "DRAW(%d:%d)", g_VDbgCFrames, g_VDbgCDraws);
-        }
-
-        if (!g_VDbgDoFrameDump)
-            return false;
-
-#define CR_SERVER_DUMP_MARKER_ENTER_STR "VBox.Cr.DrawEnter"
-#define CR_SERVER_DUMP_MARKER_LEAVE_STR "VBox.Cr.DrawLeave"
-
-        if (0)//(g_VDbgCFrames == 53 && g_VDbgCDraws == 13)
-        {
-            if (event & CR_SERVER_DUMP_F_DRAW_ENTER_ALL)
-                cr_server.head_spu->dispatch_table.StringMarkerGREMEDY(sizeof (CR_SERVER_DUMP_MARKER_ENTER_STR), CR_SERVER_DUMP_MARKER_ENTER_STR);
-            else
-                cr_server.head_spu->dispatch_table.StringMarkerGREMEDY(sizeof (CR_SERVER_DUMP_MARKER_LEAVE_STR), CR_SERVER_DUMP_MARKER_LEAVE_STR);
-        }
-    }
-    else if (event & CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER)
-    {
-        bool fSkip = true;
-        ++g_VDbgCFrames;
-//        crDmpStrF(cr_server.Recorder.pDumper, "FRAME(%d)", g_VDbgCFrames);
-        g_VDbgCDraws = 0;
-        if (g_VDbgDoFrameDump)
-        {
-            g_VDbgDoFrameDump = 0;
-            fSkip = false;
-        }
-
-        if (g_VDbgInitFrameDump)
-        {
-            g_VDbgDoFrameDump = 1;
-            g_VDbgInitFrameDump = 0;
-        }
-
-        if (fSkip)
-            return false;
-    }
-
     return CR_SERVER_DUMP_DEFAULT_FILTER_OP(event);
 }