Always generate optional decoder logging
... that is hidden behind a define so that decoder logging can be
enabled without having to re-generate the decoders.
Bug: b/189133053
Test: enable logging on Cuttlefish
Change-Id: I519188704e77fbdb065adc1d7ef9f0f5f731a60f
diff --git a/host-common/logging.h b/host-common/logging.h
index 22d0581..b4563e9 100644
--- a/host-common/logging.h
+++ b/host-common/logging.h
@@ -19,6 +19,13 @@
#define GL_LOG(...) ((void)0)
#endif
+//#define ENABLE_DECODER_LOG 1
+#if defined(ENABLE_DECODER_LOG)
+#define DECODER_DEBUG_LOG(...) GFXSTREAM_LOG(stderr, "I", __VA_ARGS__)
+#else
+#define DECODER_DEBUG_LOG(...) ((void)0)
+#endif
+
#define ERR(...) \
do { \
GFXSTREAM_LOG(stderr, "E", __VA_ARGS__); \
diff --git a/protocols/generic-apigen/ApiGen.cpp b/protocols/generic-apigen/ApiGen.cpp
index 1f99440..d10e4fb 100644
--- a/protocols/generic-apigen/ApiGen.cpp
+++ b/protocols/generic-apigen/ApiGen.cpp
@@ -1001,6 +1001,7 @@
fprintf(fp, "#include \"%s_dec.h\"\n\n\n", m_basename.c_str());
fprintf(fp, "#include \"ProtocolUtils.h\"\n\n");
fprintf(fp, "#include \"ChecksumCalculatorThreadInfo.h\"\n\n");
+ fprintf(fp, "#include \"host-common/logging.h\"\n\n");
fprintf(fp, "#include <stdio.h>\n\n");
fprintf(fp, "typedef unsigned int tsize_t; // Target \"size_t\", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled.\n\n");
@@ -1065,6 +1066,7 @@
std::string printString;
for (size_t i = 0; i < e->vars().size(); i++) {
Var *v = &e->vars()[i];
+ printString += v->name() + ":";
if (!v->isVoid()) printString += (v->isPointer() ? "%p(%u)" : v->type()->printFormat()) + " ";
}
@@ -1086,12 +1088,7 @@
retvalType = e->retval().type()->name();
}
-#define SKIP_DEBUG_PRINT 1
-
for (int pass = PASS_FIRST; pass < PASS_LAST; pass++) {
-#if SKIP_DEBUG_PRINT
- if (pass == PASS_DebugPrint) continue;
-#endif
#if INSTRUMENT_TIMING_HOST
if (pass == PASS_FunctionCall) {
@@ -1116,14 +1113,15 @@
}
} else if (pass == PASS_DebugPrint) {
if (strstr(m_basename.c_str(), "gl")) {
- fprintf(fp, "\t\t#ifdef CHECK_GL_ERRORS\n");
- fprintf(fp, "\t\tGLint err = this->glGetError();\n");
- fprintf(fp, "\t\tif (err) fprintf(stderr, \"%s Error (pre-call): 0x%%X before %s\\n\", err);\n",
+ fprintf(fp, "\t\t\t#ifdef CHECK_GL_ERRORS\n");
+ fprintf(fp, "\t\t\tGLint err = this->glGetError();\n");
+ fprintf(fp, "\t\t\tif (err) fprintf(stderr, \"%s Error (pre-call): 0x%%X before %s\\n\", err);\n",
m_basename.c_str(), e->name().c_str());
- fprintf(fp, "\t\t#endif\n");
+ fprintf(fp, "\t\t\t#endif\n");
}
+
fprintf(fp,
- "\t\t\tDEBUG(\"%s(%%p): %s(%s)\\n\", stream",
+ "\t\t\tDECODER_DEBUG_LOG(\"%s(%%p): %s(%s)\", stream",
m_basename.c_str(),
e->name().c_str(),
printString.c_str());
diff --git a/stream-servers/gles1_dec/gles1_dec.cpp b/stream-servers/gles1_dec/gles1_dec.cpp
index 7cae3e4..5a57803 100644
--- a/stream-servers/gles1_dec/gles1_dec.cpp
+++ b/stream-servers/gles1_dec/gles1_dec.cpp
@@ -12,6 +12,8 @@
#include "ChecksumCalculatorThreadInfo.h"
+#include "host-common/logging.h"
+
#include <stdio.h>
typedef unsigned int tsize_t; // Target "size_t", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled.
@@ -45,6 +47,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glAlphaFunc: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFunc\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glAlphaFunc(func:0x%08x ref:%f )", stream, var_func, var_ref);
this->glAlphaFunc(var_func, var_ref);
SET_LASTCALL("glAlphaFunc");
android::base::endTrace();
@@ -60,6 +67,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearColor: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColor\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearColor(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
this->glClearColor(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glClearColor");
android::base::endTrace();
@@ -72,6 +84,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearDepthf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearDepthf(depth:%f )", stream, var_depth);
this->glClearDepthf(var_depth);
SET_LASTCALL("glClearDepthf");
android::base::endTrace();
@@ -86,6 +103,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
"gles1_decoder_context_t::decode, OP_glClipPlanef: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanef\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClipPlanef(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
this->glClipPlanef(var_plane, (const GLfloat*)(inptr_equation.get()));
SET_LASTCALL("glClipPlanef");
android::base::endTrace();
@@ -101,6 +123,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glColor4f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColor4f(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
this->glColor4f(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glColor4f");
android::base::endTrace();
@@ -114,6 +141,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDepthRangef: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangef\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDepthRangef(zNear:%f zFar:%f )", stream, var_zNear, var_zFar);
this->glDepthRangef(var_zNear, var_zFar);
SET_LASTCALL("glDepthRangef");
android::base::endTrace();
@@ -127,6 +159,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFogf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFogf(pname:0x%08x param:%f )", stream, var_pname, var_param);
this->glFogf(var_pname, var_param);
SET_LASTCALL("glFogf");
android::base::endTrace();
@@ -141,6 +178,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glFogfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFogfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glFogfv(var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glFogfv");
android::base::endTrace();
@@ -158,6 +200,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFrustumf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFrustumf(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glFrustumf(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glFrustumf");
android::base::endTrace();
@@ -175,6 +222,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanef\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanef(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_eqn.get()), size_eqn);
this->glGetClipPlanef(var_pname, (GLfloat*)(outptr_eqn.get()));
outptr_eqn.flush();
if (useChecksum) {
@@ -197,6 +249,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFloatv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetFloatv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetFloatv(var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -220,6 +277,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetLightfv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetLightfv(var_light, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -243,6 +305,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetMaterialfv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetMaterialfv(var_face, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -266,6 +333,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvfv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetTexEnvfv(var_env, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -289,6 +361,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetTexParameterfv(var_target, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -307,6 +384,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightModelf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightModelf(pname:0x%08x param:%f )", stream, var_pname, var_param);
this->glLightModelf(var_pname, var_param);
SET_LASTCALL("glLightModelf");
android::base::endTrace();
@@ -321,6 +403,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightModelfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightModelfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glLightModelfv(var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glLightModelfv");
android::base::endTrace();
@@ -335,6 +422,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightf(light:0x%08x pname:0x%08x param:%f )", stream, var_light, var_pname, var_param);
this->glLightf(var_light, var_pname, var_param);
SET_LASTCALL("glLightf");
android::base::endTrace();
@@ -350,6 +442,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightfv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glLightfv(var_light, var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glLightfv");
android::base::endTrace();
@@ -362,6 +459,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLineWidth: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidth\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLineWidth(width:%f )", stream, var_width);
this->glLineWidth(var_width);
SET_LASTCALL("glLineWidth");
android::base::endTrace();
@@ -375,6 +477,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
"gles1_decoder_context_t::decode, OP_glLoadMatrixf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixf(m:%p(%u) )", stream, (const GLfloat*)(inptr_m.get()), size_m);
this->glLoadMatrixf((const GLfloat*)(inptr_m.get()));
SET_LASTCALL("glLoadMatrixf");
android::base::endTrace();
@@ -389,6 +496,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMaterialf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMaterialf(face:0x%08x pname:0x%08x param:%f )", stream, var_face, var_pname, var_param);
this->glMaterialf(var_face, var_pname, var_param);
SET_LASTCALL("glMaterialf");
android::base::endTrace();
@@ -404,6 +516,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glMaterialfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMaterialfv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glMaterialfv(var_face, var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glMaterialfv");
android::base::endTrace();
@@ -417,6 +534,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultMatrixf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultMatrixf(m:%p(%u) )", stream, (const GLfloat*)(inptr_m.get()), size_m);
this->glMultMatrixf((const GLfloat*)(inptr_m.get()));
SET_LASTCALL("glMultMatrixf");
android::base::endTrace();
@@ -433,6 +555,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultiTexCoord4f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4f(target:0x%08x s:%f t:%f r:%f q:%f )", stream, var_target, var_s, var_t, var_r, var_q);
this->glMultiTexCoord4f(var_target, var_s, var_t, var_r, var_q);
SET_LASTCALL("glMultiTexCoord4f");
android::base::endTrace();
@@ -447,6 +574,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glNormal3f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glNormal3f(nx:%f ny:%f nz:%f )", stream, var_nx, var_ny, var_nz);
this->glNormal3f(var_nx, var_ny, var_nz);
SET_LASTCALL("glNormal3f");
android::base::endTrace();
@@ -464,6 +596,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glOrthof: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthof\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glOrthof(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glOrthof(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glOrthof");
android::base::endTrace();
@@ -477,6 +614,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointParameterf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointParameterf(pname:0x%08x param:%f )", stream, var_pname, var_param);
this->glPointParameterf(var_pname, var_param);
SET_LASTCALL("glPointParameterf");
android::base::endTrace();
@@ -491,6 +633,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointParameterfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointParameterfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glPointParameterfv(var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glPointParameterfv");
android::base::endTrace();
@@ -503,6 +650,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointSize: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSize\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointSize(size:%f )", stream, var_size);
this->glPointSize(var_size);
SET_LASTCALL("glPointSize");
android::base::endTrace();
@@ -516,6 +668,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPolygonOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPolygonOffset(factor:%f units:%f )", stream, var_factor, var_units);
this->glPolygonOffset(var_factor, var_units);
SET_LASTCALL("glPolygonOffset");
android::base::endTrace();
@@ -531,6 +688,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glRotatef: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatef\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glRotatef(angle:%f x:%f y:%f z:%f )", stream, var_angle, var_x, var_y, var_z);
this->glRotatef(var_angle, var_x, var_y, var_z);
SET_LASTCALL("glRotatef");
android::base::endTrace();
@@ -545,6 +707,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glScalef: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalef\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glScalef(x:%f y:%f z:%f )", stream, var_x, var_y, var_z);
this->glScalef(var_x, var_y, var_z);
SET_LASTCALL("glScalef");
android::base::endTrace();
@@ -559,6 +726,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnvf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnvf(target:0x%08x pname:0x%08x param:%f )", stream, var_target, var_pname, var_param);
this->glTexEnvf(var_target, var_pname, var_param);
SET_LASTCALL("glTexEnvf");
android::base::endTrace();
@@ -574,6 +746,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnvfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnvfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glTexEnvfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glTexEnvfv");
android::base::endTrace();
@@ -588,6 +765,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameterf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameterf(target:0x%08x pname:0x%08x param:%f )", stream, var_target, var_pname, var_param);
this->glTexParameterf(var_target, var_pname, var_param);
SET_LASTCALL("glTexParameterf");
android::base::endTrace();
@@ -603,6 +785,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameterfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glTexParameterfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glTexParameterfv");
android::base::endTrace();
@@ -617,6 +804,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTranslatef: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatef\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTranslatef(x:%f y:%f z:%f )", stream, var_x, var_y, var_z);
this->glTranslatef(var_x, var_y, var_z);
SET_LASTCALL("glTranslatef");
android::base::endTrace();
@@ -629,6 +821,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glActiveTexture: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glActiveTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glActiveTexture(texture:0x%08x )", stream, var_texture);
this->glActiveTexture(var_texture);
SET_LASTCALL("glActiveTexture");
android::base::endTrace();
@@ -642,6 +839,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glAlphaFuncx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFuncx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glAlphaFuncx(func:0x%08x ref:0x%08x )", stream, var_func, var_ref);
this->glAlphaFuncx(var_func, var_ref);
SET_LASTCALL("glAlphaFuncx");
android::base::endTrace();
@@ -655,6 +857,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBindBuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindBuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBindBuffer(target:0x%08x buffer:%u )", stream, var_target, var_buffer);
this->glBindBuffer(var_target, var_buffer);
SET_LASTCALL("glBindBuffer");
android::base::endTrace();
@@ -668,6 +875,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBindTexture: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBindTexture(target:0x%08x texture:%u )", stream, var_target, var_texture);
this->glBindTexture(var_target, var_texture);
SET_LASTCALL("glBindTexture");
android::base::endTrace();
@@ -681,6 +893,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBlendFunc: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendFunc\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBlendFunc(sfactor:0x%08x dfactor:0x%08x )", stream, var_sfactor, var_dfactor);
this->glBlendFunc(var_sfactor, var_dfactor);
SET_LASTCALL("glBlendFunc");
android::base::endTrace();
@@ -697,6 +914,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBufferData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBufferData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBufferData(target:0x%08x size:0x%08lx data:%p(%u) usage:0x%08x )", stream, var_target, var_size, (const GLvoid*)(inptr_data.get()), size_data, var_usage);
this->glBufferData(var_target, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()), var_usage);
SET_LASTCALL("glBufferData");
android::base::endTrace();
@@ -713,6 +935,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles1_decoder_context_t::decode, OP_glBufferSubData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBufferSubData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBufferSubData(target:0x%08x offset:0x%08lx size:0x%08lx data:%p(%u) )", stream, var_target, var_offset, var_size, (const GLvoid*)(inptr_data.get()), size_data);
this->glBufferSubData(var_target, var_offset, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glBufferSubData");
android::base::endTrace();
@@ -725,6 +952,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClear: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClear\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClear(mask:0x%08x )", stream, var_mask);
this->glClear(var_mask);
SET_LASTCALL("glClear");
android::base::endTrace();
@@ -740,6 +972,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearColorx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColorx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearColorx(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
this->glClearColorx(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glClearColorx");
android::base::endTrace();
@@ -752,6 +989,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearDepthx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearDepthx(depth:0x%08x )", stream, var_depth);
this->glClearDepthx(var_depth);
SET_LASTCALL("glClearDepthx");
android::base::endTrace();
@@ -764,6 +1006,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearStencil: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearStencil\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearStencil(s:%d )", stream, var_s);
this->glClearStencil(var_s);
SET_LASTCALL("glClearStencil");
android::base::endTrace();
@@ -776,6 +1023,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClientActiveTexture: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClientActiveTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClientActiveTexture(texture:0x%08x )", stream, var_texture);
this->glClientActiveTexture(var_texture);
SET_LASTCALL("glClientActiveTexture");
android::base::endTrace();
@@ -791,6 +1043,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1 + 1 + 1 + 1, ptr + 8 + 1 + 1 + 1 + 1, checksumSize,
"gles1_decoder_context_t::decode, OP_glColor4ub: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4ub\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColor4ub(red:0x%02x green:0x%02x blue:0x%02x alpha:0x%02x )", stream, var_red, var_green, var_blue, var_alpha);
this->glColor4ub(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glColor4ub");
android::base::endTrace();
@@ -806,6 +1063,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glColor4x: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4x\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColor4x(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
this->glColor4x(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glColor4x");
android::base::endTrace();
@@ -821,6 +1083,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1 + 1 + 1 + 1, ptr + 8 + 1 + 1 + 1 + 1, checksumSize,
"gles1_decoder_context_t::decode, OP_glColorMask: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorMask\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColorMask(red:%d green:%d blue:%d alpha:%d )", stream, var_red, var_green, var_blue, var_alpha);
this->glColorMask(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glColorMask");
android::base::endTrace();
@@ -837,6 +1104,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles1_decoder_context_t::decode, OP_glColorPointer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColorPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glColorPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glColorPointer");
android::base::endTrace();
@@ -857,6 +1129,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles1_decoder_context_t::decode, OP_glCompressedTexImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCompressedTexImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glCompressedTexImage2D(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d border:%d imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexImage2D(var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexImage2D");
android::base::endTrace();
@@ -878,6 +1155,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles1_decoder_context_t::decode, OP_glCompressedTexSubImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCompressedTexSubImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glCompressedTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexSubImage2D");
android::base::endTrace();
@@ -897,6 +1179,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glCopyTexImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCopyTexImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glCopyTexImage2D(target:0x%08x level:%d internalformat:0x%08x x:%d y:%d width:%d height:%d border:%d )", stream, var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
this->glCopyTexImage2D(var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
SET_LASTCALL("glCopyTexImage2D");
android::base::endTrace();
@@ -916,6 +1203,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glCopyTexSubImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCopyTexSubImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glCopyTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d x:%d y:%d width:%d height:%d )", stream, var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
this->glCopyTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
SET_LASTCALL("glCopyTexSubImage2D");
android::base::endTrace();
@@ -928,6 +1220,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glCullFace: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCullFace\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glCullFace(mode:0x%08x )", stream, var_mode);
this->glCullFace(var_mode);
SET_LASTCALL("glCullFace");
android::base::endTrace();
@@ -942,6 +1239,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_buffers, ptr + 8 + 4 + 4 + size_buffers, checksumSize,
"gles1_decoder_context_t::decode, OP_glDeleteBuffers: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteBuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDeleteBuffers(n:%d buffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_buffers.get()), size_buffers);
this->glDeleteBuffers_dec(this, var_n, (const GLuint*)(inptr_buffers.get()));
SET_LASTCALL("glDeleteBuffers");
android::base::endTrace();
@@ -956,6 +1258,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_textures, ptr + 8 + 4 + 4 + size_textures, checksumSize,
"gles1_decoder_context_t::decode, OP_glDeleteTextures: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteTextures\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDeleteTextures(n:%d textures:%p(%u) )", stream, var_n, (const GLuint*)(inptr_textures.get()), size_textures);
this->glDeleteTextures_dec(this, var_n, (const GLuint*)(inptr_textures.get()));
SET_LASTCALL("glDeleteTextures");
android::base::endTrace();
@@ -968,6 +1275,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDepthFunc: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthFunc\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDepthFunc(func:0x%08x )", stream, var_func);
this->glDepthFunc(var_func);
SET_LASTCALL("glDepthFunc");
android::base::endTrace();
@@ -980,6 +1292,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1, ptr + 8 + 1, checksumSize,
"gles1_decoder_context_t::decode, OP_glDepthMask: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthMask\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDepthMask(flag:%d )", stream, var_flag);
this->glDepthMask(var_flag);
SET_LASTCALL("glDepthMask");
android::base::endTrace();
@@ -993,6 +1310,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDepthRangex: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDepthRangex(zNear:0x%08x zFar:0x%08x )", stream, var_zNear, var_zFar);
this->glDepthRangex(var_zNear, var_zFar);
SET_LASTCALL("glDepthRangex");
android::base::endTrace();
@@ -1005,6 +1327,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDisable: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisable\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDisable(cap:0x%08x )", stream, var_cap);
this->glDisable(var_cap);
SET_LASTCALL("glDisable");
android::base::endTrace();
@@ -1017,6 +1344,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDisableClientState: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisableClientState\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDisableClientState(array:0x%08x )", stream, var_array);
this->glDisableClientState(var_array);
SET_LASTCALL("glDisableClientState");
android::base::endTrace();
@@ -1031,6 +1363,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawArrays: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawArrays\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawArrays(mode:0x%08x first:%d count:%d )", stream, var_mode, var_first, var_count);
this->glDrawArrays(var_mode, var_first, var_count);
SET_LASTCALL("glDrawArrays");
android::base::endTrace();
@@ -1047,6 +1384,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_indices, ptr + 8 + 4 + 4 + 4 + 4 + size_indices, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawElements: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElements\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawElements(mode:0x%08x count:%d type:0x%08x indices:%p(%u) )", stream, var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()), size_indices);
this->glDrawElements(var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()));
SET_LASTCALL("glDrawElements");
android::base::endTrace();
@@ -1059,6 +1401,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glEnable: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnable\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glEnable(cap:0x%08x )", stream, var_cap);
this->glEnable(var_cap);
SET_LASTCALL("glEnable");
android::base::endTrace();
@@ -1071,6 +1418,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glEnableClientState: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnableClientState\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glEnableClientState(array:0x%08x )", stream, var_array);
this->glEnableClientState(var_array);
SET_LASTCALL("glEnableClientState");
android::base::endTrace();
@@ -1082,6 +1434,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles1_decoder_context_t::decode, OP_glFinish: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinish\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFinish()", stream);
this->glFinish();
SET_LASTCALL("glFinish");
android::base::endTrace();
@@ -1093,6 +1450,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles1_decoder_context_t::decode, OP_glFlush: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFlush\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFlush()", stream);
this->glFlush();
SET_LASTCALL("glFlush");
android::base::endTrace();
@@ -1106,6 +1468,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFogx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFogx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
this->glFogx(var_pname, var_param);
SET_LASTCALL("glFogx");
android::base::endTrace();
@@ -1120,6 +1487,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glFogxv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFogxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glFogxv(var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glFogxv");
android::base::endTrace();
@@ -1132,6 +1504,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFrontFace: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrontFace\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFrontFace(mode:0x%08x )", stream, var_mode);
this->glFrontFace(var_mode);
SET_LASTCALL("glFrontFace");
android::base::endTrace();
@@ -1149,6 +1526,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFrustumx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFrustumx(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glFrustumx(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glFrustumx");
android::base::endTrace();
@@ -1166,6 +1548,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBooleanv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetBooleanv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLboolean*)(outptr_params.get()), size_params);
this->glGetBooleanv(var_pname, (GLboolean*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1189,6 +1576,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBufferParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetBufferParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetBufferParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1208,6 +1600,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_eqn, ptr + 8 + 4 + 4 + size_eqn, checksumSize,
"gles1_decoder_context_t::decode, OP_glClipPlanex: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClipPlanex(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_eqn.get()), size_eqn);
this->glClipPlanex(var_pname, (const GLfixed*)(inptr_eqn.get()));
SET_LASTCALL("glClipPlanex");
android::base::endTrace();
@@ -1225,6 +1622,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenBuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGenBuffers(n:%d buffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_buffers.get()), size_buffers);
this->glGenBuffers_dec(this, var_n, (GLuint*)(outptr_buffers.get()));
outptr_buffers.flush();
if (useChecksum) {
@@ -1247,6 +1649,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenTextures\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGenTextures(n:%d textures:%p(%u) )", stream, var_n, (GLuint*)(outptr_textures.get()), size_textures);
this->glGenTextures_dec(this, var_n, (GLuint*)(outptr_textures.get()));
outptr_textures.flush();
if (useChecksum) {
@@ -1266,6 +1673,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetError\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetError()", stream);
*(GLenum *)(&tmpBuf[0]) = this->glGetError();
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1287,6 +1699,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFixedv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetFixedv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetFixedv(var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1309,6 +1726,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetIntegerv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetIntegerv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetIntegerv(var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1332,6 +1754,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetLightxv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetLightxv(var_light, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1355,6 +1782,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetMaterialxv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetMaterialxv(var_face, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1374,6 +1806,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glGetPointerv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetPointerv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetPointerv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLvoid**)(inptr_params.get()), size_params);
this->glGetPointerv(var_pname, (GLvoid**)(inptr_params.get()));
SET_LASTCALL("glGetPointerv");
android::base::endTrace();
@@ -1386,6 +1823,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glGetString: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetString\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetString(name:0x%08x )", stream, var_name);
this->glGetString(var_name);
SET_LASTCALL("glGetString");
android::base::endTrace();
@@ -1404,6 +1846,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnviv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexEnviv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetTexEnviv(var_env, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1427,6 +1874,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvxv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetTexEnvxv(var_env, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1450,6 +1902,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetTexParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1473,6 +1930,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetTexParameterxv(var_target, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1491,6 +1953,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glHint: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glHint\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glHint(target:0x%08x mode:0x%08x )", stream, var_target, var_mode);
this->glHint(var_target, var_mode);
SET_LASTCALL("glHint");
android::base::endTrace();
@@ -1506,6 +1973,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsBuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glIsBuffer(buffer:%u )", stream, var_buffer);
*(GLboolean *)(&tmpBuf[0]) = this->glIsBuffer(var_buffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1525,6 +1997,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsEnabled\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glIsEnabled(cap:0x%08x )", stream, var_cap);
*(GLboolean *)(&tmpBuf[0]) = this->glIsEnabled(var_cap);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1544,6 +2021,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glIsTexture(texture:%u )", stream, var_texture);
*(GLboolean *)(&tmpBuf[0]) = this->glIsTexture(var_texture);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1561,6 +2043,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightModelx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightModelx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
this->glLightModelx(var_pname, var_param);
SET_LASTCALL("glLightModelx");
android::base::endTrace();
@@ -1575,6 +2062,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightModelxv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightModelxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glLightModelxv(var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glLightModelxv");
android::base::endTrace();
@@ -1589,6 +2081,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightx(light:0x%08x pname:0x%08x param:0x%08x )", stream, var_light, var_pname, var_param);
this->glLightx(var_light, var_pname, var_param);
SET_LASTCALL("glLightx");
android::base::endTrace();
@@ -1604,6 +2101,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightxv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightxv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glLightxv(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glLightxv");
android::base::endTrace();
@@ -1616,6 +2118,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLineWidthx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidthx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLineWidthx(width:0x%08x )", stream, var_width);
this->glLineWidthx(var_width);
SET_LASTCALL("glLineWidthx");
android::base::endTrace();
@@ -1627,6 +2134,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles1_decoder_context_t::decode, OP_glLoadIdentity: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadIdentity\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLoadIdentity()", stream);
this->glLoadIdentity();
SET_LASTCALL("glLoadIdentity");
android::base::endTrace();
@@ -1640,6 +2152,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
"gles1_decoder_context_t::decode, OP_glLoadMatrixx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixx(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
this->glLoadMatrixx((const GLfixed*)(inptr_m.get()));
SET_LASTCALL("glLoadMatrixx");
android::base::endTrace();
@@ -1652,6 +2169,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLogicOp: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLogicOp\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLogicOp(opcode:0x%08x )", stream, var_opcode);
this->glLogicOp(var_opcode);
SET_LASTCALL("glLogicOp");
android::base::endTrace();
@@ -1666,6 +2188,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMaterialx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMaterialx(face:0x%08x pname:0x%08x param:0x%08x )", stream, var_face, var_pname, var_param);
this->glMaterialx(var_face, var_pname, var_param);
SET_LASTCALL("glMaterialx");
android::base::endTrace();
@@ -1681,6 +2208,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glMaterialxv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMaterialxv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glMaterialxv(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glMaterialxv");
android::base::endTrace();
@@ -1693,6 +2225,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMatrixMode: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixMode\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMatrixMode(mode:0x%08x )", stream, var_mode);
this->glMatrixMode(var_mode);
SET_LASTCALL("glMatrixMode");
android::base::endTrace();
@@ -1706,6 +2243,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultMatrixx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultMatrixx(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
this->glMultMatrixx((const GLfixed*)(inptr_m.get()));
SET_LASTCALL("glMultMatrixx");
android::base::endTrace();
@@ -1722,6 +2264,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultiTexCoord4x: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4x\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4x(target:0x%08x s:0x%08x t:0x%08x r:0x%08x q:0x%08x )", stream, var_target, var_s, var_t, var_r, var_q);
this->glMultiTexCoord4x(var_target, var_s, var_t, var_r, var_q);
SET_LASTCALL("glMultiTexCoord4x");
android::base::endTrace();
@@ -1736,6 +2283,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glNormal3x: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3x\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glNormal3x(nx:0x%08x ny:0x%08x nz:0x%08x )", stream, var_nx, var_ny, var_nz);
this->glNormal3x(var_nx, var_ny, var_nz);
SET_LASTCALL("glNormal3x");
android::base::endTrace();
@@ -1751,6 +2303,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles1_decoder_context_t::decode, OP_glNormalPointer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glNormalPointer(type:0x%08x stride:%d pointer:%p(%u) )", stream, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glNormalPointer(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glNormalPointer");
android::base::endTrace();
@@ -1768,6 +2325,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glOrthox: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthox\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glOrthox(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glOrthox(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glOrthox");
android::base::endTrace();
@@ -1781,6 +2343,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPixelStorei: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPixelStorei\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPixelStorei(pname:0x%08x param:%d )", stream, var_pname, var_param);
this->glPixelStorei(var_pname, var_param);
SET_LASTCALL("glPixelStorei");
android::base::endTrace();
@@ -1794,6 +2361,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointParameterx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointParameterx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
this->glPointParameterx(var_pname, var_param);
SET_LASTCALL("glPointParameterx");
android::base::endTrace();
@@ -1808,6 +2380,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointParameterxv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointParameterxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glPointParameterxv(var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glPointParameterxv");
android::base::endTrace();
@@ -1820,6 +2397,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointSizex: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointSizex(size:0x%08x )", stream, var_size);
this->glPointSizex(var_size);
SET_LASTCALL("glPointSizex");
android::base::endTrace();
@@ -1833,6 +2415,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPolygonOffsetx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffsetx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPolygonOffsetx(factor:0x%08x units:0x%08x )", stream, var_factor, var_units);
this->glPolygonOffsetx(var_factor, var_units);
SET_LASTCALL("glPolygonOffsetx");
android::base::endTrace();
@@ -1844,6 +2431,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles1_decoder_context_t::decode, OP_glPopMatrix: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPopMatrix\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPopMatrix()", stream);
this->glPopMatrix();
SET_LASTCALL("glPopMatrix");
android::base::endTrace();
@@ -1855,6 +2447,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles1_decoder_context_t::decode, OP_glPushMatrix: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPushMatrix\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPushMatrix()", stream);
this->glPushMatrix();
SET_LASTCALL("glPushMatrix");
android::base::endTrace();
@@ -1877,6 +2474,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glReadPixels\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glReadPixels(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()), size_pixels);
this->glReadPixels(var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()));
outptr_pixels.flush();
if (useChecksum) {
@@ -1897,6 +2499,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glRotatex: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glRotatex(angle:0x%08x x:0x%08x y:0x%08x z:0x%08x )", stream, var_angle, var_x, var_y, var_z);
this->glRotatex(var_angle, var_x, var_y, var_z);
SET_LASTCALL("glRotatex");
android::base::endTrace();
@@ -1910,6 +2517,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
"gles1_decoder_context_t::decode, OP_glSampleCoverage: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoverage\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glSampleCoverage(value:%f invert:%d )", stream, var_value, var_invert);
this->glSampleCoverage(var_value, var_invert);
SET_LASTCALL("glSampleCoverage");
android::base::endTrace();
@@ -1923,6 +2535,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
"gles1_decoder_context_t::decode, OP_glSampleCoveragex: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoveragex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glSampleCoveragex(value:0x%08x invert:%d )", stream, var_value, var_invert);
this->glSampleCoveragex(var_value, var_invert);
SET_LASTCALL("glSampleCoveragex");
android::base::endTrace();
@@ -1937,6 +2554,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glScalex: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glScalex(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
this->glScalex(var_x, var_y, var_z);
SET_LASTCALL("glScalex");
android::base::endTrace();
@@ -1952,6 +2574,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glScissor: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScissor\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glScissor(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
this->glScissor(var_x, var_y, var_width, var_height);
SET_LASTCALL("glScissor");
android::base::endTrace();
@@ -1964,6 +2591,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glShadeModel: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glShadeModel\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glShadeModel(mode:0x%08x )", stream, var_mode);
this->glShadeModel(var_mode);
SET_LASTCALL("glShadeModel");
android::base::endTrace();
@@ -1978,6 +2610,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glStencilFunc: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilFunc\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glStencilFunc(func:0x%08x ref:%d mask:%u )", stream, var_func, var_ref, var_mask);
this->glStencilFunc(var_func, var_ref, var_mask);
SET_LASTCALL("glStencilFunc");
android::base::endTrace();
@@ -1990,6 +2627,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glStencilMask: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilMask\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glStencilMask(mask:%u )", stream, var_mask);
this->glStencilMask(var_mask);
SET_LASTCALL("glStencilMask");
android::base::endTrace();
@@ -2004,6 +2646,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glStencilOp: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilOp\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glStencilOp(fail:0x%08x zfail:0x%08x zpass:0x%08x )", stream, var_fail, var_zfail, var_zpass);
this->glStencilOp(var_fail, var_zfail, var_zpass);
SET_LASTCALL("glStencilOp");
android::base::endTrace();
@@ -2020,6 +2667,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexCoordPointer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glTexCoordPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glTexCoordPointer");
android::base::endTrace();
@@ -2034,6 +2686,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnvi: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvi\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnvi(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
this->glTexEnvi(var_target, var_pname, var_param);
SET_LASTCALL("glTexEnvi");
android::base::endTrace();
@@ -2048,6 +2705,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnvx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnvx(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
this->glTexEnvx(var_target, var_pname, var_param);
SET_LASTCALL("glTexEnvx");
android::base::endTrace();
@@ -2063,6 +2725,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnviv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnviv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnviv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLint*)(inptr_params.get()), size_params);
this->glTexEnviv(var_target, var_pname, (const GLint*)(inptr_params.get()));
SET_LASTCALL("glTexEnviv");
android::base::endTrace();
@@ -2078,6 +2745,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnvxv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnvxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glTexEnvxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glTexEnvxv");
android::base::endTrace();
@@ -2099,6 +2771,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexImage2D(target:0x%08x level:%d internalformat:%d width:%d height:%d border:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
this->glTexImage2D(var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
SET_LASTCALL("glTexImage2D");
android::base::endTrace();
@@ -2113,6 +2790,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameteri: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameteri\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameteri(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
this->glTexParameteri(var_target, var_pname, var_param);
SET_LASTCALL("glTexParameteri");
android::base::endTrace();
@@ -2127,6 +2809,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameterx: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterx\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameterx(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
this->glTexParameterx(var_target, var_pname, var_param);
SET_LASTCALL("glTexParameterx");
android::base::endTrace();
@@ -2142,6 +2829,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameteriv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLint*)(inptr_params.get()), size_params);
this->glTexParameteriv(var_target, var_pname, (const GLint*)(inptr_params.get()));
SET_LASTCALL("glTexParameteriv");
android::base::endTrace();
@@ -2157,6 +2849,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameterxv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameterxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glTexParameterxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glTexParameterxv");
android::base::endTrace();
@@ -2178,6 +2875,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexSubImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexSubImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
this->glTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
SET_LASTCALL("glTexSubImage2D");
android::base::endTrace();
@@ -2192,6 +2894,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTranslatex: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTranslatex(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
this->glTranslatex(var_x, var_y, var_z);
SET_LASTCALL("glTranslatex");
android::base::endTrace();
@@ -2208,6 +2915,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles1_decoder_context_t::decode, OP_glVertexPointer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glVertexPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glVertexPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glVertexPointer");
android::base::endTrace();
@@ -2223,6 +2935,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glViewport: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glViewport\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glViewport(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
this->glViewport(var_x, var_y, var_width, var_height);
SET_LASTCALL("glViewport");
android::base::endTrace();
@@ -2238,6 +2955,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointSizePointerOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerOES(type:0x%08x stride:%d pointer:%p(%u) )", stream, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glPointSizePointerOES(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glPointSizePointerOES");
android::base::endTrace();
@@ -2253,6 +2975,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glVertexPointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glVertexPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
this->glVertexPointerOffset(this, var_size, var_type, var_stride, var_offset);
SET_LASTCALL("glVertexPointerOffset");
android::base::endTrace();
@@ -2268,6 +2995,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glColorPointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColorPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
this->glColorPointerOffset(this, var_size, var_type, var_stride, var_offset);
SET_LASTCALL("glColorPointerOffset");
android::base::endTrace();
@@ -2282,6 +3014,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glNormalPointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glNormalPointerOffset(type:0x%08x stride:%d offset:%u )", stream, var_type, var_stride, var_offset);
this->glNormalPointerOffset(this, var_type, var_stride, var_offset);
SET_LASTCALL("glNormalPointerOffset");
android::base::endTrace();
@@ -2296,6 +3033,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointSizePointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerOffset(type:0x%08x stride:%d offset:%u )", stream, var_type, var_stride, var_offset);
this->glPointSizePointerOffset(this, var_type, var_stride, var_offset);
SET_LASTCALL("glPointSizePointerOffset");
android::base::endTrace();
@@ -2311,6 +3053,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexCoordPointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
this->glTexCoordPointerOffset(this, var_size, var_type, var_stride, var_offset);
SET_LASTCALL("glTexCoordPointerOffset");
android::base::endTrace();
@@ -2326,6 +3073,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glWeightPointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glWeightPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
this->glWeightPointerOffset(this, var_size, var_type, var_stride, var_offset);
SET_LASTCALL("glWeightPointerOffset");
android::base::endTrace();
@@ -2341,6 +3093,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMatrixIndexPointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
this->glMatrixIndexPointerOffset(this, var_size, var_type, var_stride, var_offset);
SET_LASTCALL("glMatrixIndexPointerOffset");
android::base::endTrace();
@@ -2358,6 +3115,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glVertexPointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glVertexPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glVertexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glVertexPointerData");
android::base::endTrace();
@@ -2375,6 +3137,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glColorPointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColorPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glColorPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glColorPointerData");
android::base::endTrace();
@@ -2391,6 +3158,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glNormalPointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glNormalPointerData(type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glNormalPointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glNormalPointerData");
android::base::endTrace();
@@ -2409,6 +3181,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexCoordPointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointerData(unit:%d size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_unit, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glTexCoordPointerData(this, var_unit, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glTexCoordPointerData");
android::base::endTrace();
@@ -2425,6 +3202,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointSizePointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerData(type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glPointSizePointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glPointSizePointerData");
android::base::endTrace();
@@ -2442,6 +3224,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glWeightPointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glWeightPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glWeightPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glWeightPointerData");
android::base::endTrace();
@@ -2459,6 +3246,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMatrixIndexPointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glMatrixIndexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glMatrixIndexPointerData");
android::base::endTrace();
@@ -2474,6 +3266,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawElementsOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElementsOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawElementsOffset(mode:0x%08x count:%d type:0x%08x offset:%u )", stream, var_mode, var_count, var_type, var_offset);
this->glDrawElementsOffset(this, var_mode, var_count, var_type, var_offset);
SET_LASTCALL("glDrawElementsOffset");
android::base::endTrace();
@@ -2491,6 +3288,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawElementsData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElementsData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawElementsData(mode:0x%08x count:%d type:0x%08x data:%p(%u) datalen:%u )", stream, var_mode, var_count, var_type, (void*)(inptr_data.get()), size_data, var_datalen);
this->glDrawElementsData(this, var_mode, var_count, var_type, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glDrawElementsData");
android::base::endTrace();
@@ -2508,6 +3310,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_formats(&tmpBuf[0], size_formats);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetCompressedTextureFormats\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetCompressedTextureFormats(count:%d formats:%p(%u) )", stream, var_count, (GLint*)(outptr_formats.get()), size_formats);
this->glGetCompressedTextureFormats(this, var_count, (GLint*)(outptr_formats.get()));
outptr_formats.flush();
if (useChecksum) {
@@ -2527,6 +3334,11 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinishRoundTrip\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFinishRoundTrip()", stream);
*(int *)(&tmpBuf[0]) = this->glFinishRoundTrip(this);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -2544,6 +3356,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBlendEquationSeparateOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendEquationSeparateOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBlendEquationSeparateOES(modeRGB:0x%08x modeAlpha:0x%08x )", stream, var_modeRGB, var_modeAlpha);
this->glBlendEquationSeparateOES(var_modeRGB, var_modeAlpha);
SET_LASTCALL("glBlendEquationSeparateOES");
android::base::endTrace();
@@ -2559,6 +3376,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBlendFuncSeparateOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendFuncSeparateOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBlendFuncSeparateOES(srcRGB:0x%08x dstRGB:0x%08x srcAlpha:0x%08x dstAlpha:0x%08x )", stream, var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
this->glBlendFuncSeparateOES(var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
SET_LASTCALL("glBlendFuncSeparateOES");
android::base::endTrace();
@@ -2571,6 +3393,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBlendEquationOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendEquationOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBlendEquationOES(mode:0x%08x )", stream, var_mode);
this->glBlendEquationOES(var_mode);
SET_LASTCALL("glBlendEquationOES");
android::base::endTrace();
@@ -2587,6 +3414,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 2 + 2 + 2 + 2 + 2, ptr + 8 + 2 + 2 + 2 + 2 + 2, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexsOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexsOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexsOES(x:%d y:%d z:%d width:%d height:%d )", stream, var_x, var_y, var_z, var_width, var_height);
this->glDrawTexsOES(var_x, var_y, var_z, var_width, var_height);
SET_LASTCALL("glDrawTexsOES");
android::base::endTrace();
@@ -2603,6 +3435,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexiOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexiOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexiOES(x:%d y:%d z:%d width:%d height:%d )", stream, var_x, var_y, var_z, var_width, var_height);
this->glDrawTexiOES(var_x, var_y, var_z, var_width, var_height);
SET_LASTCALL("glDrawTexiOES");
android::base::endTrace();
@@ -2619,6 +3456,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexxOES(x:0x%08x y:0x%08x z:0x%08x width:0x%08x height:0x%08x )", stream, var_x, var_y, var_z, var_width, var_height);
this->glDrawTexxOES(var_x, var_y, var_z, var_width, var_height);
SET_LASTCALL("glDrawTexxOES");
android::base::endTrace();
@@ -2632,6 +3474,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexsvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexsvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexsvOES(coords:%p(%u) )", stream, (const GLshort*)(inptr_coords.get()), size_coords);
this->glDrawTexsvOES((const GLshort*)(inptr_coords.get()));
SET_LASTCALL("glDrawTexsvOES");
android::base::endTrace();
@@ -2645,6 +3492,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexivOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexivOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexivOES(coords:%p(%u) )", stream, (const GLint*)(inptr_coords.get()), size_coords);
this->glDrawTexivOES((const GLint*)(inptr_coords.get()));
SET_LASTCALL("glDrawTexivOES");
android::base::endTrace();
@@ -2658,6 +3510,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexxvOES(coords:%p(%u) )", stream, (const GLfixed*)(inptr_coords.get()), size_coords);
this->glDrawTexxvOES((const GLfixed*)(inptr_coords.get()));
SET_LASTCALL("glDrawTexxvOES");
android::base::endTrace();
@@ -2674,6 +3531,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexfOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexfOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexfOES(x:%f y:%f z:%f width:%f height:%f )", stream, var_x, var_y, var_z, var_width, var_height);
this->glDrawTexfOES(var_x, var_y, var_z, var_width, var_height);
SET_LASTCALL("glDrawTexfOES");
android::base::endTrace();
@@ -2687,6 +3549,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
"gles1_decoder_context_t::decode, OP_glDrawTexfvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexfvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDrawTexfvOES(coords:%p(%u) )", stream, (const GLfloat*)(inptr_coords.get()), size_coords);
this->glDrawTexfvOES((const GLfloat*)(inptr_coords.get()));
SET_LASTCALL("glDrawTexfvOES");
android::base::endTrace();
@@ -2700,6 +3567,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glEGLImageTargetTexture2DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEGLImageTargetTexture2DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glEGLImageTargetTexture2DOES(target:0x%08x image:%p )", stream, var_target, var_image);
this->glEGLImageTargetTexture2DOES(var_target, var_image);
SET_LASTCALL("glEGLImageTargetTexture2DOES");
android::base::endTrace();
@@ -2713,6 +3585,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glEGLImageTargetRenderbufferStorageOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEGLImageTargetRenderbufferStorageOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glEGLImageTargetRenderbufferStorageOES(target:0x%08x image:%p )", stream, var_target, var_image);
this->glEGLImageTargetRenderbufferStorageOES(var_target, var_image);
SET_LASTCALL("glEGLImageTargetRenderbufferStorageOES");
android::base::endTrace();
@@ -2726,6 +3603,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glAlphaFuncxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFuncxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glAlphaFuncxOES(func:0x%08x ref:0x%08x )", stream, var_func, var_ref);
this->glAlphaFuncxOES(var_func, var_ref);
SET_LASTCALL("glAlphaFuncxOES");
android::base::endTrace();
@@ -2741,6 +3623,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearColorxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColorxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearColorxOES(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
this->glClearColorxOES(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glClearColorxOES");
android::base::endTrace();
@@ -2753,6 +3640,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearDepthxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearDepthxOES(depth:0x%08x )", stream, var_depth);
this->glClearDepthxOES(var_depth);
SET_LASTCALL("glClearDepthxOES");
android::base::endTrace();
@@ -2767,6 +3659,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
"gles1_decoder_context_t::decode, OP_glClipPlanexOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClipPlanexOES(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfixed*)(inptr_equation.get()), size_equation);
this->glClipPlanexOES(var_plane, (const GLfixed*)(inptr_equation.get()));
SET_LASTCALL("glClipPlanexOES");
android::base::endTrace();
@@ -2781,6 +3678,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
"gles1_decoder_context_t::decode, OP_glClipPlanexIMG: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanexIMG\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClipPlanexIMG(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfixed*)(inptr_equation.get()), size_equation);
this->glClipPlanexIMG(var_plane, (const GLfixed*)(inptr_equation.get()));
SET_LASTCALL("glClipPlanexIMG");
android::base::endTrace();
@@ -2796,6 +3698,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glColor4xOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4xOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glColor4xOES(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
this->glColor4xOES(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glColor4xOES");
android::base::endTrace();
@@ -2809,6 +3716,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDepthRangexOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDepthRangexOES(zNear:0x%08x zFar:0x%08x )", stream, var_zNear, var_zFar);
this->glDepthRangexOES(var_zNear, var_zFar);
SET_LASTCALL("glDepthRangexOES");
android::base::endTrace();
@@ -2822,6 +3734,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFogxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFogxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
this->glFogxOES(var_pname, var_param);
SET_LASTCALL("glFogxOES");
android::base::endTrace();
@@ -2836,6 +3753,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glFogxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFogxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glFogxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glFogxvOES");
android::base::endTrace();
@@ -2853,6 +3775,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFrustumxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFrustumxOES(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glFrustumxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glFrustumxOES");
android::base::endTrace();
@@ -2870,6 +3797,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanexOES(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_eqn.get()), size_eqn);
this->glGetClipPlanexOES(var_pname, (GLfixed*)(outptr_eqn.get()));
outptr_eqn.flush();
if (useChecksum) {
@@ -2892,6 +3824,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanex(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_eqn.get()), size_eqn);
this->glGetClipPlanex(var_pname, (GLfixed*)(outptr_eqn.get()));
outptr_eqn.flush();
if (useChecksum) {
@@ -2914,6 +3851,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFixedvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetFixedvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetFixedvOES(var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -2937,6 +3879,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetLightxvOES(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetLightxvOES(var_light, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -2960,6 +3907,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetMaterialxvOES(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetMaterialxvOES(var_face, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -2983,6 +3935,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvxvOES(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetTexEnvxvOES(var_env, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -3006,6 +3963,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfixed*)(outptr_params.get()), size_params);
this->glGetTexParameterxvOES(var_target, var_pname, (GLfixed*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -3024,6 +3986,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightModelxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightModelxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
this->glLightModelxOES(var_pname, var_param);
SET_LASTCALL("glLightModelxOES");
android::base::endTrace();
@@ -3038,6 +4005,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightModelxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightModelxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glLightModelxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glLightModelxvOES");
android::base::endTrace();
@@ -3052,6 +4024,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightxOES(light:0x%08x pname:0x%08x param:0x%08x )", stream, var_light, var_pname, var_param);
this->glLightxOES(var_light, var_pname, var_param);
SET_LASTCALL("glLightxOES");
android::base::endTrace();
@@ -3067,6 +4044,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glLightxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLightxvOES(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glLightxvOES(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glLightxvOES");
android::base::endTrace();
@@ -3079,6 +4061,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glLineWidthxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidthxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLineWidthxOES(width:0x%08x )", stream, var_width);
this->glLineWidthxOES(var_width);
SET_LASTCALL("glLineWidthxOES");
android::base::endTrace();
@@ -3092,6 +4079,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
"gles1_decoder_context_t::decode, OP_glLoadMatrixxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixxOES(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
this->glLoadMatrixxOES((const GLfixed*)(inptr_m.get()));
SET_LASTCALL("glLoadMatrixxOES");
android::base::endTrace();
@@ -3106,6 +4098,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMaterialxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMaterialxOES(face:0x%08x pname:0x%08x param:0x%08x )", stream, var_face, var_pname, var_param);
this->glMaterialxOES(var_face, var_pname, var_param);
SET_LASTCALL("glMaterialxOES");
android::base::endTrace();
@@ -3121,6 +4118,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glMaterialxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMaterialxvOES(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glMaterialxvOES(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glMaterialxvOES");
android::base::endTrace();
@@ -3134,6 +4136,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultMatrixxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultMatrixxOES(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
this->glMultMatrixxOES((const GLfixed*)(inptr_m.get()));
SET_LASTCALL("glMultMatrixxOES");
android::base::endTrace();
@@ -3150,6 +4157,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultiTexCoord4xOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4xOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4xOES(target:0x%08x s:0x%08x t:0x%08x r:0x%08x q:0x%08x )", stream, var_target, var_s, var_t, var_r, var_q);
this->glMultiTexCoord4xOES(var_target, var_s, var_t, var_r, var_q);
SET_LASTCALL("glMultiTexCoord4xOES");
android::base::endTrace();
@@ -3164,6 +4176,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glNormal3xOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3xOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glNormal3xOES(nx:0x%08x ny:0x%08x nz:0x%08x )", stream, var_nx, var_ny, var_nz);
this->glNormal3xOES(var_nx, var_ny, var_nz);
SET_LASTCALL("glNormal3xOES");
android::base::endTrace();
@@ -3181,6 +4198,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glOrthoxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthoxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glOrthoxOES(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glOrthoxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glOrthoxOES");
android::base::endTrace();
@@ -3194,6 +4216,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointParameterxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointParameterxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
this->glPointParameterxOES(var_pname, var_param);
SET_LASTCALL("glPointParameterxOES");
android::base::endTrace();
@@ -3208,6 +4235,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointParameterxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointParameterxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glPointParameterxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glPointParameterxvOES");
android::base::endTrace();
@@ -3220,6 +4252,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPointSizexOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPointSizexOES(size:0x%08x )", stream, var_size);
this->glPointSizexOES(var_size);
SET_LASTCALL("glPointSizexOES");
android::base::endTrace();
@@ -3233,6 +4270,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glPolygonOffsetxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffsetxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glPolygonOffsetxOES(factor:0x%08x units:0x%08x )", stream, var_factor, var_units);
this->glPolygonOffsetxOES(var_factor, var_units);
SET_LASTCALL("glPolygonOffsetxOES");
android::base::endTrace();
@@ -3248,6 +4290,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glRotatexOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glRotatexOES(angle:0x%08x x:0x%08x y:0x%08x z:0x%08x )", stream, var_angle, var_x, var_y, var_z);
this->glRotatexOES(var_angle, var_x, var_y, var_z);
SET_LASTCALL("glRotatexOES");
android::base::endTrace();
@@ -3261,6 +4308,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
"gles1_decoder_context_t::decode, OP_glSampleCoveragexOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoveragexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glSampleCoveragexOES(value:0x%08x invert:%d )", stream, var_value, var_invert);
this->glSampleCoveragexOES(var_value, var_invert);
SET_LASTCALL("glSampleCoveragexOES");
android::base::endTrace();
@@ -3275,6 +4327,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glScalexOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glScalexOES(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
this->glScalexOES(var_x, var_y, var_z);
SET_LASTCALL("glScalexOES");
android::base::endTrace();
@@ -3289,6 +4346,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnvxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnvxOES(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
this->glTexEnvxOES(var_target, var_pname, var_param);
SET_LASTCALL("glTexEnvxOES");
android::base::endTrace();
@@ -3304,6 +4366,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexEnvxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexEnvxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glTexEnvxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glTexEnvxvOES");
android::base::endTrace();
@@ -3318,6 +4385,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameterxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameterxOES(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
this->glTexParameterxOES(var_target, var_pname, var_param);
SET_LASTCALL("glTexParameterxOES");
android::base::endTrace();
@@ -3333,6 +4405,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexParameterxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexParameterxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glTexParameterxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glTexParameterxvOES");
android::base::endTrace();
@@ -3347,6 +4424,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTranslatexOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatexOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTranslatexOES(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
this->glTranslatexOES(var_x, var_y, var_z);
SET_LASTCALL("glTranslatexOES");
android::base::endTrace();
@@ -3362,6 +4444,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsRenderbufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glIsRenderbufferOES(renderbuffer:%u )", stream, var_renderbuffer);
*(GLboolean *)(&tmpBuf[0]) = this->glIsRenderbufferOES(var_renderbuffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3379,6 +4466,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBindRenderbufferOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindRenderbufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBindRenderbufferOES(target:0x%08x renderbuffer:%u )", stream, var_target, var_renderbuffer);
this->glBindRenderbufferOES(var_target, var_renderbuffer);
SET_LASTCALL("glBindRenderbufferOES");
android::base::endTrace();
@@ -3393,6 +4485,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_renderbuffers, ptr + 8 + 4 + 4 + size_renderbuffers, checksumSize,
"gles1_decoder_context_t::decode, OP_glDeleteRenderbuffersOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteRenderbuffersOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDeleteRenderbuffersOES(n:%d renderbuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_renderbuffers.get()), size_renderbuffers);
this->glDeleteRenderbuffersOES_dec(this, var_n, (const GLuint*)(inptr_renderbuffers.get()));
SET_LASTCALL("glDeleteRenderbuffersOES");
android::base::endTrace();
@@ -3410,6 +4507,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenRenderbuffersOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGenRenderbuffersOES(n:%d renderbuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_renderbuffers.get()), size_renderbuffers);
this->glGenRenderbuffersOES_dec(this, var_n, (GLuint*)(outptr_renderbuffers.get()));
outptr_renderbuffers.flush();
if (useChecksum) {
@@ -3430,6 +4532,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glRenderbufferStorageOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRenderbufferStorageOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glRenderbufferStorageOES(target:0x%08x internalformat:0x%08x width:%d height:%d )", stream, var_target, var_internalformat, var_width, var_height);
this->glRenderbufferStorageOES(var_target, var_internalformat, var_width, var_height);
SET_LASTCALL("glRenderbufferStorageOES");
android::base::endTrace();
@@ -3448,6 +4555,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetRenderbufferParameterivOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetRenderbufferParameterivOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetRenderbufferParameterivOES(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -3468,6 +4580,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsFramebufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glIsFramebufferOES(framebuffer:%u )", stream, var_framebuffer);
*(GLboolean *)(&tmpBuf[0]) = this->glIsFramebufferOES(var_framebuffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3485,6 +4602,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBindFramebufferOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindFramebufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBindFramebufferOES(target:0x%08x framebuffer:%u )", stream, var_target, var_framebuffer);
this->glBindFramebufferOES(var_target, var_framebuffer);
SET_LASTCALL("glBindFramebufferOES");
android::base::endTrace();
@@ -3499,6 +4621,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_framebuffers, ptr + 8 + 4 + 4 + size_framebuffers, checksumSize,
"gles1_decoder_context_t::decode, OP_glDeleteFramebuffersOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteFramebuffersOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDeleteFramebuffersOES(n:%d framebuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_framebuffers.get()), size_framebuffers);
this->glDeleteFramebuffersOES_dec(this, var_n, (const GLuint*)(inptr_framebuffers.get()));
SET_LASTCALL("glDeleteFramebuffersOES");
android::base::endTrace();
@@ -3516,6 +4643,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenFramebuffersOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGenFramebuffersOES(n:%d framebuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_framebuffers.get()), size_framebuffers);
this->glGenFramebuffersOES_dec(this, var_n, (GLuint*)(outptr_framebuffers.get()));
outptr_framebuffers.flush();
if (useChecksum) {
@@ -3536,6 +4668,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCheckFramebufferStatusOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glCheckFramebufferStatusOES(target:0x%08x )", stream, var_target);
*(GLenum *)(&tmpBuf[0]) = this->glCheckFramebufferStatusOES(var_target);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3555,6 +4692,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFramebufferRenderbufferOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferRenderbufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFramebufferRenderbufferOES(target:0x%08x attachment:0x%08x renderbuffertarget:0x%08x renderbuffer:%u )", stream, var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
this->glFramebufferRenderbufferOES(var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
SET_LASTCALL("glFramebufferRenderbufferOES");
android::base::endTrace();
@@ -3571,6 +4713,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFramebufferTexture2DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferTexture2DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFramebufferTexture2DOES(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level);
this->glFramebufferTexture2DOES(var_target, var_attachment, var_textarget, var_texture, var_level);
SET_LASTCALL("glFramebufferTexture2DOES");
android::base::endTrace();
@@ -3590,6 +4737,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFramebufferAttachmentParameterivOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetFramebufferAttachmentParameterivOES(target:0x%08x attachment:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetFramebufferAttachmentParameterivOES(var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -3607,6 +4759,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glGenerateMipmapOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenerateMipmapOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGenerateMipmapOES(target:0x%08x )", stream, var_target);
this->glGenerateMipmapOES(var_target);
SET_LASTCALL("glGenerateMipmapOES");
android::base::endTrace();
@@ -3620,6 +4777,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMapBufferOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMapBufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMapBufferOES(target:0x%08x access:0x%08x )", stream, var_target, var_access);
this->glMapBufferOES(var_target, var_access);
SET_LASTCALL("glMapBufferOES");
android::base::endTrace();
@@ -3635,6 +4797,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glUnmapBufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glUnmapBufferOES(target:0x%08x )", stream, var_target);
*(GLboolean *)(&tmpBuf[0]) = this->glUnmapBufferOES(var_target);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3654,6 +4821,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glGetBufferPointervOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBufferPointervOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetBufferPointervOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLvoid**)(inptr_params.get()), size_params);
this->glGetBufferPointervOES(var_target, var_pname, (GLvoid**)(inptr_params.get()));
SET_LASTCALL("glGetBufferPointervOES");
android::base::endTrace();
@@ -3666,6 +4838,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glCurrentPaletteMatrixOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCurrentPaletteMatrixOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glCurrentPaletteMatrixOES(matrixpaletteindex:%u )", stream, var_matrixpaletteindex);
this->glCurrentPaletteMatrixOES(var_matrixpaletteindex);
SET_LASTCALL("glCurrentPaletteMatrixOES");
android::base::endTrace();
@@ -3677,6 +4854,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles1_decoder_context_t::decode, OP_glLoadPaletteFromModelViewMatrixOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadPaletteFromModelViewMatrixOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glLoadPaletteFromModelViewMatrixOES()", stream);
this->glLoadPaletteFromModelViewMatrixOES();
SET_LASTCALL("glLoadPaletteFromModelViewMatrixOES");
android::base::endTrace();
@@ -3693,6 +4875,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles1_decoder_context_t::decode, OP_glMatrixIndexPointerOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerOES(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glMatrixIndexPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glMatrixIndexPointerOES");
android::base::endTrace();
@@ -3709,6 +4896,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles1_decoder_context_t::decode, OP_glWeightPointerOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glWeightPointerOES(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glWeightPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glWeightPointerOES");
android::base::endTrace();
@@ -3729,6 +4921,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_mantissa(&tmpBuf[0], size_mantissa);
OutputBuffer outptr_exponent(&tmpBuf[0 + size_mantissa], size_exponent);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glQueryMatrixxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glQueryMatrixxOES(mantissa:%p(%u) exponent:%p(%u) )", stream, (GLfixed*)(outptr_mantissa.get()), size_mantissa, (GLint*)(outptr_exponent.get()), size_exponent);
*(GLbitfield *)(&tmpBuf[0 + size_mantissa + size_exponent]) = this->glQueryMatrixxOES((GLfixed*)(outptr_mantissa.get()), (GLint*)(outptr_exponent.get()));
outptr_mantissa.flush();
outptr_exponent.flush();
@@ -3748,6 +4945,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDepthRangefOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangefOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDepthRangefOES(zNear:%f zFar:%f )", stream, var_zNear, var_zFar);
this->glDepthRangefOES(var_zNear, var_zFar);
SET_LASTCALL("glDepthRangefOES");
android::base::endTrace();
@@ -3765,6 +4967,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFrustumfOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumfOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFrustumfOES(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glFrustumfOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glFrustumfOES");
android::base::endTrace();
@@ -3782,6 +4989,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glOrthofOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthofOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glOrthofOES(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
this->glOrthofOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
SET_LASTCALL("glOrthofOES");
android::base::endTrace();
@@ -3796,6 +5008,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
"gles1_decoder_context_t::decode, OP_glClipPlanefOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanefOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClipPlanefOES(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
this->glClipPlanefOES(var_plane, (const GLfloat*)(inptr_equation.get()));
SET_LASTCALL("glClipPlanefOES");
android::base::endTrace();
@@ -3810,6 +5027,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
"gles1_decoder_context_t::decode, OP_glClipPlanefIMG: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanefIMG\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClipPlanefIMG(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
this->glClipPlanefIMG(var_plane, (const GLfloat*)(inptr_equation.get()));
SET_LASTCALL("glClipPlanefIMG");
android::base::endTrace();
@@ -3827,6 +5049,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanefOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanefOES(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_eqn.get()), size_eqn);
this->glGetClipPlanefOES(var_pname, (GLfloat*)(outptr_eqn.get()));
outptr_eqn.flush();
if (useChecksum) {
@@ -3844,6 +5071,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glClearDepthfOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthfOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glClearDepthfOES(depth:%f )", stream, var_depth);
this->glClearDepthfOES(var_depth);
SET_LASTCALL("glClearDepthfOES");
android::base::endTrace();
@@ -3858,6 +5090,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexGenfOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenfOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexGenfOES(coord:0x%08x pname:0x%08x param:%f )", stream, var_coord, var_pname, var_param);
this->glTexGenfOES(var_coord, var_pname, var_param);
SET_LASTCALL("glTexGenfOES");
android::base::endTrace();
@@ -3873,6 +5110,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexGenfvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenfvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexGenfvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glTexGenfvOES(var_coord, var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glTexGenfvOES");
android::base::endTrace();
@@ -3887,6 +5129,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexGeniOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGeniOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexGeniOES(coord:0x%08x pname:0x%08x param:%d )", stream, var_coord, var_pname, var_param);
this->glTexGeniOES(var_coord, var_pname, var_param);
SET_LASTCALL("glTexGeniOES");
android::base::endTrace();
@@ -3902,6 +5149,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexGenivOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenivOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexGenivOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLint*)(inptr_params.get()), size_params);
this->glTexGenivOES(var_coord, var_pname, (const GLint*)(inptr_params.get()));
SET_LASTCALL("glTexGenivOES");
android::base::endTrace();
@@ -3916,6 +5168,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexGenxOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenxOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexGenxOES(coord:0x%08x pname:0x%08x param:0x%08x )", stream, var_coord, var_pname, var_param);
this->glTexGenxOES(var_coord, var_pname, var_param);
SET_LASTCALL("glTexGenxOES");
android::base::endTrace();
@@ -3931,6 +5188,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glTexGenxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTexGenxvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
this->glTexGenxvOES(var_coord, var_pname, (const GLfixed*)(inptr_params.get()));
SET_LASTCALL("glTexGenxvOES");
android::base::endTrace();
@@ -3946,6 +5208,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glGetTexGenfvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenfvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexGenfvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLfloat*)(inptr_params.get()), size_params);
this->glGetTexGenfvOES(var_coord, var_pname, (GLfloat*)(inptr_params.get()));
SET_LASTCALL("glGetTexGenfvOES");
android::base::endTrace();
@@ -3961,6 +5228,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glGetTexGenivOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenivOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexGenivOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLint*)(inptr_params.get()), size_params);
this->glGetTexGenivOES(var_coord, var_pname, (GLint*)(inptr_params.get()));
SET_LASTCALL("glGetTexGenivOES");
android::base::endTrace();
@@ -3976,6 +5248,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glGetTexGenxvOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenxvOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetTexGenxvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLfixed*)(inptr_params.get()), size_params);
this->glGetTexGenxvOES(var_coord, var_pname, (GLfixed*)(inptr_params.get()));
SET_LASTCALL("glGetTexGenxvOES");
android::base::endTrace();
@@ -3988,6 +5265,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glBindVertexArrayOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindVertexArrayOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glBindVertexArrayOES(array:%u )", stream, var_array);
this->glBindVertexArrayOES(var_array);
SET_LASTCALL("glBindVertexArrayOES");
android::base::endTrace();
@@ -4002,6 +5284,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_arrays, ptr + 8 + 4 + 4 + size_arrays, checksumSize,
"gles1_decoder_context_t::decode, OP_glDeleteVertexArraysOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteVertexArraysOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDeleteVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (const GLuint*)(inptr_arrays.get()), size_arrays);
this->glDeleteVertexArraysOES_dec(this, var_n, (const GLuint*)(inptr_arrays.get()));
SET_LASTCALL("glDeleteVertexArraysOES");
android::base::endTrace();
@@ -4019,6 +5306,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_arrays(&tmpBuf[0], size_arrays);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenVertexArraysOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGenVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (GLuint*)(outptr_arrays.get()), size_arrays);
this->glGenVertexArraysOES_dec(this, var_n, (GLuint*)(outptr_arrays.get()));
outptr_arrays.flush();
if (useChecksum) {
@@ -4039,6 +5331,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsVertexArrayOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glIsVertexArrayOES(array:%u )", stream, var_array);
*(GLboolean *)(&tmpBuf[0]) = this->glIsVertexArrayOES(var_array);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4058,6 +5355,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_attachments, ptr + 8 + 4 + 4 + 4 + size_attachments, checksumSize,
"gles1_decoder_context_t::decode, OP_glDiscardFramebufferEXT: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDiscardFramebufferEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDiscardFramebufferEXT(target:0x%08x numAttachments:%d attachments:%p(%u) )", stream, var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()), size_attachments);
this->glDiscardFramebufferEXT(var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()));
SET_LASTCALL("glDiscardFramebufferEXT");
android::base::endTrace();
@@ -4075,6 +5377,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_first + 4 + size_count + 4, ptr + 8 + 4 + 4 + size_first + 4 + size_count + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultiDrawArraysEXT: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawArraysEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultiDrawArraysEXT(mode:0x%08x first:%p(%u) count:%p(%u) primcount:%d )", stream, var_mode, (const GLint*)(inptr_first.get()), size_first, (const GLsizei*)(inptr_count.get()), size_count, var_primcount);
this->glMultiDrawArraysEXT(var_mode, (const GLint*)(inptr_first.get()), (const GLsizei*)(inptr_count.get()), var_primcount);
SET_LASTCALL("glMultiDrawArraysEXT");
android::base::endTrace();
@@ -4093,6 +5400,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultiDrawElementsEXT: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawElementsEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultiDrawElementsEXT(mode:0x%08x count:%p(%u) type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, (const GLsizei*)(inptr_count.get()), size_count, var_type, (const GLvoid* const*)(inptr_indices.get()), size_indices, var_primcount);
this->glMultiDrawElementsEXT(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid* const*)(inptr_indices.get()), var_primcount);
SET_LASTCALL("glMultiDrawElementsEXT");
android::base::endTrace();
@@ -4110,6 +5422,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_first + 4 + size_count + 4, ptr + 8 + 4 + 4 + size_first + 4 + size_count + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultiDrawArraysSUN: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawArraysSUN\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultiDrawArraysSUN(mode:0x%08x first:%p(%u) count:%p(%u) primcount:%d )", stream, var_mode, (GLint*)(inptr_first.get()), size_first, (GLsizei*)(inptr_count.get()), size_count, var_primcount);
this->glMultiDrawArraysSUN(var_mode, (GLint*)(inptr_first.get()), (GLsizei*)(inptr_count.get()), var_primcount);
SET_LASTCALL("glMultiDrawArraysSUN");
android::base::endTrace();
@@ -4128,6 +5445,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glMultiDrawElementsSUN: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawElementsSUN\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glMultiDrawElementsSUN(mode:0x%08x count:%p(%u) type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, (const GLsizei*)(inptr_count.get()), size_count, var_type, (const GLvoid**)(inptr_indices.get()), size_indices, var_primcount);
this->glMultiDrawElementsSUN(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid**)(inptr_indices.get()), var_primcount);
SET_LASTCALL("glMultiDrawElementsSUN");
android::base::endTrace();
@@ -4144,6 +5466,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glRenderbufferStorageMultisampleIMG: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRenderbufferStorageMultisampleIMG\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glRenderbufferStorageMultisampleIMG(target:0x%08x samples:%d internalformat:0x%08x width:%d height:%d )", stream, var_target, var_samples, var_internalformat, var_width, var_height);
this->glRenderbufferStorageMultisampleIMG(var_target, var_samples, var_internalformat, var_width, var_height);
SET_LASTCALL("glRenderbufferStorageMultisampleIMG");
android::base::endTrace();
@@ -4161,6 +5488,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFramebufferTexture2DMultisampleIMG: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferTexture2DMultisampleIMG\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFramebufferTexture2DMultisampleIMG(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d samples:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
this->glFramebufferTexture2DMultisampleIMG(var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
SET_LASTCALL("glFramebufferTexture2DMultisampleIMG");
android::base::endTrace();
@@ -4175,6 +5507,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
"gles1_decoder_context_t::decode, OP_glDeleteFencesNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteFencesNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDeleteFencesNV(n:%d fences:%p(%u) )", stream, var_n, (const GLuint*)(inptr_fences.get()), size_fences);
this->glDeleteFencesNV(var_n, (const GLuint*)(inptr_fences.get()));
SET_LASTCALL("glDeleteFencesNV");
android::base::endTrace();
@@ -4189,6 +5526,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
"gles1_decoder_context_t::decode, OP_glGenFencesNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenFencesNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGenFencesNV(n:%d fences:%p(%u) )", stream, var_n, (GLuint*)(inptr_fences.get()), size_fences);
this->glGenFencesNV(var_n, (GLuint*)(inptr_fences.get()));
SET_LASTCALL("glGenFencesNV");
android::base::endTrace();
@@ -4204,6 +5546,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glIsFenceNV(fence:%u )", stream, var_fence);
*(GLboolean *)(&tmpBuf[0]) = this->glIsFenceNV(var_fence);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4223,6 +5570,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTestFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glTestFenceNV(fence:%u )", stream, var_fence);
*(GLboolean *)(&tmpBuf[0]) = this->glTestFenceNV(var_fence);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4245,6 +5597,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFenceivNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetFenceivNV(fence:%u pname:0x%08x params:%p(%u) )", stream, var_fence, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetFenceivNV(var_fence, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4262,6 +5619,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glFinishFenceNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinishFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glFinishFenceNV(fence:%u )", stream, var_fence);
this->glFinishFenceNV(var_fence);
SET_LASTCALL("glFinishFenceNV");
android::base::endTrace();
@@ -4275,6 +5637,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glSetFenceNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSetFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glSetFenceNV(fence:%u condition:0x%08x )", stream, var_fence, var_condition);
this->glSetFenceNV(var_fence, var_condition);
SET_LASTCALL("glSetFenceNV");
android::base::endTrace();
@@ -4295,6 +5662,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_num(&tmpBuf[0], size_num);
OutputBuffer outptr_driverControls(&tmpBuf[0 + size_num], size_driverControls);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetDriverControlsQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetDriverControlsQCOM(num:%p(%u) size:%d driverControls:%p(%u) )", stream, (GLint*)(outptr_num.get()), size_num, var_size, (GLuint*)(outptr_driverControls.get()), size_driverControls);
this->glGetDriverControlsQCOM((GLint*)(outptr_num.get()), var_size, (GLuint*)(outptr_driverControls.get()));
outptr_num.flush();
outptr_driverControls.flush();
@@ -4322,6 +5694,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_driverControlString(&tmpBuf[0 + size_length], size_driverControlString);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetDriverControlStringQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetDriverControlStringQCOM(driverControl:%u bufSize:%d length:%p(%u) driverControlString:%p(%u) )", stream, var_driverControl, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_driverControlString.get()), size_driverControlString);
this->glGetDriverControlStringQCOM(var_driverControl, var_bufSize, (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_driverControlString.get()));
outptr_length.flush();
outptr_driverControlString.flush();
@@ -4340,6 +5717,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glEnableDriverControlQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnableDriverControlQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glEnableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
this->glEnableDriverControlQCOM(var_driverControl);
SET_LASTCALL("glEnableDriverControlQCOM");
android::base::endTrace();
@@ -4352,6 +5734,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glDisableDriverControlQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisableDriverControlQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glDisableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
this->glDisableDriverControlQCOM(var_driverControl);
SET_LASTCALL("glDisableDriverControlQCOM");
android::base::endTrace();
@@ -4372,6 +5759,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
OutputBuffer outptr_numTextures(&tmpBuf[0 + size_textures], size_numTextures);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexturesQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetTexturesQCOM(textures:%p(%u) maxTextures:%d numTextures:%p(%u) )", stream, (GLuint*)(outptr_textures.get()), size_textures, var_maxTextures, (GLint*)(outptr_numTextures.get()), size_numTextures);
this->glExtGetTexturesQCOM((GLuint*)(outptr_textures.get()), var_maxTextures, (GLint*)(outptr_numTextures.get()));
outptr_textures.flush();
outptr_numTextures.flush();
@@ -4398,6 +5790,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
OutputBuffer outptr_numBuffers(&tmpBuf[0 + size_buffers], size_numBuffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetBuffersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetBuffersQCOM(buffers:%p(%u) maxBuffers:%d numBuffers:%p(%u) )", stream, (GLuint*)(outptr_buffers.get()), size_buffers, var_maxBuffers, (GLint*)(outptr_numBuffers.get()), size_numBuffers);
this->glExtGetBuffersQCOM((GLuint*)(outptr_buffers.get()), var_maxBuffers, (GLint*)(outptr_numBuffers.get()));
outptr_buffers.flush();
outptr_numBuffers.flush();
@@ -4424,6 +5821,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
OutputBuffer outptr_numRenderbuffers(&tmpBuf[0 + size_renderbuffers], size_numRenderbuffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetRenderbuffersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetRenderbuffersQCOM(renderbuffers:%p(%u) maxRenderbuffers:%d numRenderbuffers:%p(%u) )", stream, (GLuint*)(outptr_renderbuffers.get()), size_renderbuffers, var_maxRenderbuffers, (GLint*)(outptr_numRenderbuffers.get()), size_numRenderbuffers);
this->glExtGetRenderbuffersQCOM((GLuint*)(outptr_renderbuffers.get()), var_maxRenderbuffers, (GLint*)(outptr_numRenderbuffers.get()));
outptr_renderbuffers.flush();
outptr_numRenderbuffers.flush();
@@ -4450,6 +5852,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
OutputBuffer outptr_numFramebuffers(&tmpBuf[0 + size_framebuffers], size_numFramebuffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetFramebuffersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetFramebuffersQCOM(framebuffers:%p(%u) maxFramebuffers:%d numFramebuffers:%p(%u) )", stream, (GLuint*)(outptr_framebuffers.get()), size_framebuffers, var_maxFramebuffers, (GLint*)(outptr_numFramebuffers.get()), size_numFramebuffers);
this->glExtGetFramebuffersQCOM((GLuint*)(outptr_framebuffers.get()), var_maxFramebuffers, (GLint*)(outptr_numFramebuffers.get()));
outptr_framebuffers.flush();
outptr_numFramebuffers.flush();
@@ -4476,6 +5883,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexLevelParameterivQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetTexLevelParameterivQCOM(texture:%u face:0x%08x level:%d pname:0x%08x params:%p(%u) )", stream, var_texture, var_face, var_level, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glExtGetTexLevelParameterivQCOM(var_texture, var_face, var_level, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4495,6 +5907,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glExtTexObjectStateOverrideiQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtTexObjectStateOverrideiQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtTexObjectStateOverrideiQCOM(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
this->glExtTexObjectStateOverrideiQCOM(var_target, var_pname, var_param);
SET_LASTCALL("glExtTexObjectStateOverrideiQCOM");
android::base::endTrace();
@@ -4521,6 +5938,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_texels(&tmpBuf[0], size_texels);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexSubImageQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetTexSubImageQCOM(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x type:0x%08x texels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (GLvoid*)(outptr_texels.get()), size_texels);
this->glExtGetTexSubImageQCOM(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (GLvoid*)(outptr_texels.get()));
outptr_texels.flush();
if (useChecksum) {
@@ -4540,6 +5962,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles1_decoder_context_t::decode, OP_glExtGetBufferPointervQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetBufferPointervQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetBufferPointervQCOM(target:0x%08x params:%p(%u) )", stream, var_target, (GLvoid**)(inptr_params.get()), size_params);
this->glExtGetBufferPointervQCOM(var_target, (GLvoid**)(inptr_params.get()));
SET_LASTCALL("glExtGetBufferPointervQCOM");
android::base::endTrace();
@@ -4560,6 +5987,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_shaders(&tmpBuf[0], size_shaders);
OutputBuffer outptr_numShaders(&tmpBuf[0 + size_shaders], size_numShaders);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetShadersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetShadersQCOM(shaders:%p(%u) maxShaders:%d numShaders:%p(%u) )", stream, (GLuint*)(outptr_shaders.get()), size_shaders, var_maxShaders, (GLint*)(outptr_numShaders.get()), size_numShaders);
this->glExtGetShadersQCOM((GLuint*)(outptr_shaders.get()), var_maxShaders, (GLint*)(outptr_numShaders.get()));
outptr_shaders.flush();
outptr_numShaders.flush();
@@ -4586,6 +6018,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_programs(&tmpBuf[0], size_programs);
OutputBuffer outptr_numPrograms(&tmpBuf[0 + size_programs], size_numPrograms);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetProgramsQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetProgramsQCOM(programs:%p(%u) maxPrograms:%d numPrograms:%p(%u) )", stream, (GLuint*)(outptr_programs.get()), size_programs, var_maxPrograms, (GLint*)(outptr_numPrograms.get()), size_numPrograms);
this->glExtGetProgramsQCOM((GLuint*)(outptr_programs.get()), var_maxPrograms, (GLint*)(outptr_numPrograms.get()));
outptr_programs.flush();
outptr_numPrograms.flush();
@@ -4607,6 +6044,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtIsProgramBinaryQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtIsProgramBinaryQCOM(program:%u )", stream, var_program);
*(GLboolean *)(&tmpBuf[0]) = this->glExtIsProgramBinaryQCOM(var_program);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4628,6 +6070,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_source + 4 + size_length, ptr + 8 + 4 + 4 + 4 + size_source + 4 + size_length, checksumSize,
"gles1_decoder_context_t::decode, OP_glExtGetProgramBinarySourceQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetProgramBinarySourceQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glExtGetProgramBinarySourceQCOM(program:%u shadertype:0x%08x source:%p(%u) length:%p(%u) )", stream, var_program, var_shadertype, (GLchar*)(inptr_source.get()), size_source, (GLint*)(inptr_length.get()), size_length);
this->glExtGetProgramBinarySourceQCOM(var_program, var_shadertype, (GLchar*)(inptr_source.get()), (GLint*)(inptr_length.get()));
SET_LASTCALL("glExtGetProgramBinarySourceQCOM");
android::base::endTrace();
@@ -4644,6 +6091,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glStartTilingQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStartTilingQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glStartTilingQCOM(x:%u y:%u width:%u height:%u preserveMask:0x%08x )", stream, var_x, var_y, var_width, var_height, var_preserveMask);
this->glStartTilingQCOM(var_x, var_y, var_width, var_height, var_preserveMask);
SET_LASTCALL("glStartTilingQCOM");
android::base::endTrace();
@@ -4656,6 +6108,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles1_decoder_context_t::decode, OP_glEndTilingQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEndTilingQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glEndTilingQCOM(preserveMask:0x%08x )", stream, var_preserveMask);
this->glEndTilingQCOM(var_preserveMask);
SET_LASTCALL("glEndTilingQCOM");
android::base::endTrace();
@@ -4670,6 +6127,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetGraphicsResetStatusEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glGetGraphicsResetStatusEXT()", stream);
*(GLenum *)(&tmpBuf[0]) = this->glGetGraphicsResetStatusEXT();
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4697,6 +6159,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_data(&tmpBuf[0], size_data);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glReadnPixelsEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles1(%p): glReadnPixelsEXT(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x bufSize:%d data:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()), size_data);
this->glReadnPixelsEXT(var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()));
outptr_data.flush();
if (useChecksum) {
diff --git a/stream-servers/gles2_dec/gles2_dec.cpp b/stream-servers/gles2_dec/gles2_dec.cpp
index 593f6b8..f9c3ac4 100644
--- a/stream-servers/gles2_dec/gles2_dec.cpp
+++ b/stream-servers/gles2_dec/gles2_dec.cpp
@@ -12,6 +12,8 @@
#include "ChecksumCalculatorThreadInfo.h"
+#include "host-common/logging.h"
+
#include <stdio.h>
typedef unsigned int tsize_t; // Target "size_t", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled.
@@ -44,6 +46,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glActiveTexture: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glActiveTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glActiveTexture(texture:0x%08x )", stream, var_texture);
this->glActiveTexture(var_texture);
SET_LASTCALL("glActiveTexture");
android::base::endTrace();
@@ -57,6 +64,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glAttachShader: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glAttachShader\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glAttachShader(program:%u shader:%u )", stream, var_program, var_shader);
this->glAttachShader_dec(this, var_program, var_shader);
SET_LASTCALL("glAttachShader");
android::base::endTrace();
@@ -72,6 +84,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_name, ptr + 8 + 4 + 4 + 4 + size_name, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindAttribLocation: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindAttribLocation\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindAttribLocation(program:%u index:%u name:%p(%u) )", stream, var_program, var_index, (const GLchar*)(inptr_name.get()), size_name);
this->glBindAttribLocation_dec(this, var_program, var_index, (const GLchar*)(inptr_name.get()));
SET_LASTCALL("glBindAttribLocation");
android::base::endTrace();
@@ -85,6 +102,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindBuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindBuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindBuffer(target:0x%08x buffer:%u )", stream, var_target, var_buffer);
this->glBindBuffer(var_target, var_buffer);
SET_LASTCALL("glBindBuffer");
android::base::endTrace();
@@ -98,6 +120,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindFramebuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindFramebuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindFramebuffer(target:0x%08x framebuffer:%u )", stream, var_target, var_framebuffer);
this->glBindFramebuffer(var_target, var_framebuffer);
SET_LASTCALL("glBindFramebuffer");
android::base::endTrace();
@@ -111,6 +138,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindRenderbuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindRenderbuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindRenderbuffer(target:0x%08x renderbuffer:%u )", stream, var_target, var_renderbuffer);
this->glBindRenderbuffer(var_target, var_renderbuffer);
SET_LASTCALL("glBindRenderbuffer");
android::base::endTrace();
@@ -124,6 +156,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindTexture: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindTexture(target:0x%08x texture:%u )", stream, var_target, var_texture);
this->glBindTexture(var_target, var_texture);
SET_LASTCALL("glBindTexture");
android::base::endTrace();
@@ -139,6 +176,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBlendColor: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBlendColor\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBlendColor(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
this->glBlendColor(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glBlendColor");
android::base::endTrace();
@@ -151,6 +193,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBlendEquation: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBlendEquation\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBlendEquation(mode:0x%08x )", stream, var_mode);
this->glBlendEquation(var_mode);
SET_LASTCALL("glBlendEquation");
android::base::endTrace();
@@ -164,6 +211,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBlendEquationSeparate: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBlendEquationSeparate\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBlendEquationSeparate(modeRGB:0x%08x modeAlpha:0x%08x )", stream, var_modeRGB, var_modeAlpha);
this->glBlendEquationSeparate(var_modeRGB, var_modeAlpha);
SET_LASTCALL("glBlendEquationSeparate");
android::base::endTrace();
@@ -177,6 +229,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBlendFunc: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBlendFunc\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBlendFunc(sfactor:0x%08x dfactor:0x%08x )", stream, var_sfactor, var_dfactor);
this->glBlendFunc(var_sfactor, var_dfactor);
SET_LASTCALL("glBlendFunc");
android::base::endTrace();
@@ -192,6 +249,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBlendFuncSeparate: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBlendFuncSeparate\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBlendFuncSeparate(srcRGB:0x%08x dstRGB:0x%08x srcAlpha:0x%08x dstAlpha:0x%08x )", stream, var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
this->glBlendFuncSeparate(var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
SET_LASTCALL("glBlendFuncSeparate");
android::base::endTrace();
@@ -208,6 +270,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBufferData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBufferData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBufferData(target:0x%08x size:0x%08lx data:%p(%u) usage:0x%08x )", stream, var_target, var_size, (const GLvoid*)(inptr_data.get()), size_data, var_usage);
this->glBufferData(var_target, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()), var_usage);
SET_LASTCALL("glBufferData");
android::base::endTrace();
@@ -224,6 +291,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glBufferSubData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBufferSubData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBufferSubData(target:0x%08x offset:0x%08lx size:0x%08lx data:%p(%u) )", stream, var_target, var_offset, var_size, (const GLvoid*)(inptr_data.get()), size_data);
this->glBufferSubData(var_target, var_offset, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glBufferSubData");
android::base::endTrace();
@@ -239,6 +311,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCheckFramebufferStatus\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCheckFramebufferStatus(target:0x%08x )", stream, var_target);
*(GLenum *)(&tmpBuf[0]) = this->glCheckFramebufferStatus(var_target);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -255,6 +332,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glClear: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClear\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClear(mask:0x%08x )", stream, var_mask);
this->glClear(var_mask);
SET_LASTCALL("glClear");
android::base::endTrace();
@@ -270,6 +352,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glClearColor: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClearColor\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClearColor(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
this->glClearColor(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glClearColor");
android::base::endTrace();
@@ -282,6 +369,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glClearDepthf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClearDepthf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClearDepthf(depth:%f )", stream, var_depth);
this->glClearDepthf(var_depth);
SET_LASTCALL("glClearDepthf");
android::base::endTrace();
@@ -294,6 +386,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glClearStencil: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClearStencil\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClearStencil(s:%d )", stream, var_s);
this->glClearStencil(var_s);
SET_LASTCALL("glClearStencil");
android::base::endTrace();
@@ -309,6 +406,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1 + 1 + 1 + 1, ptr + 8 + 1 + 1 + 1 + 1, checksumSize,
"gles2_decoder_context_t::decode, OP_glColorMask: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glColorMask\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glColorMask(red:%d green:%d blue:%d alpha:%d )", stream, var_red, var_green, var_blue, var_alpha);
this->glColorMask(var_red, var_green, var_blue, var_alpha);
SET_LASTCALL("glColorMask");
android::base::endTrace();
@@ -321,6 +423,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompileShader: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompileShader\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompileShader(shader:%u )", stream, var_shader);
this->glCompileShader_dec(this, var_shader);
SET_LASTCALL("glCompileShader");
android::base::endTrace();
@@ -341,6 +448,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexImage2D(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d border:%d imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexImage2D(var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexImage2D");
android::base::endTrace();
@@ -362,6 +474,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexSubImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexSubImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexSubImage2D");
android::base::endTrace();
@@ -381,6 +498,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCopyTexImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCopyTexImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCopyTexImage2D(target:0x%08x level:%d internalformat:0x%08x x:%d y:%d width:%d height:%d border:%d )", stream, var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
this->glCopyTexImage2D(var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
SET_LASTCALL("glCopyTexImage2D");
android::base::endTrace();
@@ -400,6 +522,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCopyTexSubImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCopyTexSubImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCopyTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d x:%d y:%d width:%d height:%d )", stream, var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
this->glCopyTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
SET_LASTCALL("glCopyTexSubImage2D");
android::base::endTrace();
@@ -414,6 +541,11 @@
size_t totalTmpSize = sizeof(GLuint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCreateProgram\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCreateProgram()", stream);
*(GLuint *)(&tmpBuf[0]) = this->glCreateProgram_dec(this);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -433,6 +565,11 @@
size_t totalTmpSize = sizeof(GLuint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCreateShader\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCreateShader(type:0x%08x )", stream, var_type);
*(GLuint *)(&tmpBuf[0]) = this->glCreateShader_dec(this, var_type);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -449,6 +586,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCullFace: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCullFace\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCullFace(mode:0x%08x )", stream, var_mode);
this->glCullFace(var_mode);
SET_LASTCALL("glCullFace");
android::base::endTrace();
@@ -463,6 +605,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_buffers, ptr + 8 + 4 + 4 + size_buffers, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteBuffers: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteBuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteBuffers(n:%d buffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_buffers.get()), size_buffers);
this->glDeleteBuffers_dec(this, var_n, (const GLuint*)(inptr_buffers.get()));
SET_LASTCALL("glDeleteBuffers");
android::base::endTrace();
@@ -477,6 +624,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_framebuffers, ptr + 8 + 4 + 4 + size_framebuffers, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteFramebuffers: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteFramebuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteFramebuffers(n:%d framebuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_framebuffers.get()), size_framebuffers);
this->glDeleteFramebuffers_dec(this, var_n, (const GLuint*)(inptr_framebuffers.get()));
SET_LASTCALL("glDeleteFramebuffers");
android::base::endTrace();
@@ -489,6 +641,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteProgram: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteProgram\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteProgram(program:%u )", stream, var_program);
this->glDeleteProgram_dec(this, var_program);
SET_LASTCALL("glDeleteProgram");
android::base::endTrace();
@@ -503,6 +660,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_renderbuffers, ptr + 8 + 4 + 4 + size_renderbuffers, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteRenderbuffers: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteRenderbuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteRenderbuffers(n:%d renderbuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_renderbuffers.get()), size_renderbuffers);
this->glDeleteRenderbuffers_dec(this, var_n, (const GLuint*)(inptr_renderbuffers.get()));
SET_LASTCALL("glDeleteRenderbuffers");
android::base::endTrace();
@@ -515,6 +677,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteShader: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteShader\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteShader(shader:%u )", stream, var_shader);
this->glDeleteShader_dec(this, var_shader);
SET_LASTCALL("glDeleteShader");
android::base::endTrace();
@@ -529,6 +696,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_textures, ptr + 8 + 4 + 4 + size_textures, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteTextures: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteTextures\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteTextures(n:%d textures:%p(%u) )", stream, var_n, (const GLuint*)(inptr_textures.get()), size_textures);
this->glDeleteTextures_dec(this, var_n, (const GLuint*)(inptr_textures.get()));
SET_LASTCALL("glDeleteTextures");
android::base::endTrace();
@@ -541,6 +713,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDepthFunc: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDepthFunc\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDepthFunc(func:0x%08x )", stream, var_func);
this->glDepthFunc(var_func);
SET_LASTCALL("glDepthFunc");
android::base::endTrace();
@@ -553,6 +730,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1, ptr + 8 + 1, checksumSize,
"gles2_decoder_context_t::decode, OP_glDepthMask: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDepthMask\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDepthMask(flag:%d )", stream, var_flag);
this->glDepthMask(var_flag);
SET_LASTCALL("glDepthMask");
android::base::endTrace();
@@ -566,6 +748,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDepthRangef: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDepthRangef\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDepthRangef(zNear:%f zFar:%f )", stream, var_zNear, var_zFar);
this->glDepthRangef(var_zNear, var_zFar);
SET_LASTCALL("glDepthRangef");
android::base::endTrace();
@@ -579,6 +766,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDetachShader: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDetachShader\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDetachShader(program:%u shader:%u )", stream, var_program, var_shader);
this->glDetachShader_dec(this, var_program, var_shader);
SET_LASTCALL("glDetachShader");
android::base::endTrace();
@@ -591,6 +783,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDisable: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDisable\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDisable(cap:0x%08x )", stream, var_cap);
this->glDisable(var_cap);
SET_LASTCALL("glDisable");
android::base::endTrace();
@@ -603,6 +800,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDisableVertexAttribArray: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDisableVertexAttribArray\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDisableVertexAttribArray(index:%u )", stream, var_index);
this->glDisableVertexAttribArray(var_index);
SET_LASTCALL("glDisableVertexAttribArray");
android::base::endTrace();
@@ -617,6 +819,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawArrays: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawArrays\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawArrays(mode:0x%08x first:%d count:%d )", stream, var_mode, var_first, var_count);
this->glDrawArrays(var_mode, var_first, var_count);
SET_LASTCALL("glDrawArrays");
android::base::endTrace();
@@ -633,6 +840,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_indices, ptr + 8 + 4 + 4 + 4 + 4 + size_indices, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElements: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElements\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElements(mode:0x%08x count:%d type:0x%08x indices:%p(%u) )", stream, var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()), size_indices);
this->glDrawElements(var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()));
SET_LASTCALL("glDrawElements");
android::base::endTrace();
@@ -645,6 +857,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEnable: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEnable\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEnable(cap:0x%08x )", stream, var_cap);
this->glEnable(var_cap);
SET_LASTCALL("glEnable");
android::base::endTrace();
@@ -657,6 +874,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEnableVertexAttribArray: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEnableVertexAttribArray\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEnableVertexAttribArray(index:%u )", stream, var_index);
this->glEnableVertexAttribArray(var_index);
SET_LASTCALL("glEnableVertexAttribArray");
android::base::endTrace();
@@ -668,6 +890,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glFinish: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFinish\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFinish()", stream);
this->glFinish();
SET_LASTCALL("glFinish");
android::base::endTrace();
@@ -679,6 +906,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glFlush: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFlush\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFlush()", stream);
this->glFlush();
SET_LASTCALL("glFlush");
android::base::endTrace();
@@ -694,6 +926,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFramebufferRenderbuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFramebufferRenderbuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFramebufferRenderbuffer(target:0x%08x attachment:0x%08x renderbuffertarget:0x%08x renderbuffer:%u )", stream, var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
this->glFramebufferRenderbuffer(var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
SET_LASTCALL("glFramebufferRenderbuffer");
android::base::endTrace();
@@ -710,6 +947,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFramebufferTexture2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFramebufferTexture2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFramebufferTexture2D(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level);
this->glFramebufferTexture2D(var_target, var_attachment, var_textarget, var_texture, var_level);
SET_LASTCALL("glFramebufferTexture2D");
android::base::endTrace();
@@ -722,6 +964,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFrontFace: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFrontFace\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFrontFace(mode:0x%08x )", stream, var_mode);
this->glFrontFace(var_mode);
SET_LASTCALL("glFrontFace");
android::base::endTrace();
@@ -739,6 +986,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenBuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenBuffers(n:%d buffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_buffers.get()), size_buffers);
this->glGenBuffers_dec(this, var_n, (GLuint*)(outptr_buffers.get()));
outptr_buffers.flush();
if (useChecksum) {
@@ -756,6 +1008,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glGenerateMipmap: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenerateMipmap\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenerateMipmap(target:0x%08x )", stream, var_target);
this->glGenerateMipmap(var_target);
SET_LASTCALL("glGenerateMipmap");
android::base::endTrace();
@@ -773,6 +1030,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenFramebuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenFramebuffers(n:%d framebuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_framebuffers.get()), size_framebuffers);
this->glGenFramebuffers_dec(this, var_n, (GLuint*)(outptr_framebuffers.get()));
outptr_framebuffers.flush();
if (useChecksum) {
@@ -795,6 +1057,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenRenderbuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenRenderbuffers(n:%d renderbuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_renderbuffers.get()), size_renderbuffers);
this->glGenRenderbuffers_dec(this, var_n, (GLuint*)(outptr_renderbuffers.get()));
outptr_renderbuffers.flush();
if (useChecksum) {
@@ -817,6 +1084,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenTextures\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenTextures(n:%d textures:%p(%u) )", stream, var_n, (GLuint*)(outptr_textures.get()), size_textures);
this->glGenTextures_dec(this, var_n, (GLuint*)(outptr_textures.get()));
outptr_textures.flush();
if (useChecksum) {
@@ -850,6 +1122,11 @@
OutputBuffer outptr_size(&tmpBuf[0 + size_length], size_size);
OutputBuffer outptr_type(&tmpBuf[0 + size_length + size_size], size_type);
OutputBuffer outptr_name(&tmpBuf[0 + size_length + size_size + size_type], size_name);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetActiveAttrib\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetActiveAttrib(program:%u index:%u bufsize:%d length:%p(%u) size:%p(%u) type:%p(%u) name:%p(%u) )", stream, var_program, var_index, var_bufsize, (GLsizei*)(outptr_length.get()), size_length, (GLint*)(outptr_size.get()), size_size, (GLenum*)(outptr_type.get()), size_type, (GLchar*)(outptr_name.get()), size_name);
this->glGetActiveAttrib_dec(this, var_program, var_index, var_bufsize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), size_size == 0 ? nullptr : (GLint*)(outptr_size.get()), size_type == 0 ? nullptr : (GLenum*)(outptr_type.get()), size_name == 0 ? nullptr : (GLchar*)(outptr_name.get()));
outptr_length.flush();
outptr_size.flush();
@@ -886,6 +1163,11 @@
OutputBuffer outptr_size(&tmpBuf[0 + size_length], size_size);
OutputBuffer outptr_type(&tmpBuf[0 + size_length + size_size], size_type);
OutputBuffer outptr_name(&tmpBuf[0 + size_length + size_size + size_type], size_name);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetActiveUniform\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetActiveUniform(program:%u index:%u bufsize:%d length:%p(%u) size:%p(%u) type:%p(%u) name:%p(%u) )", stream, var_program, var_index, var_bufsize, (GLsizei*)(outptr_length.get()), size_length, (GLint*)(outptr_size.get()), size_size, (GLenum*)(outptr_type.get()), size_type, (GLchar*)(outptr_name.get()), size_name);
this->glGetActiveUniform_dec(this, var_program, var_index, var_bufsize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), size_size == 0 ? nullptr : (GLint*)(outptr_size.get()), size_type == 0 ? nullptr : (GLenum*)(outptr_type.get()), size_name == 0 ? nullptr : (GLchar*)(outptr_name.get()));
outptr_length.flush();
outptr_size.flush();
@@ -915,6 +1197,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_count(&tmpBuf[0], size_count);
OutputBuffer outptr_shaders(&tmpBuf[0 + size_count], size_shaders);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetAttachedShaders\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetAttachedShaders(program:%u maxcount:%d count:%p(%u) shaders:%p(%u) )", stream, var_program, var_maxcount, (GLsizei*)(outptr_count.get()), size_count, (GLuint*)(outptr_shaders.get()), size_shaders);
this->glGetAttachedShaders_dec(this, var_program, var_maxcount, size_count == 0 ? nullptr : (GLsizei*)(outptr_count.get()), (GLuint*)(outptr_shaders.get()));
outptr_count.flush();
outptr_shaders.flush();
@@ -938,6 +1225,11 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetAttribLocation\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetAttribLocation(program:%u name:%p(%u) )", stream, var_program, (const GLchar*)(inptr_name.get()), size_name);
*(int *)(&tmpBuf[0]) = this->glGetAttribLocation_dec(this, var_program, (const GLchar*)(inptr_name.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -959,6 +1251,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetBooleanv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetBooleanv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLboolean*)(outptr_params.get()), size_params);
this->glGetBooleanv(var_pname, (GLboolean*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -982,6 +1279,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetBufferParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetBufferParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetBufferParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1001,6 +1303,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetError\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetError()", stream);
*(GLenum *)(&tmpBuf[0]) = this->glGetError();
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1022,6 +1329,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetFloatv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetFloatv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetFloatv(var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1046,6 +1358,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetFramebufferAttachmentParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetFramebufferAttachmentParameteriv(target:0x%08x attachment:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetFramebufferAttachmentParameteriv(var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1068,6 +1385,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetIntegerv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetIntegerv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetIntegerv(var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1091,6 +1413,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramiv(program:%u pname:0x%08x params:%p(%u) )", stream, var_program, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetProgramiv_dec(this, var_program, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1117,6 +1444,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_infolog(&tmpBuf[0 + size_length], size_infolog);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramInfoLog\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramInfoLog(program:%u bufsize:%d length:%p(%u) infolog:%p(%u) )", stream, var_program, var_bufsize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_infolog.get()), size_infolog);
this->glGetProgramInfoLog_dec(this, var_program, var_bufsize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_infolog.get()));
outptr_length.flush();
outptr_infolog.flush();
@@ -1141,6 +1473,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetRenderbufferParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetRenderbufferParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetRenderbufferParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1164,6 +1501,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetShaderiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetShaderiv(shader:%u pname:0x%08x params:%p(%u) )", stream, var_shader, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetShaderiv_dec(this, var_shader, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1190,6 +1532,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_infolog(&tmpBuf[0 + size_length], size_infolog);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetShaderInfoLog\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetShaderInfoLog(shader:%u bufsize:%d length:%p(%u) infolog:%p(%u) )", stream, var_shader, var_bufsize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_infolog.get()), size_infolog);
this->glGetShaderInfoLog_dec(this, var_shader, var_bufsize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_infolog.get()));
outptr_length.flush();
outptr_infolog.flush();
@@ -1217,6 +1564,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_range(&tmpBuf[0], size_range);
OutputBuffer outptr_precision(&tmpBuf[0 + size_range], size_precision);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetShaderPrecisionFormat\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetShaderPrecisionFormat(shadertype:0x%08x precisiontype:0x%08x range:%p(%u) precision:%p(%u) )", stream, var_shadertype, var_precisiontype, (GLint*)(outptr_range.get()), size_range, (GLint*)(outptr_precision.get()), size_precision);
this->glGetShaderPrecisionFormat(var_shadertype, var_precisiontype, (GLint*)(outptr_range.get()), (GLint*)(outptr_precision.get()));
outptr_range.flush();
outptr_precision.flush();
@@ -1244,6 +1596,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_source(&tmpBuf[0 + size_length], size_source);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetShaderSource\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetShaderSource(shader:%u bufsize:%d length:%p(%u) source:%p(%u) )", stream, var_shader, var_bufsize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_source.get()), size_source);
this->glGetShaderSource_dec(this, var_shader, var_bufsize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_source.get()));
outptr_length.flush();
outptr_source.flush();
@@ -1262,6 +1619,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetString: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetString\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetString(name:0x%08x )", stream, var_name);
this->glGetString(var_name);
SET_LASTCALL("glGetString");
android::base::endTrace();
@@ -1280,6 +1642,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetTexParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetTexParameterfv(var_target, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1303,6 +1670,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetTexParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetTexParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1326,6 +1698,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetUniformfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetUniformfv(program:%u location:%d params:%p(%u) )", stream, var_program, var_location, (GLfloat*)(outptr_params.get()), size_params);
this->glGetUniformfv_dec(this, var_program, var_location, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1349,6 +1726,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetUniformiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetUniformiv(program:%u location:%d params:%p(%u) )", stream, var_program, var_location, (GLint*)(outptr_params.get()), size_params);
this->glGetUniformiv_dec(this, var_program, var_location, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1371,6 +1753,11 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetUniformLocation\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetUniformLocation(program:%u name:%p(%u) )", stream, var_program, (const GLchar*)(inptr_name.get()), size_name);
*(int *)(&tmpBuf[0]) = this->glGetUniformLocation_dec(this, var_program, (const GLchar*)(inptr_name.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1393,6 +1780,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetVertexAttribfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetVertexAttribfv(index:%u pname:0x%08x params:%p(%u) )", stream, var_index, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetVertexAttribfv(var_index, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1416,6 +1808,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetVertexAttribiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetVertexAttribiv(index:%u pname:0x%08x params:%p(%u) )", stream, var_index, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetVertexAttribiv(var_index, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -1436,6 +1833,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetVertexAttribPointerv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetVertexAttribPointerv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetVertexAttribPointerv(index:%u pname:0x%08x pointer:%p(%u) )", stream, var_index, var_pname, (GLvoid**)(inptr_pointer.get()), size_pointer);
this->glGetVertexAttribPointerv(var_index, var_pname, (GLvoid**)(inptr_pointer.get()));
SET_LASTCALL("glGetVertexAttribPointerv");
android::base::endTrace();
@@ -1449,6 +1851,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glHint: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glHint\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glHint(target:0x%08x mode:0x%08x )", stream, var_target, var_mode);
this->glHint(var_target, var_mode);
SET_LASTCALL("glHint");
android::base::endTrace();
@@ -1464,6 +1871,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsBuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsBuffer(buffer:%u )", stream, var_buffer);
*(GLboolean *)(&tmpBuf[0]) = this->glIsBuffer(var_buffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1483,6 +1895,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsEnabled\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsEnabled(cap:0x%08x )", stream, var_cap);
*(GLboolean *)(&tmpBuf[0]) = this->glIsEnabled(var_cap);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1502,6 +1919,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsFramebuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsFramebuffer(framebuffer:%u )", stream, var_framebuffer);
*(GLboolean *)(&tmpBuf[0]) = this->glIsFramebuffer(var_framebuffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1521,6 +1943,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsProgram\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsProgram(program:%u )", stream, var_program);
*(GLboolean *)(&tmpBuf[0]) = this->glIsProgram_dec(this, var_program);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1540,6 +1967,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsRenderbuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsRenderbuffer(renderbuffer:%u )", stream, var_renderbuffer);
*(GLboolean *)(&tmpBuf[0]) = this->glIsRenderbuffer(var_renderbuffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1559,6 +1991,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsShader\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsShader(shader:%u )", stream, var_shader);
*(GLboolean *)(&tmpBuf[0]) = this->glIsShader_dec(this, var_shader);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1578,6 +2015,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsTexture(texture:%u )", stream, var_texture);
*(GLboolean *)(&tmpBuf[0]) = this->glIsTexture(var_texture);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1594,6 +2036,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glLineWidth: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glLineWidth\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glLineWidth(width:%f )", stream, var_width);
this->glLineWidth(var_width);
SET_LASTCALL("glLineWidth");
android::base::endTrace();
@@ -1606,6 +2053,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glLinkProgram: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glLinkProgram\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glLinkProgram(program:%u )", stream, var_program);
this->glLinkProgram_dec(this, var_program);
SET_LASTCALL("glLinkProgram");
android::base::endTrace();
@@ -1619,6 +2071,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glPixelStorei: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glPixelStorei\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glPixelStorei(pname:0x%08x param:%d )", stream, var_pname, var_param);
this->glPixelStorei(var_pname, var_param);
SET_LASTCALL("glPixelStorei");
android::base::endTrace();
@@ -1632,6 +2089,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glPolygonOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glPolygonOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glPolygonOffset(factor:%f units:%f )", stream, var_factor, var_units);
this->glPolygonOffset(var_factor, var_units);
SET_LASTCALL("glPolygonOffset");
android::base::endTrace();
@@ -1654,6 +2116,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glReadPixels\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glReadPixels(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()), size_pixels);
this->glReadPixels(var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()));
outptr_pixels.flush();
if (useChecksum) {
@@ -1670,6 +2137,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glReleaseShaderCompiler: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glReleaseShaderCompiler\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glReleaseShaderCompiler()", stream);
this->glReleaseShaderCompiler();
SET_LASTCALL("glReleaseShaderCompiler");
android::base::endTrace();
@@ -1685,6 +2157,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glRenderbufferStorage: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glRenderbufferStorage\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glRenderbufferStorage(target:0x%08x internalformat:0x%08x width:%d height:%d )", stream, var_target, var_internalformat, var_width, var_height);
this->glRenderbufferStorage(var_target, var_internalformat, var_width, var_height);
SET_LASTCALL("glRenderbufferStorage");
android::base::endTrace();
@@ -1698,6 +2175,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
"gles2_decoder_context_t::decode, OP_glSampleCoverage: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSampleCoverage\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSampleCoverage(value:%f invert:%d )", stream, var_value, var_invert);
this->glSampleCoverage(var_value, var_invert);
SET_LASTCALL("glSampleCoverage");
android::base::endTrace();
@@ -1713,6 +2195,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glScissor: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glScissor\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glScissor(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
this->glScissor(var_x, var_y, var_width, var_height);
SET_LASTCALL("glScissor");
android::base::endTrace();
@@ -1731,6 +2218,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_shaders + 4 + 4 + size_binary + 4, ptr + 8 + 4 + 4 + size_shaders + 4 + 4 + size_binary + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glShaderBinary: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glShaderBinary\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glShaderBinary(n:%d shaders:%p(%u) binaryformat:0x%08x binary:%p(%u) length:%d )", stream, var_n, (const GLuint*)(inptr_shaders.get()), size_shaders, var_binaryformat, (const GLvoid*)(inptr_binary.get()), size_binary, var_length);
this->glShaderBinary(var_n, (const GLuint*)(inptr_shaders.get()), var_binaryformat, (const GLvoid*)(inptr_binary.get()), var_length);
SET_LASTCALL("glShaderBinary");
android::base::endTrace();
@@ -1748,6 +2240,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_string + 4 + size_length, ptr + 8 + 4 + 4 + 4 + size_string + 4 + size_length, checksumSize,
"gles2_decoder_context_t::decode, OP_glShaderSource: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glShaderSource\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glShaderSource(shader:%u count:%d string:%p(%u) length:%p(%u) )", stream, var_shader, var_count, (const GLchar* const*)(inptr_string.get()), size_string, (const GLint*)(inptr_length.get()), size_length);
this->glShaderSource(var_shader, var_count, (const GLchar* const*)(inptr_string.get()), (const GLint*)(inptr_length.get()));
SET_LASTCALL("glShaderSource");
android::base::endTrace();
@@ -1762,6 +2259,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glStencilFunc: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glStencilFunc\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glStencilFunc(func:0x%08x ref:%d mask:%u )", stream, var_func, var_ref, var_mask);
this->glStencilFunc(var_func, var_ref, var_mask);
SET_LASTCALL("glStencilFunc");
android::base::endTrace();
@@ -1777,6 +2279,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glStencilFuncSeparate: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glStencilFuncSeparate\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glStencilFuncSeparate(face:0x%08x func:0x%08x ref:%d mask:%u )", stream, var_face, var_func, var_ref, var_mask);
this->glStencilFuncSeparate(var_face, var_func, var_ref, var_mask);
SET_LASTCALL("glStencilFuncSeparate");
android::base::endTrace();
@@ -1789,6 +2296,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glStencilMask: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glStencilMask\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glStencilMask(mask:%u )", stream, var_mask);
this->glStencilMask(var_mask);
SET_LASTCALL("glStencilMask");
android::base::endTrace();
@@ -1802,6 +2314,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glStencilMaskSeparate: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glStencilMaskSeparate\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glStencilMaskSeparate(face:0x%08x mask:%u )", stream, var_face, var_mask);
this->glStencilMaskSeparate(var_face, var_mask);
SET_LASTCALL("glStencilMaskSeparate");
android::base::endTrace();
@@ -1816,6 +2333,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glStencilOp: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glStencilOp\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glStencilOp(fail:0x%08x zfail:0x%08x zpass:0x%08x )", stream, var_fail, var_zfail, var_zpass);
this->glStencilOp(var_fail, var_zfail, var_zpass);
SET_LASTCALL("glStencilOp");
android::base::endTrace();
@@ -1831,6 +2353,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glStencilOpSeparate: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glStencilOpSeparate\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glStencilOpSeparate(face:0x%08x fail:0x%08x zfail:0x%08x zpass:0x%08x )", stream, var_face, var_fail, var_zfail, var_zpass);
this->glStencilOpSeparate(var_face, var_fail, var_zfail, var_zpass);
SET_LASTCALL("glStencilOpSeparate");
android::base::endTrace();
@@ -1852,6 +2379,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexImage2D(target:0x%08x level:%d internalformat:%d width:%d height:%d border:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
this->glTexImage2D(var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
SET_LASTCALL("glTexImage2D");
android::base::endTrace();
@@ -1866,6 +2398,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexParameterf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexParameterf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexParameterf(target:0x%08x pname:0x%08x param:%f )", stream, var_target, var_pname, var_param);
this->glTexParameterf(var_target, var_pname, var_param);
SET_LASTCALL("glTexParameterf");
android::base::endTrace();
@@ -1881,6 +2418,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexParameterfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glTexParameterfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glTexParameterfv");
android::base::endTrace();
@@ -1895,6 +2437,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexParameteri: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexParameteri\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexParameteri(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
this->glTexParameteri(var_target, var_pname, var_param);
SET_LASTCALL("glTexParameteri");
android::base::endTrace();
@@ -1910,6 +2457,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexParameteriv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLint*)(inptr_params.get()), size_params);
this->glTexParameteriv(var_target, var_pname, (const GLint*)(inptr_params.get()));
SET_LASTCALL("glTexParameteriv");
android::base::endTrace();
@@ -1931,6 +2483,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexSubImage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexSubImage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
this->glTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
SET_LASTCALL("glTexSubImage2D");
android::base::endTrace();
@@ -1944,6 +2501,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform1f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform1f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform1f(location:%d x:%f )", stream, var_location, var_x);
this->glUniform1f(var_location, var_x);
SET_LASTCALL("glUniform1f");
android::base::endTrace();
@@ -1959,6 +2521,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform1fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform1fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform1fv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLfloat*)(inptr_v.get()), size_v);
this->glUniform1fv(var_location, var_count, (const GLfloat*)(inptr_v.get()));
SET_LASTCALL("glUniform1fv");
android::base::endTrace();
@@ -1972,6 +2539,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform1i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform1i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform1i(location:%d x:%d )", stream, var_location, var_x);
this->glUniform1i(var_location, var_x);
SET_LASTCALL("glUniform1i");
android::base::endTrace();
@@ -1987,6 +2559,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform1iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform1iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform1iv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLint*)(inptr_v.get()), size_v);
this->glUniform1iv(var_location, var_count, (const GLint*)(inptr_v.get()));
SET_LASTCALL("glUniform1iv");
android::base::endTrace();
@@ -2001,6 +2578,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform2f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform2f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform2f(location:%d x:%f y:%f )", stream, var_location, var_x, var_y);
this->glUniform2f(var_location, var_x, var_y);
SET_LASTCALL("glUniform2f");
android::base::endTrace();
@@ -2016,6 +2598,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform2fv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLfloat*)(inptr_v.get()), size_v);
this->glUniform2fv(var_location, var_count, (const GLfloat*)(inptr_v.get()));
SET_LASTCALL("glUniform2fv");
android::base::endTrace();
@@ -2030,6 +2617,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform2i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform2i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform2i(location:%d x:%d y:%d )", stream, var_location, var_x, var_y);
this->glUniform2i(var_location, var_x, var_y);
SET_LASTCALL("glUniform2i");
android::base::endTrace();
@@ -2045,6 +2637,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform2iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform2iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform2iv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLint*)(inptr_v.get()), size_v);
this->glUniform2iv(var_location, var_count, (const GLint*)(inptr_v.get()));
SET_LASTCALL("glUniform2iv");
android::base::endTrace();
@@ -2060,6 +2657,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform3f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform3f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform3f(location:%d x:%f y:%f z:%f )", stream, var_location, var_x, var_y, var_z);
this->glUniform3f(var_location, var_x, var_y, var_z);
SET_LASTCALL("glUniform3f");
android::base::endTrace();
@@ -2075,6 +2677,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform3fv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLfloat*)(inptr_v.get()), size_v);
this->glUniform3fv(var_location, var_count, (const GLfloat*)(inptr_v.get()));
SET_LASTCALL("glUniform3fv");
android::base::endTrace();
@@ -2090,6 +2697,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform3i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform3i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform3i(location:%d x:%d y:%d z:%d )", stream, var_location, var_x, var_y, var_z);
this->glUniform3i(var_location, var_x, var_y, var_z);
SET_LASTCALL("glUniform3i");
android::base::endTrace();
@@ -2105,6 +2717,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform3iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform3iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform3iv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLint*)(inptr_v.get()), size_v);
this->glUniform3iv(var_location, var_count, (const GLint*)(inptr_v.get()));
SET_LASTCALL("glUniform3iv");
android::base::endTrace();
@@ -2121,6 +2738,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform4f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform4f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform4f(location:%d x:%f y:%f z:%f w:%f )", stream, var_location, var_x, var_y, var_z, var_w);
this->glUniform4f(var_location, var_x, var_y, var_z, var_w);
SET_LASTCALL("glUniform4f");
android::base::endTrace();
@@ -2136,6 +2758,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform4fv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLfloat*)(inptr_v.get()), size_v);
this->glUniform4fv(var_location, var_count, (const GLfloat*)(inptr_v.get()));
SET_LASTCALL("glUniform4fv");
android::base::endTrace();
@@ -2152,6 +2779,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform4i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform4i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform4i(location:%d x:%d y:%d z:%d w:%d )", stream, var_location, var_x, var_y, var_z, var_w);
this->glUniform4i(var_location, var_x, var_y, var_z, var_w);
SET_LASTCALL("glUniform4i");
android::base::endTrace();
@@ -2167,6 +2799,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform4iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform4iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform4iv(location:%d count:%d v:%p(%u) )", stream, var_location, var_count, (const GLint*)(inptr_v.get()), size_v);
this->glUniform4iv(var_location, var_count, (const GLint*)(inptr_v.get()));
SET_LASTCALL("glUniform4iv");
android::base::endTrace();
@@ -2183,6 +2820,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix2fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix2fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix2fv");
android::base::endTrace();
@@ -2199,6 +2841,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix3fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix3fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix3fv");
android::base::endTrace();
@@ -2215,6 +2862,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix4fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix4fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix4fv");
android::base::endTrace();
@@ -2227,6 +2879,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUseProgram: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUseProgram\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUseProgram(program:%u )", stream, var_program);
this->glUseProgram_dec(this, var_program);
SET_LASTCALL("glUseProgram");
android::base::endTrace();
@@ -2239,6 +2896,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glValidateProgram: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glValidateProgram\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glValidateProgram(program:%u )", stream, var_program);
this->glValidateProgram_dec(this, var_program);
SET_LASTCALL("glValidateProgram");
android::base::endTrace();
@@ -2252,6 +2914,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib1f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib1f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib1f(indx:%u x:%f )", stream, var_indx, var_x);
this->glVertexAttrib1f(var_indx, var_x);
SET_LASTCALL("glVertexAttrib1f");
android::base::endTrace();
@@ -2266,6 +2933,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_values, ptr + 8 + 4 + 4 + size_values, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib1fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib1fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib1fv(indx:%u values:%p(%u) )", stream, var_indx, (const GLfloat*)(inptr_values.get()), size_values);
this->glVertexAttrib1fv(var_indx, (const GLfloat*)(inptr_values.get()));
SET_LASTCALL("glVertexAttrib1fv");
android::base::endTrace();
@@ -2280,6 +2952,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib2f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib2f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib2f(indx:%u x:%f y:%f )", stream, var_indx, var_x, var_y);
this->glVertexAttrib2f(var_indx, var_x, var_y);
SET_LASTCALL("glVertexAttrib2f");
android::base::endTrace();
@@ -2294,6 +2971,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_values, ptr + 8 + 4 + 4 + size_values, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib2fv(indx:%u values:%p(%u) )", stream, var_indx, (const GLfloat*)(inptr_values.get()), size_values);
this->glVertexAttrib2fv(var_indx, (const GLfloat*)(inptr_values.get()));
SET_LASTCALL("glVertexAttrib2fv");
android::base::endTrace();
@@ -2309,6 +2991,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib3f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib3f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib3f(indx:%u x:%f y:%f z:%f )", stream, var_indx, var_x, var_y, var_z);
this->glVertexAttrib3f(var_indx, var_x, var_y, var_z);
SET_LASTCALL("glVertexAttrib3f");
android::base::endTrace();
@@ -2323,6 +3010,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_values, ptr + 8 + 4 + 4 + size_values, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib3fv(indx:%u values:%p(%u) )", stream, var_indx, (const GLfloat*)(inptr_values.get()), size_values);
this->glVertexAttrib3fv(var_indx, (const GLfloat*)(inptr_values.get()));
SET_LASTCALL("glVertexAttrib3fv");
android::base::endTrace();
@@ -2339,6 +3031,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib4f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib4f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib4f(indx:%u x:%f y:%f z:%f w:%f )", stream, var_indx, var_x, var_y, var_z, var_w);
this->glVertexAttrib4f(var_indx, var_x, var_y, var_z, var_w);
SET_LASTCALL("glVertexAttrib4f");
android::base::endTrace();
@@ -2353,6 +3050,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_values, ptr + 8 + 4 + 4 + size_values, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttrib4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttrib4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttrib4fv(indx:%u values:%p(%u) )", stream, var_indx, (const GLfloat*)(inptr_values.get()), size_values);
this->glVertexAttrib4fv(var_indx, (const GLfloat*)(inptr_values.get()));
SET_LASTCALL("glVertexAttrib4fv");
android::base::endTrace();
@@ -2371,6 +3073,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + 4 + size_ptr, ptr + 8 + 4 + 4 + 4 + 1 + 4 + 4 + size_ptr, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribPointer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribPointer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribPointer(indx:%u size:%d type:0x%08x normalized:%d stride:%d ptr:%p(%u) )", stream, var_indx, var_size, var_type, var_normalized, var_stride, (const GLvoid*)(inptr_ptr.get()), size_ptr);
this->glVertexAttribPointer(var_indx, var_size, var_type, var_normalized, var_stride, (const GLvoid*)(inptr_ptr.get()));
SET_LASTCALL("glVertexAttribPointer");
android::base::endTrace();
@@ -2386,6 +3093,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glViewport: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glViewport\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glViewport(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
this->glViewport(var_x, var_y, var_width, var_height);
SET_LASTCALL("glViewport");
android::base::endTrace();
@@ -2399,6 +3111,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEGLImageTargetTexture2DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEGLImageTargetTexture2DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEGLImageTargetTexture2DOES(target:0x%08x image:%p )", stream, var_target, var_image);
this->glEGLImageTargetTexture2DOES(var_target, var_image);
SET_LASTCALL("glEGLImageTargetTexture2DOES");
android::base::endTrace();
@@ -2412,6 +3129,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEGLImageTargetRenderbufferStorageOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEGLImageTargetRenderbufferStorageOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEGLImageTargetRenderbufferStorageOES(target:0x%08x image:%p )", stream, var_target, var_image);
this->glEGLImageTargetRenderbufferStorageOES(var_target, var_image);
SET_LASTCALL("glEGLImageTargetRenderbufferStorageOES");
android::base::endTrace();
@@ -2431,6 +3153,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_length + 4 + size_binaryFormat + 4 + size_binary, ptr + 8 + 4 + 4 + 4 + size_length + 4 + size_binaryFormat + 4 + size_binary, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetProgramBinaryOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramBinaryOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramBinaryOES(program:%u bufSize:%d length:%p(%u) binaryFormat:%p(%u) binary:%p(%u) )", stream, var_program, var_bufSize, (GLsizei*)(inptr_length.get()), size_length, (GLenum*)(inptr_binaryFormat.get()), size_binaryFormat, (GLvoid*)(inptr_binary.get()), size_binary);
this->glGetProgramBinaryOES_dec(this, var_program, var_bufSize, (GLsizei*)(inptr_length.get()), (GLenum*)(inptr_binaryFormat.get()), (GLvoid*)(inptr_binary.get()));
SET_LASTCALL("glGetProgramBinaryOES");
android::base::endTrace();
@@ -2447,6 +3174,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_binary + 4, ptr + 8 + 4 + 4 + 4 + size_binary + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramBinaryOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramBinaryOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramBinaryOES(program:%u binaryFormat:0x%08x binary:%p(%u) length:%d )", stream, var_program, var_binaryFormat, (const GLvoid*)(inptr_binary.get()), size_binary, var_length);
this->glProgramBinaryOES_dec(this, var_program, var_binaryFormat, (const GLvoid*)(inptr_binary.get()), var_length);
SET_LASTCALL("glProgramBinaryOES");
android::base::endTrace();
@@ -2460,6 +3192,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glMapBufferOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMapBufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMapBufferOES(target:0x%08x access:0x%08x )", stream, var_target, var_access);
this->glMapBufferOES(var_target, var_access);
SET_LASTCALL("glMapBufferOES");
android::base::endTrace();
@@ -2475,6 +3212,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUnmapBufferOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUnmapBufferOES(target:0x%08x )", stream, var_target);
*(GLboolean *)(&tmpBuf[0]) = this->glUnmapBufferOES(var_target);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -2501,6 +3243,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexImage3DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexImage3DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexImage3DOES(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d depth:%d border:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
this->glTexImage3DOES(var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
SET_LASTCALL("glTexImage3DOES");
android::base::endTrace();
@@ -2524,6 +3271,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexSubImage3DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexSubImage3DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexSubImage3DOES(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
this->glTexSubImage3DOES(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
SET_LASTCALL("glTexSubImage3DOES");
android::base::endTrace();
@@ -2544,6 +3296,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCopyTexSubImage3DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCopyTexSubImage3DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCopyTexSubImage3DOES(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d x:%d y:%d width:%d height:%d )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_x, var_y, var_width, var_height);
this->glCopyTexSubImage3DOES(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_x, var_y, var_width, var_height);
SET_LASTCALL("glCopyTexSubImage3DOES");
android::base::endTrace();
@@ -2565,6 +3322,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexImage3DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexImage3DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexImage3DOES(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d depth:%d border:%d imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexImage3DOES(var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexImage3DOES");
android::base::endTrace();
@@ -2588,6 +3350,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexSubImage3DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexSubImage3DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexSubImage3DOES(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexSubImage3DOES(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexSubImage3DOES");
android::base::endTrace();
@@ -2605,6 +3372,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFramebufferTexture3DOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFramebufferTexture3DOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFramebufferTexture3DOES(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d zoffset:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level, var_zoffset);
this->glFramebufferTexture3DOES(var_target, var_attachment, var_textarget, var_texture, var_level, var_zoffset);
SET_LASTCALL("glFramebufferTexture3DOES");
android::base::endTrace();
@@ -2617,6 +3389,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindVertexArrayOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindVertexArrayOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindVertexArrayOES(array:%u )", stream, var_array);
this->glBindVertexArrayOES(var_array);
SET_LASTCALL("glBindVertexArrayOES");
android::base::endTrace();
@@ -2631,6 +3408,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_arrays, ptr + 8 + 4 + 4 + size_arrays, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteVertexArraysOES: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteVertexArraysOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (const GLuint*)(inptr_arrays.get()), size_arrays);
this->glDeleteVertexArraysOES_dec(this, var_n, (const GLuint*)(inptr_arrays.get()));
SET_LASTCALL("glDeleteVertexArraysOES");
android::base::endTrace();
@@ -2648,6 +3430,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_arrays(&tmpBuf[0], size_arrays);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenVertexArraysOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (GLuint*)(outptr_arrays.get()), size_arrays);
this->glGenVertexArraysOES_dec(this, var_n, (GLuint*)(outptr_arrays.get()));
outptr_arrays.flush();
if (useChecksum) {
@@ -2668,6 +3455,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsVertexArrayOES\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsVertexArrayOES(array:%u )", stream, var_array);
*(GLboolean *)(&tmpBuf[0]) = this->glIsVertexArrayOES(var_array);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -2687,6 +3479,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_attachments, ptr + 8 + 4 + 4 + 4 + size_attachments, checksumSize,
"gles2_decoder_context_t::decode, OP_glDiscardFramebufferEXT: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDiscardFramebufferEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDiscardFramebufferEXT(target:0x%08x numAttachments:%d attachments:%p(%u) )", stream, var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()), size_attachments);
this->glDiscardFramebufferEXT(var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()));
SET_LASTCALL("glDiscardFramebufferEXT");
android::base::endTrace();
@@ -2704,6 +3501,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_first + 4 + size_count + 4, ptr + 8 + 4 + 4 + size_first + 4 + size_count + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glMultiDrawArraysEXT: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMultiDrawArraysEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMultiDrawArraysEXT(mode:0x%08x first:%p(%u) count:%p(%u) primcount:%d )", stream, var_mode, (const GLint*)(inptr_first.get()), size_first, (const GLsizei*)(inptr_count.get()), size_count, var_primcount);
this->glMultiDrawArraysEXT(var_mode, (const GLint*)(inptr_first.get()), (const GLsizei*)(inptr_count.get()), var_primcount);
SET_LASTCALL("glMultiDrawArraysEXT");
android::base::endTrace();
@@ -2722,6 +3524,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glMultiDrawElementsEXT: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMultiDrawElementsEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMultiDrawElementsEXT(mode:0x%08x count:%p(%u) type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, (const GLsizei*)(inptr_count.get()), size_count, var_type, (const GLvoid* const*)(inptr_indices.get()), size_indices, var_primcount);
this->glMultiDrawElementsEXT(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid* const*)(inptr_indices.get()), var_primcount);
SET_LASTCALL("glMultiDrawElementsEXT");
android::base::endTrace();
@@ -2738,6 +3545,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_numGroups + 4 + 4 + size_groups, ptr + 8 + 4 + size_numGroups + 4 + 4 + size_groups, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetPerfMonitorGroupsAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetPerfMonitorGroupsAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetPerfMonitorGroupsAMD(numGroups:%p(%u) groupsSize:%d groups:%p(%u) )", stream, (GLint*)(inptr_numGroups.get()), size_numGroups, var_groupsSize, (GLuint*)(inptr_groups.get()), size_groups);
this->glGetPerfMonitorGroupsAMD((GLint*)(inptr_numGroups.get()), var_groupsSize, (GLuint*)(inptr_groups.get()));
SET_LASTCALL("glGetPerfMonitorGroupsAMD");
android::base::endTrace();
@@ -2757,6 +3569,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_numCounters + 4 + size_maxActiveCounters + 4 + 4 + size_counters, ptr + 8 + 4 + 4 + size_numCounters + 4 + size_maxActiveCounters + 4 + 4 + size_counters, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetPerfMonitorCountersAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetPerfMonitorCountersAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetPerfMonitorCountersAMD(group:%u numCounters:%p(%u) maxActiveCounters:%p(%u) counterSize:%d counters:%p(%u) )", stream, var_group, (GLint*)(inptr_numCounters.get()), size_numCounters, (GLint*)(inptr_maxActiveCounters.get()), size_maxActiveCounters, var_counterSize, (GLuint*)(inptr_counters.get()), size_counters);
this->glGetPerfMonitorCountersAMD(var_group, (GLint*)(inptr_numCounters.get()), (GLint*)(inptr_maxActiveCounters.get()), var_counterSize, (GLuint*)(inptr_counters.get()));
SET_LASTCALL("glGetPerfMonitorCountersAMD");
android::base::endTrace();
@@ -2774,6 +3591,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_length + 4 + size_groupString, ptr + 8 + 4 + 4 + 4 + size_length + 4 + size_groupString, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetPerfMonitorGroupStringAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetPerfMonitorGroupStringAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetPerfMonitorGroupStringAMD(group:%u bufSize:%d length:%p(%u) groupString:%p(%u) )", stream, var_group, var_bufSize, (GLsizei*)(inptr_length.get()), size_length, (GLchar*)(inptr_groupString.get()), size_groupString);
this->glGetPerfMonitorGroupStringAMD(var_group, var_bufSize, (GLsizei*)(inptr_length.get()), (GLchar*)(inptr_groupString.get()));
SET_LASTCALL("glGetPerfMonitorGroupStringAMD");
android::base::endTrace();
@@ -2792,6 +3614,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_length + 4 + size_counterString, ptr + 8 + 4 + 4 + 4 + 4 + size_length + 4 + size_counterString, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetPerfMonitorCounterStringAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetPerfMonitorCounterStringAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetPerfMonitorCounterStringAMD(group:%u counter:%u bufSize:%d length:%p(%u) counterString:%p(%u) )", stream, var_group, var_counter, var_bufSize, (GLsizei*)(inptr_length.get()), size_length, (GLchar*)(inptr_counterString.get()), size_counterString);
this->glGetPerfMonitorCounterStringAMD(var_group, var_counter, var_bufSize, (GLsizei*)(inptr_length.get()), (GLchar*)(inptr_counterString.get()));
SET_LASTCALL("glGetPerfMonitorCounterStringAMD");
android::base::endTrace();
@@ -2808,6 +3635,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetPerfMonitorCounterInfoAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetPerfMonitorCounterInfoAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetPerfMonitorCounterInfoAMD(group:%u counter:%u pname:0x%08x data:%p(%u) )", stream, var_group, var_counter, var_pname, (GLvoid*)(inptr_data.get()), size_data);
this->glGetPerfMonitorCounterInfoAMD(var_group, var_counter, var_pname, (GLvoid*)(inptr_data.get()));
SET_LASTCALL("glGetPerfMonitorCounterInfoAMD");
android::base::endTrace();
@@ -2822,6 +3654,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_monitors, ptr + 8 + 4 + 4 + size_monitors, checksumSize,
"gles2_decoder_context_t::decode, OP_glGenPerfMonitorsAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenPerfMonitorsAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenPerfMonitorsAMD(n:%d monitors:%p(%u) )", stream, var_n, (GLuint*)(inptr_monitors.get()), size_monitors);
this->glGenPerfMonitorsAMD(var_n, (GLuint*)(inptr_monitors.get()));
SET_LASTCALL("glGenPerfMonitorsAMD");
android::base::endTrace();
@@ -2836,6 +3673,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_monitors, ptr + 8 + 4 + 4 + size_monitors, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeletePerfMonitorsAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeletePerfMonitorsAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeletePerfMonitorsAMD(n:%d monitors:%p(%u) )", stream, var_n, (GLuint*)(inptr_monitors.get()), size_monitors);
this->glDeletePerfMonitorsAMD(var_n, (GLuint*)(inptr_monitors.get()));
SET_LASTCALL("glDeletePerfMonitorsAMD");
android::base::endTrace();
@@ -2853,6 +3695,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1 + 4 + 4 + 4 + size_countersList, ptr + 8 + 4 + 1 + 4 + 4 + 4 + size_countersList, checksumSize,
"gles2_decoder_context_t::decode, OP_glSelectPerfMonitorCountersAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSelectPerfMonitorCountersAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSelectPerfMonitorCountersAMD(monitor:%u enable:%d group:%u numCounters:%d countersList:%p(%u) )", stream, var_monitor, var_enable, var_group, var_numCounters, (GLuint*)(inptr_countersList.get()), size_countersList);
this->glSelectPerfMonitorCountersAMD(var_monitor, var_enable, var_group, var_numCounters, (GLuint*)(inptr_countersList.get()));
SET_LASTCALL("glSelectPerfMonitorCountersAMD");
android::base::endTrace();
@@ -2865,6 +3712,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBeginPerfMonitorAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBeginPerfMonitorAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBeginPerfMonitorAMD(monitor:%u )", stream, var_monitor);
this->glBeginPerfMonitorAMD(var_monitor);
SET_LASTCALL("glBeginPerfMonitorAMD");
android::base::endTrace();
@@ -2877,6 +3729,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEndPerfMonitorAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEndPerfMonitorAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEndPerfMonitorAMD(monitor:%u )", stream, var_monitor);
this->glEndPerfMonitorAMD(var_monitor);
SET_LASTCALL("glEndPerfMonitorAMD");
android::base::endTrace();
@@ -2895,6 +3752,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4 + size_bytesWritten, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4 + size_bytesWritten, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetPerfMonitorCounterDataAMD: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetPerfMonitorCounterDataAMD\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetPerfMonitorCounterDataAMD(monitor:%u pname:0x%08x dataSize:%d data:%p(%u) bytesWritten:%p(%u) )", stream, var_monitor, var_pname, var_dataSize, (GLuint*)(inptr_data.get()), size_data, (GLint*)(inptr_bytesWritten.get()), size_bytesWritten);
this->glGetPerfMonitorCounterDataAMD(var_monitor, var_pname, var_dataSize, (GLuint*)(inptr_data.get()), (GLint*)(inptr_bytesWritten.get()));
SET_LASTCALL("glGetPerfMonitorCounterDataAMD");
android::base::endTrace();
@@ -2911,6 +3773,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glRenderbufferStorageMultisampleIMG: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glRenderbufferStorageMultisampleIMG\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glRenderbufferStorageMultisampleIMG(target:0x%08x samples:%d internalformat:0x%08x width:%d height:%d )", stream, var_target, var_samples, var_internalformat, var_width, var_height);
this->glRenderbufferStorageMultisampleIMG(var_target, var_samples, var_internalformat, var_width, var_height);
SET_LASTCALL("glRenderbufferStorageMultisampleIMG");
android::base::endTrace();
@@ -2928,6 +3795,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFramebufferTexture2DMultisampleIMG: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFramebufferTexture2DMultisampleIMG\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFramebufferTexture2DMultisampleIMG(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d samples:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
this->glFramebufferTexture2DMultisampleIMG(var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
SET_LASTCALL("glFramebufferTexture2DMultisampleIMG");
android::base::endTrace();
@@ -2942,6 +3814,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteFencesNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteFencesNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteFencesNV(n:%d fences:%p(%u) )", stream, var_n, (const GLuint*)(inptr_fences.get()), size_fences);
this->glDeleteFencesNV(var_n, (const GLuint*)(inptr_fences.get()));
SET_LASTCALL("glDeleteFencesNV");
android::base::endTrace();
@@ -2956,6 +3833,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
"gles2_decoder_context_t::decode, OP_glGenFencesNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenFencesNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenFencesNV(n:%d fences:%p(%u) )", stream, var_n, (GLuint*)(inptr_fences.get()), size_fences);
this->glGenFencesNV(var_n, (GLuint*)(inptr_fences.get()));
SET_LASTCALL("glGenFencesNV");
android::base::endTrace();
@@ -2971,6 +3853,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsFenceNV(fence:%u )", stream, var_fence);
*(GLboolean *)(&tmpBuf[0]) = this->glIsFenceNV(var_fence);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -2990,6 +3877,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTestFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTestFenceNV(fence:%u )", stream, var_fence);
*(GLboolean *)(&tmpBuf[0]) = this->glTestFenceNV(var_fence);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3009,6 +3901,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetFenceivNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetFenceivNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetFenceivNV(fence:%u pname:0x%08x params:%p(%u) )", stream, var_fence, var_pname, (GLint*)(inptr_params.get()), size_params);
this->glGetFenceivNV(var_fence, var_pname, (GLint*)(inptr_params.get()));
SET_LASTCALL("glGetFenceivNV");
android::base::endTrace();
@@ -3021,6 +3918,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFinishFenceNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFinishFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFinishFenceNV(fence:%u )", stream, var_fence);
this->glFinishFenceNV(var_fence);
SET_LASTCALL("glFinishFenceNV");
android::base::endTrace();
@@ -3034,6 +3936,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glSetFenceNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSetFenceNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSetFenceNV(fence:%u condition:0x%08x )", stream, var_fence, var_condition);
this->glSetFenceNV(var_fence, var_condition);
SET_LASTCALL("glSetFenceNV");
android::base::endTrace();
@@ -3046,6 +3953,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1, ptr + 8 + 1, checksumSize,
"gles2_decoder_context_t::decode, OP_glCoverageMaskNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCoverageMaskNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCoverageMaskNV(mask:%d )", stream, var_mask);
this->glCoverageMaskNV(var_mask);
SET_LASTCALL("glCoverageMaskNV");
android::base::endTrace();
@@ -3058,6 +3970,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCoverageOperationNV: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCoverageOperationNV\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCoverageOperationNV(operation:0x%08x )", stream, var_operation);
this->glCoverageOperationNV(var_operation);
SET_LASTCALL("glCoverageOperationNV");
android::base::endTrace();
@@ -3074,6 +3991,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_num + 4 + 4 + size_driverControls, ptr + 8 + 4 + size_num + 4 + 4 + size_driverControls, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetDriverControlsQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetDriverControlsQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetDriverControlsQCOM(num:%p(%u) size:%d driverControls:%p(%u) )", stream, (GLint*)(inptr_num.get()), size_num, var_size, (GLuint*)(inptr_driverControls.get()), size_driverControls);
this->glGetDriverControlsQCOM((GLint*)(inptr_num.get()), var_size, (GLuint*)(inptr_driverControls.get()));
SET_LASTCALL("glGetDriverControlsQCOM");
android::base::endTrace();
@@ -3091,6 +4013,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_length + 4 + size_driverControlString, ptr + 8 + 4 + 4 + 4 + size_length + 4 + size_driverControlString, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetDriverControlStringQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetDriverControlStringQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetDriverControlStringQCOM(driverControl:%u bufSize:%d length:%p(%u) driverControlString:%p(%u) )", stream, var_driverControl, var_bufSize, (GLsizei*)(inptr_length.get()), size_length, (GLchar*)(inptr_driverControlString.get()), size_driverControlString);
this->glGetDriverControlStringQCOM(var_driverControl, var_bufSize, (GLsizei*)(inptr_length.get()), (GLchar*)(inptr_driverControlString.get()));
SET_LASTCALL("glGetDriverControlStringQCOM");
android::base::endTrace();
@@ -3103,6 +4030,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEnableDriverControlQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEnableDriverControlQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEnableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
this->glEnableDriverControlQCOM(var_driverControl);
SET_LASTCALL("glEnableDriverControlQCOM");
android::base::endTrace();
@@ -3115,6 +4047,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDisableDriverControlQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDisableDriverControlQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDisableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
this->glDisableDriverControlQCOM(var_driverControl);
SET_LASTCALL("glDisableDriverControlQCOM");
android::base::endTrace();
@@ -3131,6 +4068,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_textures + 4 + 4 + size_numTextures, ptr + 8 + 4 + size_textures + 4 + 4 + size_numTextures, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetTexturesQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetTexturesQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetTexturesQCOM(textures:%p(%u) maxTextures:%d numTextures:%p(%u) )", stream, (GLuint*)(inptr_textures.get()), size_textures, var_maxTextures, (GLint*)(inptr_numTextures.get()), size_numTextures);
this->glExtGetTexturesQCOM((GLuint*)(inptr_textures.get()), var_maxTextures, (GLint*)(inptr_numTextures.get()));
SET_LASTCALL("glExtGetTexturesQCOM");
android::base::endTrace();
@@ -3147,6 +4089,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_buffers + 4 + 4 + size_numBuffers, ptr + 8 + 4 + size_buffers + 4 + 4 + size_numBuffers, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetBuffersQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetBuffersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetBuffersQCOM(buffers:%p(%u) maxBuffers:%d numBuffers:%p(%u) )", stream, (GLuint*)(inptr_buffers.get()), size_buffers, var_maxBuffers, (GLint*)(inptr_numBuffers.get()), size_numBuffers);
this->glExtGetBuffersQCOM((GLuint*)(inptr_buffers.get()), var_maxBuffers, (GLint*)(inptr_numBuffers.get()));
SET_LASTCALL("glExtGetBuffersQCOM");
android::base::endTrace();
@@ -3163,6 +4110,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_renderbuffers + 4 + 4 + size_numRenderbuffers, ptr + 8 + 4 + size_renderbuffers + 4 + 4 + size_numRenderbuffers, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetRenderbuffersQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetRenderbuffersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetRenderbuffersQCOM(renderbuffers:%p(%u) maxRenderbuffers:%d numRenderbuffers:%p(%u) )", stream, (GLuint*)(inptr_renderbuffers.get()), size_renderbuffers, var_maxRenderbuffers, (GLint*)(inptr_numRenderbuffers.get()), size_numRenderbuffers);
this->glExtGetRenderbuffersQCOM((GLuint*)(inptr_renderbuffers.get()), var_maxRenderbuffers, (GLint*)(inptr_numRenderbuffers.get()));
SET_LASTCALL("glExtGetRenderbuffersQCOM");
android::base::endTrace();
@@ -3179,6 +4131,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_framebuffers + 4 + 4 + size_numFramebuffers, ptr + 8 + 4 + size_framebuffers + 4 + 4 + size_numFramebuffers, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetFramebuffersQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetFramebuffersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetFramebuffersQCOM(framebuffers:%p(%u) maxFramebuffers:%d numFramebuffers:%p(%u) )", stream, (GLuint*)(inptr_framebuffers.get()), size_framebuffers, var_maxFramebuffers, (GLint*)(inptr_numFramebuffers.get()), size_numFramebuffers);
this->glExtGetFramebuffersQCOM((GLuint*)(inptr_framebuffers.get()), var_maxFramebuffers, (GLint*)(inptr_numFramebuffers.get()));
SET_LASTCALL("glExtGetFramebuffersQCOM");
android::base::endTrace();
@@ -3196,6 +4153,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetTexLevelParameterivQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetTexLevelParameterivQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetTexLevelParameterivQCOM(texture:%u face:0x%08x level:%d pname:0x%08x params:%p(%u) )", stream, var_texture, var_face, var_level, var_pname, (GLint*)(inptr_params.get()), size_params);
this->glExtGetTexLevelParameterivQCOM(var_texture, var_face, var_level, var_pname, (GLint*)(inptr_params.get()));
SET_LASTCALL("glExtGetTexLevelParameterivQCOM");
android::base::endTrace();
@@ -3210,6 +4172,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtTexObjectStateOverrideiQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtTexObjectStateOverrideiQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtTexObjectStateOverrideiQCOM(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
this->glExtTexObjectStateOverrideiQCOM(var_target, var_pname, var_param);
SET_LASTCALL("glExtTexObjectStateOverrideiQCOM");
android::base::endTrace();
@@ -3233,6 +4200,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_texels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_texels, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetTexSubImageQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetTexSubImageQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetTexSubImageQCOM(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x type:0x%08x texels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (GLvoid*)(inptr_texels.get()), size_texels);
this->glExtGetTexSubImageQCOM(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (GLvoid*)(inptr_texels.get()));
SET_LASTCALL("glExtGetTexSubImageQCOM");
android::base::endTrace();
@@ -3247,6 +4219,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetBufferPointervQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetBufferPointervQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetBufferPointervQCOM(target:0x%08x params:%p(%u) )", stream, var_target, (GLvoidptr*)(inptr_params.get()), size_params);
this->glExtGetBufferPointervQCOM(var_target, (GLvoidptr*)(inptr_params.get()));
SET_LASTCALL("glExtGetBufferPointervQCOM");
android::base::endTrace();
@@ -3263,6 +4240,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_shaders + 4 + 4 + size_numShaders, ptr + 8 + 4 + size_shaders + 4 + 4 + size_numShaders, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetShadersQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetShadersQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetShadersQCOM(shaders:%p(%u) maxShaders:%d numShaders:%p(%u) )", stream, (GLuint*)(inptr_shaders.get()), size_shaders, var_maxShaders, (GLint*)(inptr_numShaders.get()), size_numShaders);
this->glExtGetShadersQCOM((GLuint*)(inptr_shaders.get()), var_maxShaders, (GLint*)(inptr_numShaders.get()));
SET_LASTCALL("glExtGetShadersQCOM");
android::base::endTrace();
@@ -3279,6 +4261,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_programs + 4 + 4 + size_numPrograms, ptr + 8 + 4 + size_programs + 4 + 4 + size_numPrograms, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetProgramsQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetProgramsQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetProgramsQCOM(programs:%p(%u) maxPrograms:%d numPrograms:%p(%u) )", stream, (GLuint*)(inptr_programs.get()), size_programs, var_maxPrograms, (GLint*)(inptr_numPrograms.get()), size_numPrograms);
this->glExtGetProgramsQCOM((GLuint*)(inptr_programs.get()), var_maxPrograms, (GLint*)(inptr_numPrograms.get()));
SET_LASTCALL("glExtGetProgramsQCOM");
android::base::endTrace();
@@ -3294,6 +4281,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtIsProgramBinaryQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtIsProgramBinaryQCOM(program:%u )", stream, var_program);
*(GLboolean *)(&tmpBuf[0]) = this->glExtIsProgramBinaryQCOM(var_program);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3315,6 +4307,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_source + 4 + size_length, ptr + 8 + 4 + 4 + 4 + size_source + 4 + size_length, checksumSize,
"gles2_decoder_context_t::decode, OP_glExtGetProgramBinarySourceQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glExtGetProgramBinarySourceQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glExtGetProgramBinarySourceQCOM(program:%u shadertype:0x%08x source:%p(%u) length:%p(%u) )", stream, var_program, var_shadertype, (GLchar*)(inptr_source.get()), size_source, (GLint*)(inptr_length.get()), size_length);
this->glExtGetProgramBinarySourceQCOM(var_program, var_shadertype, (GLchar*)(inptr_source.get()), (GLint*)(inptr_length.get()));
SET_LASTCALL("glExtGetProgramBinarySourceQCOM");
android::base::endTrace();
@@ -3331,6 +4328,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glStartTilingQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glStartTilingQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glStartTilingQCOM(x:%u y:%u width:%u height:%u preserveMask:0x%08x )", stream, var_x, var_y, var_width, var_height, var_preserveMask);
this->glStartTilingQCOM(var_x, var_y, var_width, var_height, var_preserveMask);
SET_LASTCALL("glStartTilingQCOM");
android::base::endTrace();
@@ -3343,6 +4345,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEndTilingQCOM: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEndTilingQCOM\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEndTilingQCOM(preserveMask:0x%08x )", stream, var_preserveMask);
this->glEndTilingQCOM(var_preserveMask);
SET_LASTCALL("glEndTilingQCOM");
android::base::endTrace();
@@ -3362,6 +4369,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 1 + 4 + 4 + size_data + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribPointerData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribPointerData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribPointerData(indx:%u size:%d type:0x%08x normalized:%d stride:%d data:%p(%u) datalen:%u )", stream, var_indx, var_size, var_type, var_normalized, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glVertexAttribPointerData(this, var_indx, var_size, var_type, var_normalized, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glVertexAttribPointerData");
android::base::endTrace();
@@ -3379,6 +4391,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 1 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribPointerOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribPointerOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribPointerOffset(indx:%u size:%d type:0x%08x normalized:%d stride:%d offset:%u )", stream, var_indx, var_size, var_type, var_normalized, var_stride, var_offset);
this->glVertexAttribPointerOffset(this, var_indx, var_size, var_type, var_normalized, var_stride, var_offset);
SET_LASTCALL("glVertexAttribPointerOffset");
android::base::endTrace();
@@ -3394,6 +4411,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsOffset: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsOffset\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsOffset(mode:0x%08x count:%d type:0x%08x offset:%u )", stream, var_mode, var_count, var_type, var_offset);
this->glDrawElementsOffset(this, var_mode, var_count, var_type, var_offset);
SET_LASTCALL("glDrawElementsOffset");
android::base::endTrace();
@@ -3411,6 +4433,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsData(mode:0x%08x count:%d type:0x%08x data:%p(%u) datalen:%u )", stream, var_mode, var_count, var_type, (void*)(inptr_data.get()), size_data, var_datalen);
this->glDrawElementsData(this, var_mode, var_count, var_type, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glDrawElementsData");
android::base::endTrace();
@@ -3428,6 +4455,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_formats(&tmpBuf[0], size_formats);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetCompressedTextureFormats\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetCompressedTextureFormats(count:%d formats:%p(%u) )", stream, var_count, (GLint*)(outptr_formats.get()), size_formats);
this->glGetCompressedTextureFormats(this, var_count, (GLint*)(outptr_formats.get()));
outptr_formats.flush();
if (useChecksum) {
@@ -3448,6 +4480,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_string + 4, ptr + 8 + 4 + 4 + size_string + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glShaderString: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glShaderString\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glShaderString(shader:%u string:%p(%u) len:%d )", stream, var_shader, (const GLchar*)(inptr_string.get()), size_string, var_len);
this->glShaderString(this, var_shader, (const GLchar*)(inptr_string.get()), var_len);
SET_LASTCALL("glShaderString");
android::base::endTrace();
@@ -3462,6 +4499,11 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFinishRoundTrip\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFinishRoundTrip()", stream);
*(int *)(&tmpBuf[0]) = this->glFinishRoundTrip(this);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3483,6 +4525,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_arrays(&tmpBuf[0], size_arrays);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenVertexArrays\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenVertexArrays(n:%d arrays:%p(%u) )", stream, var_n, (GLuint*)(outptr_arrays.get()), size_arrays);
this->glGenVertexArrays_dec(this, var_n, (GLuint*)(outptr_arrays.get()));
outptr_arrays.flush();
if (useChecksum) {
@@ -3500,6 +4547,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindVertexArray: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindVertexArray\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindVertexArray(array:%u )", stream, var_array);
this->glBindVertexArray(var_array);
SET_LASTCALL("glBindVertexArray");
android::base::endTrace();
@@ -3514,6 +4566,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_arrays, ptr + 8 + 4 + 4 + size_arrays, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteVertexArrays: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteVertexArrays\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteVertexArrays(n:%d arrays:%p(%u) )", stream, var_n, (const GLuint*)(inptr_arrays.get()), size_arrays);
this->glDeleteVertexArrays_dec(this, var_n, (const GLuint*)(inptr_arrays.get()));
SET_LASTCALL("glDeleteVertexArrays");
android::base::endTrace();
@@ -3529,6 +4586,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsVertexArray\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsVertexArray(array:%u )", stream, var_array);
*(GLboolean *)(&tmpBuf[0]) = this->glIsVertexArray(var_array);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3548,6 +4610,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glMapBufferRange: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMapBufferRange\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMapBufferRange(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x )", stream, var_target, var_offset, var_length, var_access);
this->glMapBufferRange(var_target, var_offset, var_length, var_access);
SET_LASTCALL("glMapBufferRange");
android::base::endTrace();
@@ -3563,6 +4630,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUnmapBuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUnmapBuffer(target:0x%08x )", stream, var_target);
*(GLboolean *)(&tmpBuf[0]) = this->glUnmapBuffer(var_target);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3581,6 +4653,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFlushMappedBufferRange: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFlushMappedBufferRange\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFlushMappedBufferRange(target:0x%08x offset:0x%08lx length:0x%08lx )", stream, var_target, var_offset, var_length);
this->glFlushMappedBufferRange(var_target, var_offset, var_length);
SET_LASTCALL("glFlushMappedBufferRange");
android::base::endTrace();
@@ -3601,6 +4678,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_mapped(&tmpBuf[0], size_mapped);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMapBufferRangeAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMapBufferRangeAEMU(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x mapped:%p(%u) )", stream, var_target, var_offset, var_length, var_access, (void*)(outptr_mapped.get()), size_mapped);
this->glMapBufferRangeAEMU(this, var_target, var_offset, var_length, var_access, size_mapped == 0 ? nullptr : (void*)(outptr_mapped.get()));
outptr_mapped.flush();
if (useChecksum) {
@@ -3628,6 +4710,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_out_res(&tmpBuf[0], size_out_res);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUnmapBufferAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUnmapBufferAEMU(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x guest_buffer:%p(%u) out_res:%p(%u) )", stream, var_target, var_offset, var_length, var_access, (void*)(inptr_guest_buffer.get()), size_guest_buffer, (GLboolean*)(outptr_out_res.get()), size_out_res);
this->glUnmapBufferAEMU(this, var_target, var_offset, var_length, var_access, size_guest_buffer == 0 ? nullptr : (void*)(inptr_guest_buffer.get()), (GLboolean*)(outptr_out_res.get()));
outptr_out_res.flush();
if (useChecksum) {
@@ -3650,6 +4737,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_guest_buffer, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_guest_buffer, checksumSize,
"gles2_decoder_context_t::decode, OP_glFlushMappedBufferRangeAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFlushMappedBufferRangeAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFlushMappedBufferRangeAEMU(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x guest_buffer:%p(%u) )", stream, var_target, var_offset, var_length, var_access, (void*)(inptr_guest_buffer.get()), size_guest_buffer);
this->glFlushMappedBufferRangeAEMU(this, var_target, var_offset, var_length, var_access, size_guest_buffer == 0 ? nullptr : (void*)(inptr_guest_buffer.get()));
SET_LASTCALL("glFlushMappedBufferRangeAEMU");
android::base::endTrace();
@@ -3668,6 +4760,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glReadPixelsOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glReadPixelsOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glReadPixelsOffsetAEMU(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x offset:%u )", stream, var_x, var_y, var_width, var_height, var_format, var_type, var_offset);
this->glReadPixelsOffsetAEMU(this, var_x, var_y, var_width, var_height, var_format, var_type, var_offset);
SET_LASTCALL("glReadPixelsOffsetAEMU");
android::base::endTrace();
@@ -3687,6 +4784,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexImage2DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexImage2DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexImage2DOffsetAEMU(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d border:%d imageSize:%d offset:%u )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, var_offset);
this->glCompressedTexImage2DOffsetAEMU(this, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, var_offset);
SET_LASTCALL("glCompressedTexImage2DOffsetAEMU");
android::base::endTrace();
@@ -3707,6 +4809,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexSubImage2DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexSubImage2DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexSubImage2DOffsetAEMU(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x imageSize:%d offset:%u )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, var_offset);
this->glCompressedTexSubImage2DOffsetAEMU(this, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, var_offset);
SET_LASTCALL("glCompressedTexSubImage2DOffsetAEMU");
android::base::endTrace();
@@ -3727,6 +4834,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexImage2DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexImage2DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexImage2DOffsetAEMU(target:0x%08x level:%d internalformat:%d width:%d height:%d border:%d format:0x%08x type:0x%08x offset:%u )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, var_offset);
this->glTexImage2DOffsetAEMU(this, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, var_offset);
SET_LASTCALL("glTexImage2DOffsetAEMU");
android::base::endTrace();
@@ -3747,6 +4859,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexSubImage2DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexSubImage2DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexSubImage2DOffsetAEMU(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x type:0x%08x offset:%u )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, var_offset);
this->glTexSubImage2DOffsetAEMU(this, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, var_offset);
SET_LASTCALL("glTexSubImage2DOffsetAEMU");
android::base::endTrace();
@@ -3763,6 +4880,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindBufferRange: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindBufferRange\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindBufferRange(target:0x%08x index:%u buffer:%u offset:0x%08lx size:0x%08lx )", stream, var_target, var_index, var_buffer, var_offset, var_size);
this->glBindBufferRange(var_target, var_index, var_buffer, var_offset, var_size);
SET_LASTCALL("glBindBufferRange");
android::base::endTrace();
@@ -3777,6 +4899,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindBufferBase: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindBufferBase\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindBufferBase(target:0x%08x index:%u buffer:%u )", stream, var_target, var_index, var_buffer);
this->glBindBufferBase(var_target, var_index, var_buffer);
SET_LASTCALL("glBindBufferBase");
android::base::endTrace();
@@ -3793,6 +4920,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCopyBufferSubData: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCopyBufferSubData\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCopyBufferSubData(readtarget:0x%08x writetarget:0x%08x readoffset:0x%08lx writeoffset:0x%08lx size:0x%08lx )", stream, var_readtarget, var_writetarget, var_readoffset, var_writeoffset, var_size);
this->glCopyBufferSubData(var_readtarget, var_writetarget, var_readoffset, var_writeoffset, var_size);
SET_LASTCALL("glCopyBufferSubData");
android::base::endTrace();
@@ -3808,6 +4940,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glClearBufferiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClearBufferiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClearBufferiv(buffer:0x%08x drawBuffer:%d value:%p(%u) )", stream, var_buffer, var_drawBuffer, (const GLint*)(inptr_value.get()), size_value);
this->glClearBufferiv(var_buffer, var_drawBuffer, (const GLint*)(inptr_value.get()));
SET_LASTCALL("glClearBufferiv");
android::base::endTrace();
@@ -3823,6 +4960,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glClearBufferuiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClearBufferuiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClearBufferuiv(buffer:0x%08x drawBuffer:%d value:%p(%u) )", stream, var_buffer, var_drawBuffer, (const GLuint*)(inptr_value.get()), size_value);
this->glClearBufferuiv(var_buffer, var_drawBuffer, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glClearBufferuiv");
android::base::endTrace();
@@ -3838,6 +4980,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glClearBufferfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClearBufferfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClearBufferfv(buffer:0x%08x drawBuffer:%d value:%p(%u) )", stream, var_buffer, var_drawBuffer, (const GLfloat*)(inptr_value.get()), size_value);
this->glClearBufferfv(var_buffer, var_drawBuffer, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glClearBufferfv");
android::base::endTrace();
@@ -3853,6 +5000,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glClearBufferfi: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClearBufferfi\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClearBufferfi(buffer:0x%08x drawBuffer:%d depth:%f stencil:%d )", stream, var_buffer, var_drawBuffer, var_depth, var_stencil);
this->glClearBufferfi(var_buffer, var_drawBuffer, var_depth, var_stencil);
SET_LASTCALL("glClearBufferfi");
android::base::endTrace();
@@ -3868,6 +5020,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetBufferParameteri64v: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetBufferParameteri64v\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetBufferParameteri64v(target:0x%08x value:0x%08x data:%p(%u) )", stream, var_target, var_value, (GLint64*)(inptr_data.get()), size_data);
this->glGetBufferParameteri64v(var_target, var_value, (GLint64*)(inptr_data.get()));
SET_LASTCALL("glGetBufferParameteri64v");
android::base::endTrace();
@@ -3883,6 +5040,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetBufferPointerv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetBufferPointerv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetBufferPointerv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLvoid**)(inptr_params.get()), size_params);
this->glGetBufferPointerv(var_target, var_pname, (GLvoid**)(inptr_params.get()));
SET_LASTCALL("glGetBufferPointerv");
android::base::endTrace();
@@ -3897,6 +5059,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformBlockBinding: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformBlockBinding\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformBlockBinding(program:%u uniformBlockIndex:%u uniformBlockBinding:%u )", stream, var_program, var_uniformBlockIndex, var_uniformBlockBinding);
this->glUniformBlockBinding_dec(this, var_program, var_uniformBlockIndex, var_uniformBlockBinding);
SET_LASTCALL("glUniformBlockBinding");
android::base::endTrace();
@@ -3914,6 +5081,11 @@
size_t totalTmpSize = sizeof(GLuint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetUniformBlockIndex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetUniformBlockIndex(program:%u uniformBlockName:%p(%u) )", stream, var_program, (const GLchar*)(inptr_uniformBlockName.get()), size_uniformBlockName);
*(GLuint *)(&tmpBuf[0]) = this->glGetUniformBlockIndex_dec(this, var_program, (const GLchar*)(inptr_uniformBlockName.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -3935,6 +5107,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_uniformNames + 4 + size_uniformIndices, ptr + 8 + 4 + 4 + 4 + size_uniformNames + 4 + size_uniformIndices, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetUniformIndices: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetUniformIndices\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetUniformIndices(program:%u uniformCount:%d uniformNames:%p(%u) uniformIndices:%p(%u) )", stream, var_program, var_uniformCount, (const GLchar**)(inptr_uniformNames.get()), size_uniformNames, (GLuint*)(inptr_uniformIndices.get()), size_uniformIndices);
this->glGetUniformIndices(var_program, var_uniformCount, (const GLchar**)(inptr_uniformNames.get()), (GLuint*)(inptr_uniformIndices.get()));
SET_LASTCALL("glGetUniformIndices");
android::base::endTrace();
@@ -3956,6 +5133,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_uniformIndices(&tmpBuf[0], size_uniformIndices);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetUniformIndicesAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetUniformIndicesAEMU(program:%u uniformCount:%d packedUniformNames:%p(%u) packedLen:%d uniformIndices:%p(%u) )", stream, var_program, var_uniformCount, (const GLchar*)(inptr_packedUniformNames.get()), size_packedUniformNames, var_packedLen, (GLuint*)(outptr_uniformIndices.get()), size_uniformIndices);
this->glGetUniformIndicesAEMU(this, var_program, var_uniformCount, (const GLchar*)(inptr_packedUniformNames.get()), var_packedLen, (GLuint*)(outptr_uniformIndices.get()));
outptr_uniformIndices.flush();
if (useChecksum) {
@@ -3980,6 +5162,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetActiveUniformBlockiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetActiveUniformBlockiv(program:%u uniformBlockIndex:%u pname:0x%08x params:%p(%u) )", stream, var_program, var_uniformBlockIndex, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetActiveUniformBlockiv_dec(this, var_program, var_uniformBlockIndex, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4007,6 +5194,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_uniformBlockName(&tmpBuf[0 + size_length], size_uniformBlockName);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetActiveUniformBlockName\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetActiveUniformBlockName(program:%u uniformBlockIndex:%u bufSize:%d length:%p(%u) uniformBlockName:%p(%u) )", stream, var_program, var_uniformBlockIndex, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_uniformBlockName.get()), size_uniformBlockName);
this->glGetActiveUniformBlockName_dec(this, var_program, var_uniformBlockIndex, var_bufSize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), size_uniformBlockName == 0 ? nullptr : (GLchar*)(outptr_uniformBlockName.get()));
outptr_length.flush();
outptr_uniformBlockName.flush();
@@ -4026,6 +5218,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform1ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform1ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform1ui(location:%d v0:%u )", stream, var_location, var_v0);
this->glUniform1ui(var_location, var_v0);
SET_LASTCALL("glUniform1ui");
android::base::endTrace();
@@ -4040,6 +5237,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform2ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform2ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform2ui(location:%d v0:%u v1:%u )", stream, var_location, var_v0, var_v1);
this->glUniform2ui(var_location, var_v0, var_v1);
SET_LASTCALL("glUniform2ui");
android::base::endTrace();
@@ -4055,6 +5257,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform3ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform3ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform3ui(location:%d v0:%u v1:%u v2:%u )", stream, var_location, var_v0, var_v1, var_v2);
this->glUniform3ui(var_location, var_v0, var_v1, var_v2);
SET_LASTCALL("glUniform3ui");
android::base::endTrace();
@@ -4071,6 +5278,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform4ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform4ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform4ui(location:%d v0:%d v1:%u v2:%u v3:%u )", stream, var_location, var_v0, var_v1, var_v2, var_v3);
this->glUniform4ui(var_location, var_v0, var_v1, var_v2, var_v3);
SET_LASTCALL("glUniform4ui");
android::base::endTrace();
@@ -4086,6 +5298,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform1uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform1uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform1uiv(location:%d count:%d value:%p(%u) )", stream, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glUniform1uiv(var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glUniform1uiv");
android::base::endTrace();
@@ -4101,6 +5318,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform2uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform2uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform2uiv(location:%d count:%d value:%p(%u) )", stream, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glUniform2uiv(var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glUniform2uiv");
android::base::endTrace();
@@ -4116,6 +5338,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform3uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform3uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform3uiv(location:%d count:%d value:%p(%u) )", stream, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glUniform3uiv(var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glUniform3uiv");
android::base::endTrace();
@@ -4131,6 +5358,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniform4uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniform4uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniform4uiv(location:%d count:%d value:%p(%u) )", stream, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glUniform4uiv(var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glUniform4uiv");
android::base::endTrace();
@@ -4147,6 +5379,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix2x3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix2x3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix2x3fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix2x3fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix2x3fv");
android::base::endTrace();
@@ -4163,6 +5400,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix3x2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix3x2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix3x2fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix3x2fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix3x2fv");
android::base::endTrace();
@@ -4179,6 +5421,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix2x4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix2x4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix2x4fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix2x4fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix2x4fv");
android::base::endTrace();
@@ -4195,6 +5442,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix4x2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix4x2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix4x2fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix4x2fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix4x2fv");
android::base::endTrace();
@@ -4211,6 +5463,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix3x4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix3x4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix3x4fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix3x4fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix3x4fv");
android::base::endTrace();
@@ -4227,6 +5484,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glUniformMatrix4x3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUniformMatrix4x3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUniformMatrix4x3fv(location:%d count:%d transpose:%d value:%p(%u) )", stream, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glUniformMatrix4x3fv(var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glUniformMatrix4x3fv");
android::base::endTrace();
@@ -4245,6 +5507,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetUniformuiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetUniformuiv(program:%u location:%d params:%p(%u) )", stream, var_program, var_location, (GLuint*)(outptr_params.get()), size_params);
this->glGetUniformuiv_dec(this, var_program, var_location, (GLuint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4271,6 +5538,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetActiveUniformsiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetActiveUniformsiv(program:%u uniformCount:%d uniformIndices:%p(%u) pname:0x%08x params:%p(%u) )", stream, var_program, var_uniformCount, (const GLuint*)(inptr_uniformIndices.get()), size_uniformIndices, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetActiveUniformsiv_dec(this, var_program, var_uniformCount, (const GLuint*)(inptr_uniformIndices.get()), var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4292,6 +5564,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribI4i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribI4i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribI4i(index:%u v0:%d v1:%d v2:%d v3:%d )", stream, var_index, var_v0, var_v1, var_v2, var_v3);
this->glVertexAttribI4i(var_index, var_v0, var_v1, var_v2, var_v3);
SET_LASTCALL("glVertexAttribI4i");
android::base::endTrace();
@@ -4308,6 +5585,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribI4ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribI4ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribI4ui(index:%u v0:%u v1:%u v2:%u v3:%u )", stream, var_index, var_v0, var_v1, var_v2, var_v3);
this->glVertexAttribI4ui(var_index, var_v0, var_v1, var_v2, var_v3);
SET_LASTCALL("glVertexAttribI4ui");
android::base::endTrace();
@@ -4322,6 +5604,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribI4iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribI4iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribI4iv(index:%u v:%p(%u) )", stream, var_index, (const GLint*)(inptr_v.get()), size_v);
this->glVertexAttribI4iv(var_index, (const GLint*)(inptr_v.get()));
SET_LASTCALL("glVertexAttribI4iv");
android::base::endTrace();
@@ -4336,6 +5623,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_v, ptr + 8 + 4 + 4 + size_v, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribI4uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribI4uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribI4uiv(index:%u v:%p(%u) )", stream, var_index, (const GLuint*)(inptr_v.get()), size_v);
this->glVertexAttribI4uiv(var_index, (const GLuint*)(inptr_v.get()));
SET_LASTCALL("glVertexAttribI4uiv");
android::base::endTrace();
@@ -4353,6 +5645,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribIPointer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribIPointer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribIPointer(index:%u size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_index, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
this->glVertexAttribIPointer(var_index, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
SET_LASTCALL("glVertexAttribIPointer");
android::base::endTrace();
@@ -4369,6 +5666,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribIPointerOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribIPointerOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribIPointerOffsetAEMU(index:%u size:%d type:0x%08x stride:%d offset:%u )", stream, var_index, var_size, var_type, var_stride, var_offset);
this->glVertexAttribIPointerOffsetAEMU(this, var_index, var_size, var_type, var_stride, var_offset);
SET_LASTCALL("glVertexAttribIPointerOffsetAEMU");
android::base::endTrace();
@@ -4387,6 +5689,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribIPointerDataAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribIPointerDataAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribIPointerDataAEMU(index:%u size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_index, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
this->glVertexAttribIPointerDataAEMU(this, var_index, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glVertexAttribIPointerDataAEMU");
android::base::endTrace();
@@ -4405,6 +5712,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetVertexAttribIiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetVertexAttribIiv(index:%u pname:0x%08x params:%p(%u) )", stream, var_index, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetVertexAttribIiv(var_index, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4428,6 +5740,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetVertexAttribIuiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetVertexAttribIuiv(index:%u pname:0x%08x params:%p(%u) )", stream, var_index, var_pname, (GLuint*)(outptr_params.get()), size_params);
this->glGetVertexAttribIuiv(var_index, var_pname, (GLuint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4446,6 +5763,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribDivisor: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribDivisor\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribDivisor(index:%u divisor:%u )", stream, var_index, var_divisor);
this->glVertexAttribDivisor(var_index, var_divisor);
SET_LASTCALL("glVertexAttribDivisor");
android::base::endTrace();
@@ -4461,6 +5783,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawArraysInstanced: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawArraysInstanced\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawArraysInstanced(mode:0x%08x first:%d count:%d primcount:%d )", stream, var_mode, var_first, var_count, var_primcount);
this->glDrawArraysInstanced(var_mode, var_first, var_count, var_primcount);
SET_LASTCALL("glDrawArraysInstanced");
android::base::endTrace();
@@ -4478,6 +5805,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_indices + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_indices + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsInstanced: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsInstanced\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsInstanced(mode:0x%08x count:%d type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, var_count, var_type, (const void*)(inptr_indices.get()), size_indices, var_primcount);
this->glDrawElementsInstanced(var_mode, var_count, var_type, (const void*)(inptr_indices.get()), var_primcount);
SET_LASTCALL("glDrawElementsInstanced");
android::base::endTrace();
@@ -4496,6 +5828,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_indices + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_indices + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsInstancedDataAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsInstancedDataAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsInstancedDataAEMU(mode:0x%08x count:%d type:0x%08x indices:%p(%u) primcount:%d datalen:%d )", stream, var_mode, var_count, var_type, (const void*)(inptr_indices.get()), size_indices, var_primcount, var_datalen);
this->glDrawElementsInstancedDataAEMU(this, var_mode, var_count, var_type, (const void*)(inptr_indices.get()), var_primcount, var_datalen);
SET_LASTCALL("glDrawElementsInstancedDataAEMU");
android::base::endTrace();
@@ -4512,6 +5849,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsInstancedOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsInstancedOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsInstancedOffsetAEMU(mode:0x%08x count:%d type:0x%08x offset:%u primcount:%d )", stream, var_mode, var_count, var_type, var_offset, var_primcount);
this->glDrawElementsInstancedOffsetAEMU(this, var_mode, var_count, var_type, var_offset, var_primcount);
SET_LASTCALL("glDrawElementsInstancedOffsetAEMU");
android::base::endTrace();
@@ -4530,6 +5872,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + size_indices, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + size_indices, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawRangeElements: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawRangeElements\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawRangeElements(mode:0x%08x start:%u end:%u count:%d type:0x%08x indices:%p(%u) )", stream, var_mode, var_start, var_end, var_count, var_type, (const GLvoid*)(inptr_indices.get()), size_indices);
this->glDrawRangeElements(var_mode, var_start, var_end, var_count, var_type, (const GLvoid*)(inptr_indices.get()));
SET_LASTCALL("glDrawRangeElements");
android::base::endTrace();
@@ -4549,6 +5896,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + size_indices + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + size_indices + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawRangeElementsDataAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawRangeElementsDataAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawRangeElementsDataAEMU(mode:0x%08x start:%u end:%u count:%d type:0x%08x indices:%p(%u) datalen:%d )", stream, var_mode, var_start, var_end, var_count, var_type, (const GLvoid*)(inptr_indices.get()), size_indices, var_datalen);
this->glDrawRangeElementsDataAEMU(this, var_mode, var_start, var_end, var_count, var_type, (const GLvoid*)(inptr_indices.get()), var_datalen);
SET_LASTCALL("glDrawRangeElementsDataAEMU");
android::base::endTrace();
@@ -4566,6 +5918,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawRangeElementsOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawRangeElementsOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawRangeElementsOffsetAEMU(mode:0x%08x start:%u end:%u count:%d type:0x%08x offset:%u )", stream, var_mode, var_start, var_end, var_count, var_type, var_offset);
this->glDrawRangeElementsOffsetAEMU(this, var_mode, var_start, var_end, var_count, var_type, var_offset);
SET_LASTCALL("glDrawRangeElementsOffsetAEMU");
android::base::endTrace();
@@ -4582,6 +5939,11 @@
size_t totalTmpSize = sizeof(GLsync);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFenceSync\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFenceSync(condition:0x%08x flags:0x%08x )", stream, var_condition, var_flags);
*(GLsync *)(&tmpBuf[0]) = this->glFenceSync(var_condition, var_flags);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4603,6 +5965,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClientWaitSync\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClientWaitSync(wait_on:%p flags:0x%08x timeout:0x%016lx )", stream, var_wait_on, var_flags, var_timeout);
*(GLenum *)(&tmpBuf[0]) = this->glClientWaitSync(var_wait_on, var_flags, var_timeout);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4621,6 +5988,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8, ptr + 8 + 8 + 4 + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glWaitSync: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glWaitSync\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glWaitSync(wait_on:%p flags:0x%08x timeout:0x%016lx )", stream, var_wait_on, var_flags, var_timeout);
this->glWaitSync(var_wait_on, var_flags, var_timeout);
SET_LASTCALL("glWaitSync");
android::base::endTrace();
@@ -4633,6 +6005,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteSync: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteSync\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteSync(to_delete:%p )", stream, var_to_delete);
this->glDeleteSync(var_to_delete);
SET_LASTCALL("glDeleteSync");
android::base::endTrace();
@@ -4648,6 +6025,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsSync\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsSync(sync:%p )", stream, var_sync);
*(GLboolean *)(&tmpBuf[0]) = this->glIsSync(var_sync);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4670,6 +6052,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 4 + 4 + size_length + 4 + size_values, ptr + 8 + 8 + 4 + 4 + 4 + size_length + 4 + size_values, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetSynciv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetSynciv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetSynciv(sync:%p pname:0x%08x bufSize:%d length:%p(%u) values:%p(%u) )", stream, var_sync, var_pname, var_bufSize, (GLsizei*)(inptr_length.get()), size_length, (GLint*)(inptr_values.get()), size_values);
this->glGetSynciv(var_sync, var_pname, var_bufSize, (GLsizei*)(inptr_length.get()), (GLint*)(inptr_values.get()));
SET_LASTCALL("glGetSynciv");
android::base::endTrace();
@@ -4686,6 +6073,11 @@
size_t totalTmpSize = sizeof(uint64_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFenceSyncAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFenceSyncAEMU(condition:0x%08x flags:0x%08x )", stream, var_condition, var_flags);
*(uint64_t *)(&tmpBuf[0]) = this->glFenceSyncAEMU(this, var_condition, var_flags);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4707,6 +6099,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glClientWaitSyncAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glClientWaitSyncAEMU(wait_on:0x%016lx flags:0x%08x timeout:0x%016lx )", stream, var_wait_on, var_flags, var_timeout);
*(GLenum *)(&tmpBuf[0]) = this->glClientWaitSyncAEMU(this, var_wait_on, var_flags, var_timeout);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4725,6 +6122,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8, ptr + 8 + 8 + 4 + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glWaitSyncAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glWaitSyncAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glWaitSyncAEMU(wait_on:0x%016lx flags:0x%08x timeout:0x%016lx )", stream, var_wait_on, var_flags, var_timeout);
this->glWaitSyncAEMU(this, var_wait_on, var_flags, var_timeout);
SET_LASTCALL("glWaitSyncAEMU");
android::base::endTrace();
@@ -4737,6 +6139,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteSyncAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteSyncAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteSyncAEMU(to_delete:0x%016lx )", stream, var_to_delete);
this->glDeleteSyncAEMU(this, var_to_delete);
SET_LASTCALL("glDeleteSyncAEMU");
android::base::endTrace();
@@ -4752,6 +6159,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsSyncAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsSyncAEMU(sync:0x%016lx )", stream, var_sync);
*(GLboolean *)(&tmpBuf[0]) = this->glIsSyncAEMU(this, var_sync);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -4778,6 +6190,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_values(&tmpBuf[0 + size_length], size_values);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetSyncivAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetSyncivAEMU(sync:0x%016lx pname:0x%08x bufSize:%d length:%p(%u) values:%p(%u) )", stream, var_sync, var_pname, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLint*)(outptr_values.get()), size_values);
this->glGetSyncivAEMU(this, var_sync, var_pname, var_bufSize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLint*)(outptr_values.get()));
outptr_length.flush();
outptr_values.flush();
@@ -4798,6 +6215,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_bufs, ptr + 8 + 4 + 4 + size_bufs, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawBuffers: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawBuffers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawBuffers(n:%d bufs:%p(%u) )", stream, var_n, (const GLenum*)(inptr_bufs.get()), size_bufs);
this->glDrawBuffers(var_n, (const GLenum*)(inptr_bufs.get()));
SET_LASTCALL("glDrawBuffers");
android::base::endTrace();
@@ -4810,6 +6232,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glReadBuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glReadBuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glReadBuffer(src:0x%08x )", stream, var_src);
this->glReadBuffer(var_src);
SET_LASTCALL("glReadBuffer");
android::base::endTrace();
@@ -4831,6 +6258,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBlitFramebuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBlitFramebuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBlitFramebuffer(srcX0:%d srcY0:%d srcX1:%d srcY1:%d dstX0:%d dstY0:%d dstX1:%d dstY1:%d mask:0x%08x filter:0x%08x )", stream, var_srcX0, var_srcY0, var_srcX1, var_srcY1, var_dstX0, var_dstY0, var_dstX1, var_dstY1, var_mask, var_filter);
this->glBlitFramebuffer(var_srcX0, var_srcY0, var_srcX1, var_srcY1, var_dstX0, var_dstY0, var_dstX1, var_dstY1, var_mask, var_filter);
SET_LASTCALL("glBlitFramebuffer");
android::base::endTrace();
@@ -4846,6 +6278,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_attachments, ptr + 8 + 4 + 4 + 4 + size_attachments, checksumSize,
"gles2_decoder_context_t::decode, OP_glInvalidateFramebuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glInvalidateFramebuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glInvalidateFramebuffer(target:0x%08x numAttachments:%d attachments:%p(%u) )", stream, var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()), size_attachments);
this->glInvalidateFramebuffer(var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()));
SET_LASTCALL("glInvalidateFramebuffer");
android::base::endTrace();
@@ -4865,6 +6302,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_attachments + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + size_attachments + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glInvalidateSubFramebuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glInvalidateSubFramebuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glInvalidateSubFramebuffer(target:0x%08x numAttachments:%d attachments:%p(%u) x:%d y:%d width:%d height:%d )", stream, var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()), size_attachments, var_x, var_y, var_width, var_height);
this->glInvalidateSubFramebuffer(var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()), var_x, var_y, var_width, var_height);
SET_LASTCALL("glInvalidateSubFramebuffer");
android::base::endTrace();
@@ -4881,6 +6323,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFramebufferTextureLayer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFramebufferTextureLayer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFramebufferTextureLayer(target:0x%08x attachment:0x%08x texture:%u level:%d layer:%d )", stream, var_target, var_attachment, var_texture, var_level, var_layer);
this->glFramebufferTextureLayer(var_target, var_attachment, var_texture, var_level, var_layer);
SET_LASTCALL("glFramebufferTextureLayer");
android::base::endTrace();
@@ -4897,6 +6344,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glRenderbufferStorageMultisample: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glRenderbufferStorageMultisample\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glRenderbufferStorageMultisample(target:0x%08x samples:%d internalformat:0x%08x width:%d height:%d )", stream, var_target, var_samples, var_internalformat, var_width, var_height);
this->glRenderbufferStorageMultisample(var_target, var_samples, var_internalformat, var_width, var_height);
SET_LASTCALL("glRenderbufferStorageMultisample");
android::base::endTrace();
@@ -4913,6 +6365,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexStorage2D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexStorage2D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexStorage2D(target:0x%08x levels:%d internalformat:0x%08x width:%d height:%d )", stream, var_target, var_levels, var_internalformat, var_width, var_height);
this->glTexStorage2D(var_target, var_levels, var_internalformat, var_width, var_height);
SET_LASTCALL("glTexStorage2D");
android::base::endTrace();
@@ -4933,6 +6390,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetInternalformativ\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetInternalformativ(target:0x%08x internalformat:0x%08x pname:0x%08x bufSize:%d params:%p(%u) )", stream, var_target, var_internalformat, var_pname, var_bufSize, (GLint*)(outptr_params.get()), size_params);
this->glGetInternalformativ(var_target, var_internalformat, var_pname, var_bufSize, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -4950,6 +6412,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBeginTransformFeedback: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBeginTransformFeedback\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBeginTransformFeedback(primitiveMode:0x%08x )", stream, var_primitiveMode);
this->glBeginTransformFeedback(var_primitiveMode);
SET_LASTCALL("glBeginTransformFeedback");
android::base::endTrace();
@@ -4961,6 +6428,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glEndTransformFeedback: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEndTransformFeedback\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEndTransformFeedback()", stream);
this->glEndTransformFeedback();
SET_LASTCALL("glEndTransformFeedback");
android::base::endTrace();
@@ -4978,6 +6450,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_ids(&tmpBuf[0], size_ids);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenTransformFeedbacks\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenTransformFeedbacks(n:%d ids:%p(%u) )", stream, var_n, (GLuint*)(outptr_ids.get()), size_ids);
this->glGenTransformFeedbacks_dec(this, var_n, (GLuint*)(outptr_ids.get()));
outptr_ids.flush();
if (useChecksum) {
@@ -4997,6 +6474,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_ids, ptr + 8 + 4 + 4 + size_ids, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteTransformFeedbacks: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteTransformFeedbacks\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteTransformFeedbacks(n:%d ids:%p(%u) )", stream, var_n, (const GLuint*)(inptr_ids.get()), size_ids);
this->glDeleteTransformFeedbacks_dec(this, var_n, (const GLuint*)(inptr_ids.get()));
SET_LASTCALL("glDeleteTransformFeedbacks");
android::base::endTrace();
@@ -5010,6 +6492,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindTransformFeedback: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindTransformFeedback\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindTransformFeedback(target:0x%08x id:%u )", stream, var_target, var_id);
this->glBindTransformFeedback(var_target, var_id);
SET_LASTCALL("glBindTransformFeedback");
android::base::endTrace();
@@ -5021,6 +6508,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glPauseTransformFeedback: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glPauseTransformFeedback\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glPauseTransformFeedback()", stream);
this->glPauseTransformFeedback();
SET_LASTCALL("glPauseTransformFeedback");
android::base::endTrace();
@@ -5032,6 +6524,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glResumeTransformFeedback: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glResumeTransformFeedback\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glResumeTransformFeedback()", stream);
this->glResumeTransformFeedback();
SET_LASTCALL("glResumeTransformFeedback");
android::base::endTrace();
@@ -5047,6 +6544,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsTransformFeedback\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsTransformFeedback(id:%u )", stream, var_id);
*(GLboolean *)(&tmpBuf[0]) = this->glIsTransformFeedback(var_id);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -5067,6 +6569,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_varyings + 4, ptr + 8 + 4 + 4 + 4 + size_varyings + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTransformFeedbackVaryings: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTransformFeedbackVaryings\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTransformFeedbackVaryings(program:%u count:%d varyings:%p(%u) bufferMode:0x%08x )", stream, var_program, var_count, (const char**)(inptr_varyings.get()), size_varyings, var_bufferMode);
this->glTransformFeedbackVaryings_dec(this, var_program, var_count, (const char**)(inptr_varyings.get()), var_bufferMode);
SET_LASTCALL("glTransformFeedbackVaryings");
android::base::endTrace();
@@ -5084,6 +6591,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_packedVaryings + 4 + 4, ptr + 8 + 4 + 4 + 4 + size_packedVaryings + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTransformFeedbackVaryingsAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTransformFeedbackVaryingsAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTransformFeedbackVaryingsAEMU(program:%u count:%d packedVaryings:%p(%u) packedVaryingsLen:%u bufferMode:0x%08x )", stream, var_program, var_count, (const char*)(inptr_packedVaryings.get()), size_packedVaryings, var_packedVaryingsLen, var_bufferMode);
this->glTransformFeedbackVaryingsAEMU(this, var_program, var_count, (const char*)(inptr_packedVaryings.get()), var_packedVaryingsLen, var_bufferMode);
SET_LASTCALL("glTransformFeedbackVaryingsAEMU");
android::base::endTrace();
@@ -5112,6 +6624,11 @@
OutputBuffer outptr_size(&tmpBuf[0 + size_length], size_size);
OutputBuffer outptr_type(&tmpBuf[0 + size_length + size_size], size_type);
OutputBuffer outptr_name(&tmpBuf[0 + size_length + size_size + size_type], size_name);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetTransformFeedbackVarying\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetTransformFeedbackVarying(program:%u index:%u bufSize:%d length:%p(%u) size:%p(%u) type:%p(%u) name:%p(%u) )", stream, var_program, var_index, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLsizei*)(outptr_size.get()), size_size, (GLenum*)(outptr_type.get()), size_type, (char*)(outptr_name.get()), size_name);
this->glGetTransformFeedbackVarying_dec(this, var_program, var_index, var_bufSize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLsizei*)(outptr_size.get()), size_type == 0 ? nullptr : (GLenum*)(outptr_type.get()), size_name == 0 ? nullptr : (char*)(outptr_name.get()));
outptr_length.flush();
outptr_size.flush();
@@ -5137,6 +6654,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_samplers(&tmpBuf[0], size_samplers);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenSamplers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenSamplers(n:%d samplers:%p(%u) )", stream, var_n, (GLuint*)(outptr_samplers.get()), size_samplers);
this->glGenSamplers_dec(this, var_n, (GLuint*)(outptr_samplers.get()));
outptr_samplers.flush();
if (useChecksum) {
@@ -5156,6 +6678,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_samplers, ptr + 8 + 4 + 4 + size_samplers, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteSamplers: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteSamplers\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteSamplers(n:%d samplers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_samplers.get()), size_samplers);
this->glDeleteSamplers_dec(this, var_n, (const GLuint*)(inptr_samplers.get()));
SET_LASTCALL("glDeleteSamplers");
android::base::endTrace();
@@ -5169,6 +6696,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindSampler: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindSampler\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindSampler(unit:%u sampler:%u )", stream, var_unit, var_sampler);
this->glBindSampler(var_unit, var_sampler);
SET_LASTCALL("glBindSampler");
android::base::endTrace();
@@ -5183,6 +6715,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glSamplerParameterf: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSamplerParameterf\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSamplerParameterf(sampler:%u pname:0x%08x param:%f )", stream, var_sampler, var_pname, var_param);
this->glSamplerParameterf(var_sampler, var_pname, var_param);
SET_LASTCALL("glSamplerParameterf");
android::base::endTrace();
@@ -5197,6 +6734,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glSamplerParameteri: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSamplerParameteri\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSamplerParameteri(sampler:%u pname:0x%08x param:%d )", stream, var_sampler, var_pname, var_param);
this->glSamplerParameteri(var_sampler, var_pname, var_param);
SET_LASTCALL("glSamplerParameteri");
android::base::endTrace();
@@ -5212,6 +6754,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glSamplerParameterfv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSamplerParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSamplerParameterfv(sampler:%u pname:0x%08x params:%p(%u) )", stream, var_sampler, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
this->glSamplerParameterfv(var_sampler, var_pname, (const GLfloat*)(inptr_params.get()));
SET_LASTCALL("glSamplerParameterfv");
android::base::endTrace();
@@ -5227,6 +6774,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
"gles2_decoder_context_t::decode, OP_glSamplerParameteriv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSamplerParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSamplerParameteriv(sampler:%u pname:0x%08x params:%p(%u) )", stream, var_sampler, var_pname, (const GLint*)(inptr_params.get()), size_params);
this->glSamplerParameteriv(var_sampler, var_pname, (const GLint*)(inptr_params.get()));
SET_LASTCALL("glSamplerParameteriv");
android::base::endTrace();
@@ -5245,6 +6797,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetSamplerParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetSamplerParameterfv(sampler:%u pname:0x%08x params:%p(%u) )", stream, var_sampler, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetSamplerParameterfv(var_sampler, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -5268,6 +6825,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetSamplerParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetSamplerParameteriv(sampler:%u pname:0x%08x params:%p(%u) )", stream, var_sampler, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetSamplerParameteriv(var_sampler, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -5288,6 +6850,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsSampler\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsSampler(sampler:%u )", stream, var_sampler);
*(GLboolean *)(&tmpBuf[0]) = this->glIsSampler(var_sampler);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -5309,6 +6876,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_queries(&tmpBuf[0], size_queries);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenQueries\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenQueries(n:%d queries:%p(%u) )", stream, var_n, (GLuint*)(outptr_queries.get()), size_queries);
this->glGenQueries_dec(this, var_n, (GLuint*)(outptr_queries.get()));
outptr_queries.flush();
if (useChecksum) {
@@ -5328,6 +6900,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_queries, ptr + 8 + 4 + 4 + size_queries, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteQueries: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteQueries\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteQueries(n:%d queries:%p(%u) )", stream, var_n, (const GLuint*)(inptr_queries.get()), size_queries);
this->glDeleteQueries_dec(this, var_n, (const GLuint*)(inptr_queries.get()));
SET_LASTCALL("glDeleteQueries");
android::base::endTrace();
@@ -5341,6 +6918,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBeginQuery: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBeginQuery\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBeginQuery(target:0x%08x query:%u )", stream, var_target, var_query);
this->glBeginQuery(var_target, var_query);
SET_LASTCALL("glBeginQuery");
android::base::endTrace();
@@ -5353,6 +6935,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glEndQuery: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glEndQuery\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glEndQuery(target:0x%08x )", stream, var_target);
this->glEndQuery(var_target);
SET_LASTCALL("glEndQuery");
android::base::endTrace();
@@ -5371,6 +6958,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetQueryiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetQueryiv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetQueryiv(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -5394,6 +6986,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetQueryObjectuiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetQueryObjectuiv(query:%u pname:0x%08x params:%p(%u) )", stream, var_query, var_pname, (GLuint*)(outptr_params.get()), size_params);
this->glGetQueryObjectuiv(var_query, var_pname, (GLuint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -5414,6 +7011,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsQuery\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsQuery(query:%u )", stream, var_query);
*(GLboolean *)(&tmpBuf[0]) = this->glIsQuery(var_query);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -5432,6 +7034,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramParameteri: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramParameteri\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramParameteri(program:%u pname:0x%08x value:%d )", stream, var_program, var_pname, var_value);
this->glProgramParameteri_dec(this, var_program, var_pname, var_value);
SET_LASTCALL("glProgramParameteri");
android::base::endTrace();
@@ -5448,6 +7055,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_binary + 4, ptr + 8 + 4 + 4 + 4 + size_binary + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramBinary: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramBinary\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramBinary(program:%u binaryFormat:0x%08x binary:%p(%u) length:%d )", stream, var_program, var_binaryFormat, (const void*)(inptr_binary.get()), size_binary, var_length);
this->glProgramBinary_dec(this, var_program, var_binaryFormat, (const void*)(inptr_binary.get()), var_length);
SET_LASTCALL("glProgramBinary");
android::base::endTrace();
@@ -5472,6 +7084,11 @@
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_binaryFormat(&tmpBuf[0 + size_length], size_binaryFormat);
OutputBuffer outptr_binary(&tmpBuf[0 + size_length + size_binaryFormat], size_binary);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramBinary\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramBinary(program:%u bufSize:%d length:%p(%u) binaryFormat:%p(%u) binary:%p(%u) )", stream, var_program, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLenum*)(outptr_binaryFormat.get()), size_binaryFormat, (void*)(outptr_binary.get()), size_binary);
this->glGetProgramBinary_dec(this, var_program, var_bufSize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLenum*)(outptr_binaryFormat.get()), (void*)(outptr_binary.get()));
outptr_length.flush();
outptr_binaryFormat.flush();
@@ -5496,6 +7113,11 @@
size_t totalTmpSize = sizeof(GLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetFragDataLocation\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetFragDataLocation(program:%u name:%p(%u) )", stream, var_program, (const char*)(inptr_name.get()), size_name);
*(GLint *)(&tmpBuf[0]) = this->glGetFragDataLocation_dec(this, var_program, (const char*)(inptr_name.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -5517,6 +7139,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_data(&tmpBuf[0], size_data);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetInteger64v\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetInteger64v(pname:0x%08x data:%p(%u) )", stream, var_pname, (GLint64*)(outptr_data.get()), size_data);
this->glGetInteger64v(var_pname, (GLint64*)(outptr_data.get()));
outptr_data.flush();
if (useChecksum) {
@@ -5540,6 +7167,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_data(&tmpBuf[0], size_data);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetIntegeri_v\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetIntegeri_v(target:0x%08x index:%u data:%p(%u) )", stream, var_target, var_index, (GLint*)(outptr_data.get()), size_data);
this->glGetIntegeri_v(var_target, var_index, (GLint*)(outptr_data.get()));
outptr_data.flush();
if (useChecksum) {
@@ -5563,6 +7195,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_data(&tmpBuf[0], size_data);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetInteger64i_v\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetInteger64i_v(target:0x%08x index:%u data:%p(%u) )", stream, var_target, var_index, (GLint64*)(outptr_data.get()), size_data);
this->glGetInteger64i_v(var_target, var_index, (GLint64*)(outptr_data.get()));
outptr_data.flush();
if (useChecksum) {
@@ -5590,6 +7227,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexImage3D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexImage3D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexImage3D(target:0x%08x level:%d internalFormat:%d width:%d height:%d depth:%d border:%d format:0x%08x type:0x%08x data:%p(%u) )", stream, var_target, var_level, var_internalFormat, var_width, var_height, var_depth, var_border, var_format, var_type, (const GLvoid*)(inptr_data.get()), size_data);
this->glTexImage3D(var_target, var_level, var_internalFormat, var_width, var_height, var_depth, var_border, var_format, var_type, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glTexImage3D");
android::base::endTrace();
@@ -5611,6 +7253,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexImage3DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexImage3DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexImage3DOffsetAEMU(target:0x%08x level:%d internalFormat:%d width:%d height:%d depth:%d border:%d format:0x%08x type:0x%08x offset:%u )", stream, var_target, var_level, var_internalFormat, var_width, var_height, var_depth, var_border, var_format, var_type, var_offset);
this->glTexImage3DOffsetAEMU(this, var_target, var_level, var_internalFormat, var_width, var_height, var_depth, var_border, var_format, var_type, var_offset);
SET_LASTCALL("glTexImage3DOffsetAEMU");
android::base::endTrace();
@@ -5628,6 +7275,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexStorage3D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexStorage3D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexStorage3D(target:0x%08x levels:%d internalformat:0x%08x width:%d height:%d depth:%d )", stream, var_target, var_levels, var_internalformat, var_width, var_height, var_depth);
this->glTexStorage3D(var_target, var_levels, var_internalformat, var_width, var_height, var_depth);
SET_LASTCALL("glTexStorage3D");
android::base::endTrace();
@@ -5651,6 +7303,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexSubImage3D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexSubImage3D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexSubImage3D(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x type:0x%08x data:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (const GLvoid*)(inptr_data.get()), size_data);
this->glTexSubImage3D(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glTexSubImage3D");
android::base::endTrace();
@@ -5673,6 +7330,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexSubImage3DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexSubImage3DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexSubImage3DOffsetAEMU(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x type:0x%08x offset:%u )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, var_offset);
this->glTexSubImage3DOffsetAEMU(this, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, var_offset);
SET_LASTCALL("glTexSubImage3DOffsetAEMU");
android::base::endTrace();
@@ -5694,6 +7356,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexImage3D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexImage3D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexImage3D(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d depth:%d border:%d imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexImage3D(var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexImage3D");
android::base::endTrace();
@@ -5714,6 +7381,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexImage3DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexImage3DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexImage3DOffsetAEMU(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d depth:%d border:%d imageSize:%d offset:%u )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_imageSize, var_offset);
this->glCompressedTexImage3DOffsetAEMU(this, var_target, var_level, var_internalformat, var_width, var_height, var_depth, var_border, var_imageSize, var_offset);
SET_LASTCALL("glCompressedTexImage3DOffsetAEMU");
android::base::endTrace();
@@ -5737,6 +7409,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexSubImage3D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexSubImage3D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexSubImage3D(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
this->glCompressedTexSubImage3D(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
SET_LASTCALL("glCompressedTexSubImage3D");
android::base::endTrace();
@@ -5759,6 +7436,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCompressedTexSubImage3DOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCompressedTexSubImage3DOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCompressedTexSubImage3DOffsetAEMU(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x imageSize:%d data:%u )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_imageSize, var_data);
this->glCompressedTexSubImage3DOffsetAEMU(this, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_imageSize, var_data);
SET_LASTCALL("glCompressedTexSubImage3DOffsetAEMU");
android::base::endTrace();
@@ -5779,6 +7461,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glCopyTexSubImage3D: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCopyTexSubImage3D\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCopyTexSubImage3D(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d x:%d y:%d width:%d height:%d )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_x, var_y, var_width, var_height);
this->glCopyTexSubImage3D(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_x, var_y, var_width, var_height);
SET_LASTCALL("glCopyTexSubImage3D");
android::base::endTrace();
@@ -5792,6 +7479,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glGetStringi: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetStringi\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetStringi(name:0x%08x index:%u )", stream, var_name, var_index);
this->glGetStringi(var_name, var_index);
SET_LASTCALL("glGetStringi");
android::base::endTrace();
@@ -5810,6 +7502,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_data(&tmpBuf[0], size_data);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetBooleani_v\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetBooleani_v(target:0x%08x index:%u data:%p(%u) )", stream, var_target, var_index, (GLboolean*)(outptr_data.get()), size_data);
this->glGetBooleani_v(var_target, var_index, (GLboolean*)(outptr_data.get()));
outptr_data.flush();
if (useChecksum) {
@@ -5827,6 +7524,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glMemoryBarrier: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMemoryBarrier\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMemoryBarrier(barriers:0x%08x )", stream, var_barriers);
this->glMemoryBarrier(var_barriers);
SET_LASTCALL("glMemoryBarrier");
android::base::endTrace();
@@ -5839,6 +7541,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glMemoryBarrierByRegion: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMemoryBarrierByRegion\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMemoryBarrierByRegion(barriers:0x%08x )", stream, var_barriers);
this->glMemoryBarrierByRegion(var_barriers);
SET_LASTCALL("glMemoryBarrierByRegion");
android::base::endTrace();
@@ -5856,6 +7563,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_pipelines(&tmpBuf[0], size_pipelines);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGenProgramPipelines\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGenProgramPipelines(n:%d pipelines:%p(%u) )", stream, var_n, (GLuint*)(outptr_pipelines.get()), size_pipelines);
this->glGenProgramPipelines_dec(this, var_n, (GLuint*)(outptr_pipelines.get()));
outptr_pipelines.flush();
if (useChecksum) {
@@ -5875,6 +7587,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_pipelines, ptr + 8 + 4 + 4 + size_pipelines, checksumSize,
"gles2_decoder_context_t::decode, OP_glDeleteProgramPipelines: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDeleteProgramPipelines\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDeleteProgramPipelines(n:%d pipelines:%p(%u) )", stream, var_n, (const GLuint*)(inptr_pipelines.get()), size_pipelines);
this->glDeleteProgramPipelines_dec(this, var_n, (const GLuint*)(inptr_pipelines.get()));
SET_LASTCALL("glDeleteProgramPipelines");
android::base::endTrace();
@@ -5887,6 +7604,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindProgramPipeline: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindProgramPipeline\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindProgramPipeline(pipeline:%u )", stream, var_pipeline);
this->glBindProgramPipeline(var_pipeline);
SET_LASTCALL("glBindProgramPipeline");
android::base::endTrace();
@@ -5905,6 +7627,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramPipelineiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramPipelineiv(pipeline:%u pname:0x%08x params:%p(%u) )", stream, var_pipeline, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetProgramPipelineiv(var_pipeline, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -5931,6 +7658,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_infoLog(&tmpBuf[0 + size_length], size_infoLog);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramPipelineInfoLog\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramPipelineInfoLog(pipeline:%u bufSize:%d length:%p(%u) infoLog:%p(%u) )", stream, var_pipeline, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_infoLog.get()), size_infoLog);
this->glGetProgramPipelineInfoLog(var_pipeline, var_bufSize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_infoLog.get()));
outptr_length.flush();
outptr_infoLog.flush();
@@ -5949,6 +7681,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glValidateProgramPipeline: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glValidateProgramPipeline\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glValidateProgramPipeline(pipeline:%u )", stream, var_pipeline);
this->glValidateProgramPipeline(var_pipeline);
SET_LASTCALL("glValidateProgramPipeline");
android::base::endTrace();
@@ -5964,6 +7701,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glIsProgramPipeline\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glIsProgramPipeline(pipeline:%u )", stream, var_pipeline);
*(GLboolean *)(&tmpBuf[0]) = this->glIsProgramPipeline(var_pipeline);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -5982,6 +7724,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glUseProgramStages: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUseProgramStages\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUseProgramStages(pipeline:%u stages:0x%08x program:%u )", stream, var_pipeline, var_stages, var_program);
this->glUseProgramStages_dec(this, var_pipeline, var_stages, var_program);
SET_LASTCALL("glUseProgramStages");
android::base::endTrace();
@@ -5995,6 +7742,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glActiveShaderProgram: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glActiveShaderProgram\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glActiveShaderProgram(pipeline:%u program:%u )", stream, var_pipeline, var_program);
this->glActiveShaderProgram_dec(this, var_pipeline, var_program);
SET_LASTCALL("glActiveShaderProgram");
android::base::endTrace();
@@ -6013,6 +7765,11 @@
size_t totalTmpSize = sizeof(GLuint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCreateShaderProgramv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCreateShaderProgramv(type:0x%08x count:%d strings:%p(%u) )", stream, var_type, var_count, (const char**)(inptr_strings.get()), size_strings);
*(GLuint *)(&tmpBuf[0]) = this->glCreateShaderProgramv(var_type, var_count, (const char**)(inptr_strings.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -6036,6 +7793,11 @@
size_t totalTmpSize = sizeof(GLuint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glCreateShaderProgramvAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glCreateShaderProgramvAEMU(type:0x%08x count:%d packedStrings:%p(%u) packedLen:%u )", stream, var_type, var_count, (const char*)(inptr_packedStrings.get()), size_packedStrings, var_packedLen);
*(GLuint *)(&tmpBuf[0]) = this->glCreateShaderProgramvAEMU(this, var_type, var_count, (const char*)(inptr_packedStrings.get()), var_packedLen);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -6054,6 +7816,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform1f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform1f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform1f(program:%u location:%d v0:%f )", stream, var_program, var_location, var_v0);
this->glProgramUniform1f_dec(this, var_program, var_location, var_v0);
SET_LASTCALL("glProgramUniform1f");
android::base::endTrace();
@@ -6069,6 +7836,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform2f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform2f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform2f(program:%u location:%d v0:%f v1:%f )", stream, var_program, var_location, var_v0, var_v1);
this->glProgramUniform2f_dec(this, var_program, var_location, var_v0, var_v1);
SET_LASTCALL("glProgramUniform2f");
android::base::endTrace();
@@ -6085,6 +7857,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform3f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform3f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform3f(program:%u location:%d v0:%f v1:%f v2:%f )", stream, var_program, var_location, var_v0, var_v1, var_v2);
this->glProgramUniform3f_dec(this, var_program, var_location, var_v0, var_v1, var_v2);
SET_LASTCALL("glProgramUniform3f");
android::base::endTrace();
@@ -6102,6 +7879,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform4f: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform4f\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform4f(program:%u location:%d v0:%f v1:%f v2:%f v3:%f )", stream, var_program, var_location, var_v0, var_v1, var_v2, var_v3);
this->glProgramUniform4f_dec(this, var_program, var_location, var_v0, var_v1, var_v2, var_v3);
SET_LASTCALL("glProgramUniform4f");
android::base::endTrace();
@@ -6116,6 +7898,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform1i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform1i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform1i(program:%u location:%d v0:%d )", stream, var_program, var_location, var_v0);
this->glProgramUniform1i_dec(this, var_program, var_location, var_v0);
SET_LASTCALL("glProgramUniform1i");
android::base::endTrace();
@@ -6131,6 +7918,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform2i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform2i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform2i(program:%u location:%d v0:%d v1:%d )", stream, var_program, var_location, var_v0, var_v1);
this->glProgramUniform2i_dec(this, var_program, var_location, var_v0, var_v1);
SET_LASTCALL("glProgramUniform2i");
android::base::endTrace();
@@ -6147,6 +7939,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform3i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform3i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform3i(program:%u location:%d v0:%d v1:%d v2:%d )", stream, var_program, var_location, var_v0, var_v1, var_v2);
this->glProgramUniform3i_dec(this, var_program, var_location, var_v0, var_v1, var_v2);
SET_LASTCALL("glProgramUniform3i");
android::base::endTrace();
@@ -6164,6 +7961,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform4i: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform4i\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform4i(program:%u location:%d v0:%d v1:%d v2:%d v3:%d )", stream, var_program, var_location, var_v0, var_v1, var_v2, var_v3);
this->glProgramUniform4i_dec(this, var_program, var_location, var_v0, var_v1, var_v2, var_v3);
SET_LASTCALL("glProgramUniform4i");
android::base::endTrace();
@@ -6178,6 +7980,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform1ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform1ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform1ui(program:%u location:%d v0:%u )", stream, var_program, var_location, var_v0);
this->glProgramUniform1ui_dec(this, var_program, var_location, var_v0);
SET_LASTCALL("glProgramUniform1ui");
android::base::endTrace();
@@ -6193,6 +8000,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform2ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform2ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform2ui(program:%u location:%d v0:%d v1:%u )", stream, var_program, var_location, var_v0, var_v1);
this->glProgramUniform2ui_dec(this, var_program, var_location, var_v0, var_v1);
SET_LASTCALL("glProgramUniform2ui");
android::base::endTrace();
@@ -6209,6 +8021,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform3ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform3ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform3ui(program:%u location:%d v0:%d v1:%d v2:%u )", stream, var_program, var_location, var_v0, var_v1, var_v2);
this->glProgramUniform3ui_dec(this, var_program, var_location, var_v0, var_v1, var_v2);
SET_LASTCALL("glProgramUniform3ui");
android::base::endTrace();
@@ -6226,6 +8043,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform4ui: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform4ui\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform4ui(program:%u location:%d v0:%d v1:%d v2:%d v3:%u )", stream, var_program, var_location, var_v0, var_v1, var_v2, var_v3);
this->glProgramUniform4ui_dec(this, var_program, var_location, var_v0, var_v1, var_v2, var_v3);
SET_LASTCALL("glProgramUniform4ui");
android::base::endTrace();
@@ -6242,6 +8064,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform1fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform1fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform1fv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniform1fv_dec(this, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform1fv");
android::base::endTrace();
@@ -6258,6 +8085,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform2fv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniform2fv_dec(this, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform2fv");
android::base::endTrace();
@@ -6274,6 +8106,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform3fv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniform3fv_dec(this, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform3fv");
android::base::endTrace();
@@ -6290,6 +8127,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform4fv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniform4fv_dec(this, var_program, var_location, var_count, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform4fv");
android::base::endTrace();
@@ -6306,6 +8148,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform1iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform1iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform1iv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLint*)(inptr_value.get()), size_value);
this->glProgramUniform1iv_dec(this, var_program, var_location, var_count, (const GLint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform1iv");
android::base::endTrace();
@@ -6322,6 +8169,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform2iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform2iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform2iv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLint*)(inptr_value.get()), size_value);
this->glProgramUniform2iv_dec(this, var_program, var_location, var_count, (const GLint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform2iv");
android::base::endTrace();
@@ -6338,6 +8190,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform3iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform3iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform3iv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLint*)(inptr_value.get()), size_value);
this->glProgramUniform3iv_dec(this, var_program, var_location, var_count, (const GLint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform3iv");
android::base::endTrace();
@@ -6354,6 +8211,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform4iv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform4iv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform4iv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLint*)(inptr_value.get()), size_value);
this->glProgramUniform4iv_dec(this, var_program, var_location, var_count, (const GLint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform4iv");
android::base::endTrace();
@@ -6370,6 +8232,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform1uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform1uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform1uiv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glProgramUniform1uiv_dec(this, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform1uiv");
android::base::endTrace();
@@ -6386,6 +8253,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform2uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform2uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform2uiv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glProgramUniform2uiv_dec(this, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform2uiv");
android::base::endTrace();
@@ -6402,6 +8274,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform3uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform3uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform3uiv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glProgramUniform3uiv_dec(this, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform3uiv");
android::base::endTrace();
@@ -6418,6 +8295,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniform4uiv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniform4uiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniform4uiv(program:%u location:%d count:%d value:%p(%u) )", stream, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()), size_value);
this->glProgramUniform4uiv_dec(this, var_program, var_location, var_count, (const GLuint*)(inptr_value.get()));
SET_LASTCALL("glProgramUniform4uiv");
android::base::endTrace();
@@ -6435,6 +8317,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix2fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix2fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix2fv");
android::base::endTrace();
@@ -6452,6 +8339,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix3fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix3fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix3fv");
android::base::endTrace();
@@ -6469,6 +8361,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix4fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix4fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix4fv");
android::base::endTrace();
@@ -6486,6 +8383,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix2x3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix2x3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix2x3fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix2x3fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix2x3fv");
android::base::endTrace();
@@ -6503,6 +8405,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix3x2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix3x2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix3x2fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix3x2fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix3x2fv");
android::base::endTrace();
@@ -6520,6 +8427,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix2x4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix2x4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix2x4fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix2x4fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix2x4fv");
android::base::endTrace();
@@ -6537,6 +8449,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix4x2fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix4x2fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix4x2fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix4x2fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix4x2fv");
android::base::endTrace();
@@ -6554,6 +8471,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix3x4fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix3x4fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix3x4fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix3x4fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix3x4fv");
android::base::endTrace();
@@ -6571,6 +8493,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + size_value, ptr + 8 + 4 + 4 + 4 + 1 + 4 + size_value, checksumSize,
"gles2_decoder_context_t::decode, OP_glProgramUniformMatrix4x3fv: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glProgramUniformMatrix4x3fv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glProgramUniformMatrix4x3fv(program:%u location:%d count:%d transpose:%d value:%p(%u) )", stream, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()), size_value);
this->glProgramUniformMatrix4x3fv_dec(this, var_program, var_location, var_count, var_transpose, (const GLfloat*)(inptr_value.get()));
SET_LASTCALL("glProgramUniformMatrix4x3fv");
android::base::endTrace();
@@ -6590,6 +8517,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramInterfaceiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramInterfaceiv(program:%u programInterface:0x%08x pname:0x%08x params:%p(%u) )", stream, var_program, var_programInterface, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetProgramInterfaceiv_dec(this, var_program, var_programInterface, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -6621,6 +8553,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_params(&tmpBuf[0 + size_length], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramResourceiv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramResourceiv(program:%u programInterface:0x%08x index:%u propCount:%d props:%p(%u) bufSize:%d length:%p(%u) params:%p(%u) )", stream, var_program, var_programInterface, var_index, var_propCount, (const GLenum*)(inptr_props.get()), size_props, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLint*)(outptr_params.get()), size_params);
this->glGetProgramResourceiv_dec(this, var_program, var_programInterface, var_index, var_propCount, (const GLenum*)(inptr_props.get()), var_bufSize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (GLint*)(outptr_params.get()));
outptr_length.flush();
outptr_params.flush();
@@ -6645,6 +8582,11 @@
size_t totalTmpSize = sizeof(GLuint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramResourceIndex\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramResourceIndex(program:%u programInterface:0x%08x name:%p(%u) )", stream, var_program, var_programInterface, (const char*)(inptr_name.get()), size_name);
*(GLuint *)(&tmpBuf[0]) = this->glGetProgramResourceIndex_dec(this, var_program, var_programInterface, (const char*)(inptr_name.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -6667,6 +8609,11 @@
size_t totalTmpSize = sizeof(GLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramResourceLocation\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramResourceLocation(program:%u programInterface:0x%08x name:%p(%u) )", stream, var_program, var_programInterface, (const char*)(inptr_name.get()), size_name);
*(GLint *)(&tmpBuf[0]) = this->glGetProgramResourceLocation_dec(this, var_program, var_programInterface, (const char*)(inptr_name.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -6694,6 +8641,11 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_length(&tmpBuf[0], size_length);
OutputBuffer outptr_name(&tmpBuf[0 + size_length], size_name);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetProgramResourceName\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetProgramResourceName(program:%u programInterface:0x%08x index:%u bufSize:%d length:%p(%u) name:%p(%u) )", stream, var_program, var_programInterface, var_index, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (char*)(outptr_name.get()), size_name);
this->glGetProgramResourceName_dec(this, var_program, var_programInterface, var_index, var_bufSize, size_length == 0 ? nullptr : (GLsizei*)(outptr_length.get()), (char*)(outptr_name.get()));
outptr_length.flush();
outptr_name.flush();
@@ -6718,6 +8670,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 1 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindImageTexture: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindImageTexture\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindImageTexture(unit:%u texture:%u level:%d layered:%d layer:%d access:0x%08x format:0x%08x )", stream, var_unit, var_texture, var_level, var_layered, var_layer, var_access, var_format);
this->glBindImageTexture(var_unit, var_texture, var_level, var_layered, var_layer, var_access, var_format);
SET_LASTCALL("glBindImageTexture");
android::base::endTrace();
@@ -6732,6 +8689,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDispatchCompute: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDispatchCompute\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDispatchCompute(num_groups_x:%u num_groups_y:%u num_groups_z:%u )", stream, var_num_groups_x, var_num_groups_y, var_num_groups_z);
this->glDispatchCompute(var_num_groups_x, var_num_groups_y, var_num_groups_z);
SET_LASTCALL("glDispatchCompute");
android::base::endTrace();
@@ -6744,6 +8706,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDispatchComputeIndirect: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDispatchComputeIndirect\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDispatchComputeIndirect(indirect:0x%08lx )", stream, var_indirect);
this->glDispatchComputeIndirect(var_indirect);
SET_LASTCALL("glDispatchComputeIndirect");
android::base::endTrace();
@@ -6759,6 +8726,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glBindVertexBuffer: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBindVertexBuffer\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBindVertexBuffer(bindingindex:%u buffer:%u offset:0x%08lx stride:0x%08lx )", stream, var_bindingindex, var_buffer, var_offset, var_stride);
this->glBindVertexBuffer(var_bindingindex, var_buffer, var_offset, var_stride);
SET_LASTCALL("glBindVertexBuffer");
android::base::endTrace();
@@ -6772,6 +8744,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribBinding: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribBinding\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribBinding(attribindex:%u bindingindex:%u )", stream, var_attribindex, var_bindingindex);
this->glVertexAttribBinding(var_attribindex, var_bindingindex);
SET_LASTCALL("glVertexAttribBinding");
android::base::endTrace();
@@ -6788,6 +8765,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 1 + 4, ptr + 8 + 4 + 4 + 4 + 1 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribFormat: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribFormat\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribFormat(attribindex:%u size:%d type:0x%08x normalized:%d relativeoffset:%u )", stream, var_attribindex, var_size, var_type, var_normalized, var_relativeoffset);
this->glVertexAttribFormat(var_attribindex, var_size, var_type, var_normalized, var_relativeoffset);
SET_LASTCALL("glVertexAttribFormat");
android::base::endTrace();
@@ -6803,6 +8785,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexAttribIFormat: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexAttribIFormat\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexAttribIFormat(attribindex:%u size:%d type:0x%08x relativeoffset:%u )", stream, var_attribindex, var_size, var_type, var_relativeoffset);
this->glVertexAttribIFormat(var_attribindex, var_size, var_type, var_relativeoffset);
SET_LASTCALL("glVertexAttribIFormat");
android::base::endTrace();
@@ -6816,6 +8803,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glVertexBindingDivisor: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glVertexBindingDivisor\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glVertexBindingDivisor(bindingindex:%u divisor:%u )", stream, var_bindingindex, var_divisor);
this->glVertexBindingDivisor(var_bindingindex, var_divisor);
SET_LASTCALL("glVertexBindingDivisor");
android::base::endTrace();
@@ -6830,6 +8822,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_indirect, ptr + 8 + 4 + 4 + size_indirect, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawArraysIndirect: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawArraysIndirect\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawArraysIndirect(mode:0x%08x indirect:%p(%u) )", stream, var_mode, (const void*)(inptr_indirect.get()), size_indirect);
this->glDrawArraysIndirect(var_mode, (const void*)(inptr_indirect.get()));
SET_LASTCALL("glDrawArraysIndirect");
android::base::endTrace();
@@ -6845,6 +8842,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_indirect + 4, ptr + 8 + 4 + 4 + size_indirect + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawArraysIndirectDataAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawArraysIndirectDataAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawArraysIndirectDataAEMU(mode:0x%08x indirect:%p(%u) datalen:%u )", stream, var_mode, (const void*)(inptr_indirect.get()), size_indirect, var_datalen);
this->glDrawArraysIndirectDataAEMU(this, var_mode, (const void*)(inptr_indirect.get()), var_datalen);
SET_LASTCALL("glDrawArraysIndirectDataAEMU");
android::base::endTrace();
@@ -6858,6 +8860,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawArraysIndirectOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawArraysIndirectOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawArraysIndirectOffsetAEMU(mode:0x%08x offset:%u )", stream, var_mode, var_offset);
this->glDrawArraysIndirectOffsetAEMU(this, var_mode, var_offset);
SET_LASTCALL("glDrawArraysIndirectOffsetAEMU");
android::base::endTrace();
@@ -6873,6 +8880,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_indirect, ptr + 8 + 4 + 4 + 4 + size_indirect, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsIndirect: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsIndirect\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsIndirect(mode:0x%08x type:0x%08x indirect:%p(%u) )", stream, var_mode, var_type, (const void*)(inptr_indirect.get()), size_indirect);
this->glDrawElementsIndirect(var_mode, var_type, (const void*)(inptr_indirect.get()));
SET_LASTCALL("glDrawElementsIndirect");
android::base::endTrace();
@@ -6889,6 +8901,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_indirect + 4, ptr + 8 + 4 + 4 + 4 + size_indirect + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsIndirectDataAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsIndirectDataAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsIndirectDataAEMU(mode:0x%08x type:0x%08x indirect:%p(%u) datalen:%u )", stream, var_mode, var_type, (const void*)(inptr_indirect.get()), size_indirect, var_datalen);
this->glDrawElementsIndirectDataAEMU(this, var_mode, var_type, (const void*)(inptr_indirect.get()), var_datalen);
SET_LASTCALL("glDrawElementsIndirectDataAEMU");
android::base::endTrace();
@@ -6903,6 +8920,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsIndirectOffsetAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsIndirectOffsetAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsIndirectOffsetAEMU(mode:0x%08x type:0x%08x offset:%u )", stream, var_mode, var_type, var_offset);
this->glDrawElementsIndirectOffsetAEMU(this, var_mode, var_type, var_offset);
SET_LASTCALL("glDrawElementsIndirectOffsetAEMU");
android::base::endTrace();
@@ -6920,6 +8942,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 1, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 1, checksumSize,
"gles2_decoder_context_t::decode, OP_glTexStorage2DMultisample: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glTexStorage2DMultisample\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glTexStorage2DMultisample(target:0x%08x samples:%d internalformat:0x%08x width:%d height:%d fixedsamplelocations:%d )", stream, var_target, var_samples, var_internalformat, var_width, var_height, var_fixedsamplelocations);
this->glTexStorage2DMultisample(var_target, var_samples, var_internalformat, var_width, var_height, var_fixedsamplelocations);
SET_LASTCALL("glTexStorage2DMultisample");
android::base::endTrace();
@@ -6933,6 +8960,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glSampleMaski: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glSampleMaski\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glSampleMaski(maskNumber:%u mask:0x%08x )", stream, var_maskNumber, var_mask);
this->glSampleMaski(var_maskNumber, var_mask);
SET_LASTCALL("glSampleMaski");
android::base::endTrace();
@@ -6951,6 +8983,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_val(&tmpBuf[0], size_val);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetMultisamplefv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetMultisamplefv(pname:0x%08x index:%u val:%p(%u) )", stream, var_pname, var_index, (GLfloat*)(outptr_val.get()), size_val);
this->glGetMultisamplefv(var_pname, var_index, (GLfloat*)(outptr_val.get()));
outptr_val.flush();
if (useChecksum) {
@@ -6970,6 +9007,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFramebufferParameteri: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFramebufferParameteri\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFramebufferParameteri(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
this->glFramebufferParameteri(var_target, var_pname, var_param);
SET_LASTCALL("glFramebufferParameteri");
android::base::endTrace();
@@ -6988,6 +9030,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetFramebufferParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetFramebufferParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetFramebufferParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -7012,6 +9059,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetTexLevelParameterfv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetTexLevelParameterfv(target:0x%08x level:%d pname:0x%08x params:%p(%u) )", stream, var_target, var_level, var_pname, (GLfloat*)(outptr_params.get()), size_params);
this->glGetTexLevelParameterfv(var_target, var_level, var_pname, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -7036,6 +9088,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetTexLevelParameteriv\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetTexLevelParameteriv(target:0x%08x level:%d pname:0x%08x params:%p(%u) )", stream, var_target, var_level, var_pname, (GLint*)(outptr_params.get()), size_params);
this->glGetTexLevelParameteriv(var_target, var_level, var_pname, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -7057,6 +9114,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 8, ptr + 8 + 4 + 4 + 4 + 4 + 8, checksumSize,
"gles2_decoder_context_t::decode, OP_glMapBufferRangeDMA: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMapBufferRangeDMA\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMapBufferRangeDMA(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x paddr:0x%016lx )", stream, var_target, var_offset, var_length, var_access, var_paddr);
this->glMapBufferRangeDMA(this, var_target, var_offset, var_length, var_access, var_paddr);
SET_LASTCALL("glMapBufferRangeDMA");
android::base::endTrace();
@@ -7078,6 +9140,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_out_res(&tmpBuf[0], size_out_res);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUnmapBufferDMA\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUnmapBufferDMA(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x paddr:0x%016lx out_res:%p(%u) )", stream, var_target, var_offset, var_length, var_access, var_paddr, (GLboolean*)(outptr_out_res.get()), size_out_res);
this->glUnmapBufferDMA(this, var_target, var_offset, var_length, var_access, var_paddr, (GLboolean*)(outptr_out_res.get()));
outptr_out_res.flush();
if (useChecksum) {
@@ -7102,6 +9169,11 @@
size_t totalTmpSize = sizeof(uint64_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glMapBufferRangeDirect\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glMapBufferRangeDirect(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x paddr:0x%016lx )", stream, var_target, var_offset, var_length, var_access, var_paddr);
*(uint64_t *)(&tmpBuf[0]) = this->glMapBufferRangeDirect(this, var_target, var_offset, var_length, var_access, var_paddr);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -7128,6 +9200,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_out_res(&tmpBuf[0], size_out_res);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUnmapBufferDirect\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUnmapBufferDirect(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x paddr:0x%016lx guest_ptr:0x%016lx out_res:%p(%u) )", stream, var_target, var_offset, var_length, var_access, var_paddr, var_guest_ptr, (GLboolean*)(outptr_out_res.get()), size_out_res);
this->glUnmapBufferDirect(this, var_target, var_offset, var_length, var_access, var_paddr, var_guest_ptr, (GLboolean*)(outptr_out_res.get()));
outptr_out_res.flush();
if (useChecksum) {
@@ -7148,6 +9225,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glFlushMappedBufferRangeDirect: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFlushMappedBufferRangeDirect\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFlushMappedBufferRangeDirect(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x )", stream, var_target, var_offset, var_length, var_access);
this->glFlushMappedBufferRangeDirect(this, var_target, var_offset, var_length, var_access);
SET_LASTCALL("glFlushMappedBufferRangeDirect");
android::base::endTrace();
@@ -7162,6 +9244,11 @@
size_t totalTmpSize = sizeof(GLenum);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetGraphicsResetStatusEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetGraphicsResetStatusEXT()", stream);
*(GLenum *)(&tmpBuf[0]) = this->glGetGraphicsResetStatusEXT();
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -7189,6 +9276,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_data(&tmpBuf[0], size_data);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glReadnPixelsEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glReadnPixelsEXT(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x bufSize:%d data:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()), size_data);
this->glReadnPixelsEXT(var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()));
outptr_data.flush();
if (useChecksum) {
@@ -7213,6 +9305,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetnUniformfvEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetnUniformfvEXT(program:%u location:%d bufSize:%d params:%p(%u) )", stream, var_program, var_location, var_bufSize, (GLfloat*)(outptr_params.get()), size_params);
this->glGetnUniformfvEXT(var_program, var_location, var_bufSize, (GLfloat*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -7237,6 +9334,11 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_params(&tmpBuf[0], size_params);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glGetnUniformivEXT\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glGetnUniformivEXT(program:%u location:%d bufSize:%d params:%p(%u) )", stream, var_program, var_location, var_bufSize, (GLint*)(outptr_params.get()), size_params);
this->glGetnUniformivEXT(var_program, var_location, var_bufSize, (GLint*)(outptr_params.get()));
outptr_params.flush();
if (useChecksum) {
@@ -7256,6 +9358,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawArraysNullAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawArraysNullAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawArraysNullAEMU(mode:0x%08x first:%d count:%d )", stream, var_mode, var_first, var_count);
this->glDrawArraysNullAEMU(var_mode, var_first, var_count);
SET_LASTCALL("glDrawArraysNullAEMU");
android::base::endTrace();
@@ -7272,6 +9379,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_indices, ptr + 8 + 4 + 4 + 4 + 4 + size_indices, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsNullAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsNullAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsNullAEMU(mode:0x%08x count:%d type:0x%08x indices:%p(%u) )", stream, var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()), size_indices);
this->glDrawElementsNullAEMU(var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()));
SET_LASTCALL("glDrawElementsNullAEMU");
android::base::endTrace();
@@ -7287,6 +9399,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsOffsetNullAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsOffsetNullAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsOffsetNullAEMU(mode:0x%08x count:%d type:0x%08x offset:%u )", stream, var_mode, var_count, var_type, var_offset);
this->glDrawElementsOffsetNullAEMU(this, var_mode, var_count, var_type, var_offset);
SET_LASTCALL("glDrawElementsOffsetNullAEMU");
android::base::endTrace();
@@ -7304,6 +9421,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
"gles2_decoder_context_t::decode, OP_glDrawElementsDataNullAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glDrawElementsDataNullAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glDrawElementsDataNullAEMU(mode:0x%08x count:%d type:0x%08x data:%p(%u) datalen:%u )", stream, var_mode, var_count, var_type, (void*)(inptr_data.get()), size_data, var_datalen);
this->glDrawElementsDataNullAEMU(this, var_mode, var_count, var_type, (void*)(inptr_data.get()), var_datalen);
SET_LASTCALL("glDrawElementsDataNullAEMU");
android::base::endTrace();
@@ -7323,6 +9445,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_guest_buffer + 4 + size_out_res, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_guest_buffer + 4 + size_out_res, checksumSize,
"gles2_decoder_context_t::decode, OP_glUnmapBufferAsyncAEMU: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glUnmapBufferAsyncAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glUnmapBufferAsyncAEMU(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x guest_buffer:%p(%u) out_res:%p(%u) )", stream, var_target, var_offset, var_length, var_access, (void*)(inptr_guest_buffer.get()), size_guest_buffer, (GLboolean*)(inptr_out_res.get()), size_out_res);
this->glUnmapBufferAEMU(this, var_target, var_offset, var_length, var_access, size_guest_buffer == 0 ? nullptr : (void*)(inptr_guest_buffer.get()), (GLboolean*)(inptr_out_res.get()));
SET_LASTCALL("glUnmapBufferAsyncAEMU");
android::base::endTrace();
@@ -7340,6 +9467,11 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_guest_buffer, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_guest_buffer, checksumSize,
"gles2_decoder_context_t::decode, OP_glFlushMappedBufferRangeAEMU2: GL checksumCalculator failure\n");
}
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glFlushMappedBufferRangeAEMU2\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glFlushMappedBufferRangeAEMU2(target:0x%08x offset:0x%08lx length:0x%08lx access:0x%08x guest_buffer:%p(%u) )", stream, var_target, var_offset, var_length, var_access, (void*)(inptr_guest_buffer.get()), size_guest_buffer);
this->glFlushMappedBufferRangeAEMU(this, var_target, var_offset, var_length, var_access, size_guest_buffer == 0 ? nullptr : (void*)(inptr_guest_buffer.get()));
SET_LASTCALL("glFlushMappedBufferRangeAEMU2");
android::base::endTrace();
@@ -7359,6 +9491,11 @@
size_t totalTmpSize = sizeof(GLboolean);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ #ifdef CHECK_GL_ERRORS
+ GLint err = this->glGetError();
+ if (err) fprintf(stderr, "gles2 Error (pre-call): 0x%X before glBufferDataSyncAEMU\n", err);
+ #endif
+ DECODER_DEBUG_LOG("gles2(%p): glBufferDataSyncAEMU(target:0x%08x size:0x%08lx data:%p(%u) usage:0x%08x )", stream, var_target, var_size, (const GLvoid*)(inptr_data.get()), size_data, var_usage);
*(GLboolean *)(&tmpBuf[0]) = this->glBufferDataSyncAEMU(this, var_target, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()), var_usage);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
diff --git a/stream-servers/renderControl_dec/renderControl_dec.cpp b/stream-servers/renderControl_dec/renderControl_dec.cpp
index 5be63db..bec187f 100644
--- a/stream-servers/renderControl_dec/renderControl_dec.cpp
+++ b/stream-servers/renderControl_dec/renderControl_dec.cpp
@@ -12,6 +12,8 @@
#include "ChecksumCalculatorThreadInfo.h"
+#include "host-common/logging.h"
+
#include <stdio.h>
typedef unsigned int tsize_t; // Target "size_t", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled.
@@ -48,6 +50,7 @@
size_t totalTmpSize = sizeof(GLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetRendererVersion()", stream);
*(GLint *)(&tmpBuf[0]) = this->rcGetRendererVersion();
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -72,6 +75,7 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_major(&tmpBuf[0], size_major);
OutputBuffer outptr_minor(&tmpBuf[0 + size_major], size_minor);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetEGLVersion(major:%p(%u) minor:%p(%u) )", stream, (EGLint*)(outptr_major.get()), size_major, (EGLint*)(outptr_minor.get()), size_minor);
*(EGLint *)(&tmpBuf[0 + size_major + size_minor]) = this->rcGetEGLVersion((EGLint*)(outptr_major.get()), (EGLint*)(outptr_minor.get()));
outptr_major.flush();
outptr_minor.flush();
@@ -97,6 +101,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_buffer(&tmpBuf[0], size_buffer);
+ DECODER_DEBUG_LOG("renderControl(%p): rcQueryEGLString(name:0x%08x buffer:%p(%u) bufferSize:0x%08x )", stream, var_name, (void*)(outptr_buffer.get()), size_buffer, var_bufferSize);
*(EGLint *)(&tmpBuf[0 + size_buffer]) = this->rcQueryEGLString(var_name, (void*)(outptr_buffer.get()), var_bufferSize);
outptr_buffer.flush();
if (useChecksum) {
@@ -121,6 +126,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_buffer(&tmpBuf[0], size_buffer);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetGLString(name:0x%08x buffer:%p(%u) bufferSize:0x%08x )", stream, var_name, (void*)(outptr_buffer.get()), size_buffer, var_bufferSize);
*(EGLint *)(&tmpBuf[0 + size_buffer]) = this->rcGetGLString(var_name, (void*)(outptr_buffer.get()), var_bufferSize);
outptr_buffer.flush();
if (useChecksum) {
@@ -143,6 +149,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_numAttribs(&tmpBuf[0], size_numAttribs);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetNumConfigs(numAttribs:%p(%u) )", stream, (uint32_t*)(outptr_numAttribs.get()), size_numAttribs);
*(EGLint *)(&tmpBuf[0 + size_numAttribs]) = this->rcGetNumConfigs((uint32_t*)(outptr_numAttribs.get()));
outptr_numAttribs.flush();
if (useChecksum) {
@@ -166,6 +173,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_buffer(&tmpBuf[0], size_buffer);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetConfigs(bufSize:0x%08x buffer:%p(%u) )", stream, var_bufSize, (GLuint*)(outptr_buffer.get()), size_buffer);
*(EGLint *)(&tmpBuf[0 + size_buffer]) = this->rcGetConfigs(var_bufSize, (GLuint*)(outptr_buffer.get()));
outptr_buffer.flush();
if (useChecksum) {
@@ -192,6 +200,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_configs(&tmpBuf[0], size_configs);
+ DECODER_DEBUG_LOG("renderControl(%p): rcChooseConfig(attribs:%p(%u) attribs_size:0x%08x configs:%p(%u) configs_size:0x%08x )", stream, (EGLint*)(inptr_attribs.get()), size_attribs, var_attribs_size, (uint32_t*)(outptr_configs.get()), size_configs, var_configs_size);
*(EGLint *)(&tmpBuf[0 + size_configs]) = this->rcChooseConfig((EGLint*)(inptr_attribs.get()), var_attribs_size, size_configs == 0 ? nullptr : (uint32_t*)(outptr_configs.get()), var_configs_size);
outptr_configs.flush();
if (useChecksum) {
@@ -212,6 +221,7 @@
size_t totalTmpSize = sizeof(EGLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetFBParam(param:0x%08x )", stream, var_param);
*(EGLint *)(&tmpBuf[0]) = this->rcGetFBParam(var_param);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -233,6 +243,7 @@
size_t totalTmpSize = sizeof(uint32_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateContext(config:0x%08x share:0x%08x glVersion:0x%08x )", stream, var_config, var_share, var_glVersion);
*(uint32_t *)(&tmpBuf[0]) = this->rcCreateContext(var_config, var_share, var_glVersion);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -249,6 +260,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcDestroyContext: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcDestroyContext(context:0x%08x )", stream, var_context);
this->rcDestroyContext(var_context);
SET_LASTCALL("rcDestroyContext");
android::base::endTrace();
@@ -266,6 +278,7 @@
size_t totalTmpSize = sizeof(uint32_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateWindowSurface(config:0x%08x width:0x%08x height:0x%08x )", stream, var_config, var_width, var_height);
*(uint32_t *)(&tmpBuf[0]) = this->rcCreateWindowSurface(var_config, var_width, var_height);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -282,6 +295,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcDestroyWindowSurface: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcDestroyWindowSurface(windowSurface:0x%08x )", stream, var_windowSurface);
this->rcDestroyWindowSurface(var_windowSurface);
SET_LASTCALL("rcDestroyWindowSurface");
android::base::endTrace();
@@ -299,6 +313,7 @@
size_t totalTmpSize = sizeof(uint32_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateColorBuffer(width:0x%08x height:0x%08x internalFormat:0x%08x )", stream, var_width, var_height, var_internalFormat);
*(uint32_t *)(&tmpBuf[0]) = this->rcCreateColorBuffer(var_width, var_height, var_internalFormat);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -315,6 +330,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcOpenColorBuffer: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcOpenColorBuffer(colorbuffer:0x%08x )", stream, var_colorbuffer);
this->rcOpenColorBuffer(var_colorbuffer);
SET_LASTCALL("rcOpenColorBuffer");
android::base::endTrace();
@@ -327,6 +343,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcCloseColorBuffer: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcCloseColorBuffer(colorbuffer:0x%08x )", stream, var_colorbuffer);
this->rcCloseColorBuffer(var_colorbuffer);
SET_LASTCALL("rcCloseColorBuffer");
android::base::endTrace();
@@ -340,6 +357,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcSetWindowColorBuffer: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetWindowColorBuffer(windowSurface:0x%08x colorBuffer:0x%08x )", stream, var_windowSurface, var_colorBuffer);
this->rcSetWindowColorBuffer(var_windowSurface, var_colorBuffer);
SET_LASTCALL("rcSetWindowColorBuffer");
android::base::endTrace();
@@ -355,6 +373,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcFlushWindowColorBuffer(windowSurface:0x%08x )", stream, var_windowSurface);
*(int *)(&tmpBuf[0]) = this->rcFlushWindowColorBuffer(var_windowSurface);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -376,6 +395,7 @@
size_t totalTmpSize = sizeof(EGLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcMakeCurrent(context:0x%08x drawSurf:0x%08x readSurf:0x%08x )", stream, var_context, var_drawSurf, var_readSurf);
*(EGLint *)(&tmpBuf[0]) = this->rcMakeCurrent(var_context, var_drawSurf, var_readSurf);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -392,6 +412,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcFBPost: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcFBPost(colorBuffer:0x%08x )", stream, var_colorBuffer);
this->rcFBPost(var_colorBuffer);
SET_LASTCALL("rcFBPost");
android::base::endTrace();
@@ -404,6 +425,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcFBSetSwapInterval: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcFBSetSwapInterval(interval:0x%08x )", stream, var_interval);
this->rcFBSetSwapInterval(var_interval);
SET_LASTCALL("rcFBSetSwapInterval");
android::base::endTrace();
@@ -416,6 +438,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcBindTexture: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcBindTexture(colorBuffer:0x%08x )", stream, var_colorBuffer);
this->rcBindTexture(var_colorBuffer);
SET_LASTCALL("rcBindTexture");
android::base::endTrace();
@@ -428,6 +451,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcBindRenderbuffer: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcBindRenderbuffer(colorBuffer:0x%08x )", stream, var_colorBuffer);
this->rcBindRenderbuffer(var_colorBuffer);
SET_LASTCALL("rcBindRenderbuffer");
android::base::endTrace();
@@ -445,6 +469,7 @@
size_t totalTmpSize = sizeof(EGLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcColorBufferCacheFlush(colorbuffer:0x%08x postCount:0x%08x forRead:%d )", stream, var_colorbuffer, var_postCount, var_forRead);
*(EGLint *)(&tmpBuf[0]) = this->rcColorBufferCacheFlush(var_colorbuffer, var_postCount, var_forRead);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -472,6 +497,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels);
+ DECODER_DEBUG_LOG("renderControl(%p): rcReadColorBuffer(colorbuffer:0x%08x x:0x%08x y:0x%08x width:0x%08x height:0x%08x format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, (void*)(outptr_pixels.get()), size_pixels);
this->rcReadColorBuffer(var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, (void*)(outptr_pixels.get()));
outptr_pixels.flush();
if (useChecksum) {
@@ -500,6 +526,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcUpdateColorBuffer(colorbuffer:0x%08x x:0x%08x y:0x%08x width:0x%08x height:0x%08x format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, (void*)(inptr_pixels.get()), size_pixels);
*(int *)(&tmpBuf[0]) = this->rcUpdateColorBuffer(var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, (void*)(inptr_pixels.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -519,6 +546,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcOpenColorBuffer2(colorbuffer:0x%08x )", stream, var_colorbuffer);
*(int *)(&tmpBuf[0]) = this->rcOpenColorBuffer2(var_colorbuffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -540,6 +568,7 @@
size_t totalTmpSize = sizeof(uint32_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateClientImage(context:0x%08x target:0x%08x buffer:0x%08x )", stream, var_context, var_target, var_buffer);
*(uint32_t *)(&tmpBuf[0]) = this->rcCreateClientImage(var_context, var_target, var_buffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -559,6 +588,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcDestroyClientImage(image:0x%08x )", stream, var_image);
*(int *)(&tmpBuf[0]) = this->rcDestroyClientImage(var_image);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -576,6 +606,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcSelectChecksumHelper: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcSelectChecksumHelper(newProtocol:0x%08x reserved:0x%08x )", stream, var_newProtocol, var_reserved);
this->rcSelectChecksumHelper(var_newProtocol, var_reserved);
SET_LASTCALL("rcSelectChecksumHelper");
android::base::endTrace();
@@ -600,6 +631,7 @@
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_glsync_out(&tmpBuf[0], size_glsync_out);
OutputBuffer outptr_syncthread_out(&tmpBuf[0 + size_glsync_out], size_syncthread_out);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateSyncKHR(type:0x%08x attribs:%p(%u) num_attribs:0x%08x destroy_when_signaled:%d glsync_out:%p(%u) syncthread_out:%p(%u) )", stream, var_type, (EGLint*)(inptr_attribs.get()), size_attribs, var_num_attribs, var_destroy_when_signaled, (uint64_t*)(outptr_glsync_out.get()), size_glsync_out, (uint64_t*)(outptr_syncthread_out.get()), size_syncthread_out);
this->rcCreateSyncKHR(var_type, (EGLint*)(inptr_attribs.get()), var_num_attribs, var_destroy_when_signaled, (uint64_t*)(outptr_glsync_out.get()), (uint64_t*)(outptr_syncthread_out.get()));
outptr_glsync_out.flush();
outptr_syncthread_out.flush();
@@ -623,6 +655,7 @@
size_t totalTmpSize = sizeof(EGLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcClientWaitSyncKHR(sync:0x%016lx flags:0x%08x timeout:0x%016lx )", stream, var_sync, var_flags, var_timeout);
*(EGLint *)(&tmpBuf[0]) = this->rcClientWaitSyncKHR(var_sync, var_flags, var_timeout);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -639,6 +672,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcFlushWindowColorBufferAsync: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcFlushWindowColorBufferAsync(windowSurface:0x%08x )", stream, var_windowSurface);
this->rcFlushWindowColorBufferAsync(var_windowSurface);
SET_LASTCALL("rcFlushWindowColorBufferAsync");
android::base::endTrace();
@@ -654,6 +688,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcDestroySyncKHR(sync:0x%016lx )", stream, var_sync);
*(int *)(&tmpBuf[0]) = this->rcDestroySyncKHR(var_sync);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -670,6 +705,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcSetPuid: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetPuid(puid:0x%016lx )", stream, var_puid);
this->rcSetPuid(var_puid);
SET_LASTCALL("rcSetPuid");
android::base::endTrace();
@@ -695,6 +731,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcUpdateColorBufferDMA(colorbuffer:0x%08x x:0x%08x y:0x%08x width:0x%08x height:0x%08x format:0x%08x type:0x%08x pixels:%p(%u) pixels_size:0x%08x )", stream, var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, var_pixels, var_pixels_size);
*(int *)(&tmpBuf[0]) = this->rcUpdateColorBufferDMA(var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, var_pixels, var_pixels_size);
stream->unlockDma(var_pixels_guest_paddr);
if (useChecksum) {
@@ -718,6 +755,7 @@
size_t totalTmpSize = sizeof(uint32_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateColorBufferDMA(width:0x%08x height:0x%08x internalFormat:0x%08x frameworkFormat:%d )", stream, var_width, var_height, var_internalFormat, var_frameworkFormat);
*(uint32_t *)(&tmpBuf[0]) = this->rcCreateColorBufferDMA(var_width, var_height, var_internalFormat, var_frameworkFormat);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -735,6 +773,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcWaitSyncKHR: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcWaitSyncKHR(sync:0x%016lx flags:0x%08x )", stream, var_sync, var_flags);
this->rcWaitSyncKHR(var_sync, var_flags);
SET_LASTCALL("rcWaitSyncKHR");
android::base::endTrace();
@@ -752,6 +791,7 @@
size_t totalTmpSize = sizeof(GLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCompose(bufferSize:0x%08x buffer:%p(%u) )", stream, var_bufferSize, (void*)(inptr_buffer.get()), size_buffer);
*(GLint *)(&tmpBuf[0]) = this->rcCompose(var_bufferSize, (void*)(inptr_buffer.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -773,6 +813,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_displayId(&tmpBuf[0], size_displayId);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateDisplay(displayId:%p(%u) )", stream, (uint32_t*)(outptr_displayId.get()), size_displayId);
*(int *)(&tmpBuf[0 + size_displayId]) = this->rcCreateDisplay((uint32_t*)(outptr_displayId.get()));
outptr_displayId.flush();
if (useChecksum) {
@@ -793,6 +834,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcDestroyDisplay(displayId:0x%08x )", stream, var_displayId);
*(int *)(&tmpBuf[0]) = this->rcDestroyDisplay(var_displayId);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -813,6 +855,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetDisplayColorBuffer(displayId:0x%08x colorBuffer:0x%08x )", stream, var_displayId, var_colorBuffer);
*(int *)(&tmpBuf[0]) = this->rcSetDisplayColorBuffer(var_displayId, var_colorBuffer);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -835,6 +878,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_colorBuffer(&tmpBuf[0], size_colorBuffer);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetDisplayColorBuffer(displayId:0x%08x colorBuffer:%p(%u) )", stream, var_displayId, (uint32_t*)(outptr_colorBuffer.get()), size_colorBuffer);
*(int *)(&tmpBuf[0 + size_colorBuffer]) = this->rcGetDisplayColorBuffer(var_displayId, (uint32_t*)(outptr_colorBuffer.get()));
outptr_colorBuffer.flush();
if (useChecksum) {
@@ -858,6 +902,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_displayId(&tmpBuf[0], size_displayId);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetColorBufferDisplay(colorBuffer:0x%08x displayId:%p(%u) )", stream, var_colorBuffer, (uint32_t*)(outptr_displayId.get()), size_displayId);
*(int *)(&tmpBuf[0 + size_displayId]) = this->rcGetColorBufferDisplay(var_colorBuffer, (uint32_t*)(outptr_displayId.get()));
outptr_displayId.flush();
if (useChecksum) {
@@ -890,6 +935,7 @@
OutputBuffer outptr_y(&tmpBuf[0 + size_x], size_y);
OutputBuffer outptr_w(&tmpBuf[0 + size_x + size_y], size_w);
OutputBuffer outptr_h(&tmpBuf[0 + size_x + size_y + size_w], size_h);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetDisplayPose(displayId:0x%08x x:%p(%u) y:%p(%u) w:%p(%u) h:%p(%u) )", stream, var_displayId, (GLint*)(outptr_x.get()), size_x, (GLint*)(outptr_y.get()), size_y, (uint32_t*)(outptr_w.get()), size_w, (uint32_t*)(outptr_h.get()), size_h);
*(int *)(&tmpBuf[0 + size_x + size_y + size_w + size_h]) = this->rcGetDisplayPose(var_displayId, (GLint*)(outptr_x.get()), (GLint*)(outptr_y.get()), (uint32_t*)(outptr_w.get()), (uint32_t*)(outptr_h.get()));
outptr_x.flush();
outptr_y.flush();
@@ -917,6 +963,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetDisplayPose(displayId:0x%08x x:0x%08x y:0x%08x w:0x%08x h:0x%08x )", stream, var_displayId, var_x, var_y, var_w, var_h);
*(int *)(&tmpBuf[0]) = this->rcSetDisplayPose(var_displayId, var_x, var_y, var_w, var_h);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -937,6 +984,7 @@
size_t totalTmpSize = sizeof(GLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetColorBufferVulkanMode(colorBuffer:0x%08x mode:0x%08x )", stream, var_colorBuffer, var_mode);
*(GLint *)(&tmpBuf[0]) = this->rcSetColorBufferVulkanMode(var_colorBuffer, var_mode);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -963,6 +1011,7 @@
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels);
+ DECODER_DEBUG_LOG("renderControl(%p): rcReadColorBufferYUV(colorbuffer:0x%08x x:0x%08x y:0x%08x width:0x%08x height:0x%08x pixels:%p(%u) pixels_size:0x%08x )", stream, var_colorbuffer, var_x, var_y, var_width, var_height, (void*)(outptr_pixels.get()), size_pixels, var_pixels_size);
this->rcReadColorBufferYUV(var_colorbuffer, var_x, var_y, var_width, var_height, (void*)(outptr_pixels.get()), var_pixels_size);
outptr_pixels.flush();
if (useChecksum) {
@@ -983,6 +1032,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcIsSyncSignaled(sync:0x%016lx )", stream, var_sync);
*(int *)(&tmpBuf[0]) = this->rcIsSyncSignaled(var_sync);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1002,6 +1052,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcCreateColorBufferWithHandle: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateColorBufferWithHandle(width:0x%08x height:0x%08x internalFormat:0x%08x handle:0x%08x )", stream, var_width, var_height, var_internalFormat, var_handle);
this->rcCreateColorBufferWithHandle(var_width, var_height, var_internalFormat, var_handle);
SET_LASTCALL("rcCreateColorBufferWithHandle");
android::base::endTrace();
@@ -1017,6 +1068,7 @@
size_t totalTmpSize = sizeof(uint32_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateBuffer(size:0x%08x )", stream, var_size);
*(uint32_t *)(&tmpBuf[0]) = this->rcCreateBuffer(var_size);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1033,6 +1085,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcCloseBuffer: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcCloseBuffer(buffer:0x%08x )", stream, var_buffer);
this->rcCloseBuffer(var_buffer);
SET_LASTCALL("rcCloseBuffer");
android::base::endTrace();
@@ -1050,6 +1103,7 @@
size_t totalTmpSize = sizeof(GLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetColorBufferVulkanMode2(colorBuffer:0x%08x mode:0x%08x memoryProperty:0x%08x )", stream, var_colorBuffer, var_mode, var_memoryProperty);
*(GLint *)(&tmpBuf[0]) = this->rcSetColorBufferVulkanMode2(var_colorBuffer, var_mode, var_memoryProperty);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1070,6 +1124,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcMapGpaToBufferHandle(bufferHandle:0x%08x gpa:0x%016lx )", stream, var_bufferHandle, var_gpa);
*(int *)(&tmpBuf[0]) = this->rcMapGpaToBufferHandle(var_bufferHandle, var_gpa);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1090,6 +1145,7 @@
size_t totalTmpSize = sizeof(uint32_t);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateBuffer2(size:0x%016lx memoryProperty:0x%08x )", stream, var_size, var_memoryProperty);
*(uint32_t *)(&tmpBuf[0]) = this->rcCreateBuffer2(var_size, var_memoryProperty);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1111,6 +1167,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcMapGpaToBufferHandle2(bufferHandle:0x%08x gpa:0x%016lx size:0x%016lx )", stream, var_bufferHandle, var_gpa, var_size);
*(int *)(&tmpBuf[0]) = this->rcMapGpaToBufferHandle2(var_bufferHandle, var_gpa, var_size);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1128,6 +1185,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcFlushWindowColorBufferAsyncWithFrameNumber: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcFlushWindowColorBufferAsyncWithFrameNumber(windowSurface:0x%08x frameNumber:0x%08x )", stream, var_windowSurface, var_frameNumber);
this->rcFlushWindowColorBufferAsyncWithFrameNumber(var_windowSurface, var_frameNumber);
SET_LASTCALL("rcFlushWindowColorBufferAsyncWithFrameNumber");
android::base::endTrace();
@@ -1142,6 +1200,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8, ptr + 8 + 8 + 4 + 8, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcSetTracingForPuid: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetTracingForPuid(puid:0x%016lx enable:0x%08x guestTime:0x%016lx )", stream, var_puid, var_enable, var_guestTime);
this->rcSetTracingForPuid(var_puid, var_enable, var_guestTime);
SET_LASTCALL("rcSetTracingForPuid");
android::base::endTrace();
@@ -1156,6 +1215,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcMakeCurrentAsync: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcMakeCurrentAsync(context:0x%08x drawSurf:0x%08x readSurf:0x%08x )", stream, var_context, var_drawSurf, var_readSurf);
this->rcMakeCurrentAsync(var_context, var_drawSurf, var_readSurf);
SET_LASTCALL("rcMakeCurrentAsync");
android::base::endTrace();
@@ -1170,6 +1230,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_buffer, ptr + 8 + 4 + 4 + size_buffer, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcComposeAsync: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcComposeAsync(bufferSize:0x%08x buffer:%p(%u) )", stream, var_bufferSize, (void*)(inptr_buffer.get()), size_buffer);
this->rcComposeAsync(var_bufferSize, (void*)(inptr_buffer.get()));
SET_LASTCALL("rcComposeAsync");
android::base::endTrace();
@@ -1182,6 +1243,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcDestroySyncKHRAsync: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcDestroySyncKHRAsync(sync:0x%016lx )", stream, var_sync);
this->rcDestroySyncKHRAsync(var_sync);
SET_LASTCALL("rcDestroySyncKHRAsync");
android::base::endTrace();
@@ -1199,6 +1261,7 @@
size_t totalTmpSize = sizeof(GLint);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcComposeWithoutPost(bufferSize:0x%08x buffer:%p(%u) )", stream, var_bufferSize, (void*)(inptr_buffer.get()), size_buffer);
*(GLint *)(&tmpBuf[0]) = this->rcComposeWithoutPost(var_bufferSize, (void*)(inptr_buffer.get()));
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1217,6 +1280,7 @@
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_buffer, ptr + 8 + 4 + 4 + size_buffer, checksumSize,
"renderControl_decoder_context_t::decode, OP_rcComposeAsyncWithoutPost: GL checksumCalculator failure\n");
}
+ DECODER_DEBUG_LOG("renderControl(%p): rcComposeAsyncWithoutPost(bufferSize:0x%08x buffer:%p(%u) )", stream, var_bufferSize, (void*)(inptr_buffer.get()), size_buffer);
this->rcComposeAsyncWithoutPost(var_bufferSize, (void*)(inptr_buffer.get()));
SET_LASTCALL("rcComposeAsyncWithoutPost");
android::base::endTrace();
@@ -1232,6 +1296,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcCreateDisplayById(displayId:0x%08x )", stream, var_displayId);
*(int *)(&tmpBuf[0]) = this->rcCreateDisplayById(var_displayId);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1256,6 +1321,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcSetDisplayPoseDpi(displayId:0x%08x x:0x%08x y:0x%08x w:0x%08x h:0x%08x dpi:0x%08x )", stream, var_displayId, var_x, var_y, var_w, var_h, var_dpi);
*(int *)(&tmpBuf[0]) = this->rcSetDisplayPoseDpi(var_displayId, var_x, var_y, var_w, var_h, var_dpi);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1285,6 +1351,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcReadColorBufferDMA(colorbuffer:0x%08x x:0x%08x y:0x%08x width:0x%08x height:0x%08x format:0x%08x type:0x%08x pixels:%p(%u) pixels_size:0x%08x )", stream, var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, var_pixels, var_pixels_size);
*(int *)(&tmpBuf[0]) = this->rcReadColorBufferDMA(var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, var_pixels, var_pixels_size);
stream->unlockDma(var_pixels_guest_paddr);
if (useChecksum) {
@@ -1304,6 +1371,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetFBDisplayConfigsCount()", stream);
*(int *)(&tmpBuf[0]) = this->rcGetFBDisplayConfigsCount();
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1324,6 +1392,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetFBDisplayConfigsParam(configId:%d param:0x%08x )", stream, var_configId, var_param);
*(int *)(&tmpBuf[0]) = this->rcGetFBDisplayConfigsParam(var_configId, var_param);
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
@@ -1342,6 +1411,7 @@
size_t totalTmpSize = sizeof(int);
totalTmpSize += checksumSize;
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
+ DECODER_DEBUG_LOG("renderControl(%p): rcGetFBDisplayActiveConfig()", stream);
*(int *)(&tmpBuf[0]) = this->rcGetFBDisplayActiveConfig();
if (useChecksum) {
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
