You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4721 lines
224 KiB
4721 lines
224 KiB
// Generated Code - DO NOT EDIT !!
|
|
// generated by 'emugen'
|
|
|
|
|
|
#include <string.h>
|
|
#include "gles1_opcodes.h"
|
|
|
|
#include "gles1_dec.h"
|
|
|
|
|
|
#include "ProtocolUtils.h"
|
|
|
|
#include "ChecksumCalculatorThreadInfo.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.
|
|
|
|
#ifdef CHECK_GL_ERRORS
|
|
# define SET_LASTCALL(name) sprintf(lastCall, #name)
|
|
#else
|
|
# define SET_LASTCALL(name)
|
|
#endif
|
|
using namespace emugl;
|
|
|
|
size_t gles1_decoder_context_t::decode(void *buf, size_t len, IOStream *stream, ChecksumCalculator* checksumCalc) {
|
|
if (len < 8) return 0;
|
|
#ifdef CHECK_GL_ERRORS
|
|
char lastCall[256] = {0};
|
|
#endif
|
|
unsigned char *ptr = (unsigned char *)buf;
|
|
const unsigned char* const end = (const unsigned char*)buf + len;
|
|
const size_t checksumSize = checksumCalc->checksumByteSize();
|
|
const bool useChecksum = checksumSize > 0;
|
|
while (end - ptr >= 8) {
|
|
uint32_t opcode = *(uint32_t *)ptr;
|
|
int32_t packetLen = *(int32_t *)(ptr + 4);
|
|
if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
|
|
switch(opcode) {
|
|
case OP_glAlphaFunc: {
|
|
android::base::beginTrace("glAlphaFunc decode");
|
|
GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLclampf var_ref = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glAlphaFunc: GL checksumCalculator failure\n");
|
|
}
|
|
this->glAlphaFunc(var_func, var_ref);
|
|
SET_LASTCALL("glAlphaFunc");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearColor: {
|
|
android::base::beginTrace("glClearColor decode");
|
|
GLclampf var_red = Unpack<GLclampf,uint32_t>(ptr + 8);
|
|
GLclampf var_green = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
|
|
GLclampf var_blue = Unpack<GLclampf,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLclampf var_alpha = Unpack<GLclampf,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClearColor(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glClearColor");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearDepthf: {
|
|
android::base::beginTrace("glClearDepthf decode");
|
|
GLclampf var_depth = Unpack<GLclampf,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glClearDepthf: GL checksumCalculator failure\n");
|
|
}
|
|
this->glClearDepthf(var_depth);
|
|
SET_LASTCALL("glClearDepthf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClipPlanef: {
|
|
android::base::beginTrace("glClipPlanef decode");
|
|
GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClipPlanef(var_plane, (const GLfloat*)(inptr_equation.get()));
|
|
SET_LASTCALL("glClipPlanef");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColor4f: {
|
|
android::base::beginTrace("glColor4f decode");
|
|
GLfloat var_red = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_green = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_blue = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_alpha = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColor4f(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glColor4f");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDepthRangef: {
|
|
android::base::beginTrace("glDepthRangef decode");
|
|
GLclampf var_zNear = Unpack<GLclampf,uint32_t>(ptr + 8);
|
|
GLclampf var_zFar = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDepthRangef: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDepthRangef(var_zNear, var_zFar);
|
|
SET_LASTCALL("glDepthRangef");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFogf: {
|
|
android::base::beginTrace("glFogf decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFogf: GL checksumCalculator failure\n");
|
|
}
|
|
this->glFogf(var_pname, var_param);
|
|
SET_LASTCALL("glFogf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFogfv: {
|
|
android::base::beginTrace("glFogfv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFogfv(var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glFogfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFrustumf: {
|
|
android::base::beginTrace("glFrustumf decode");
|
|
GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFrustumf(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glFrustumf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetClipPlanef: {
|
|
android::base::beginTrace("glGetClipPlanef decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetClipPlanef: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_eqn;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
|
|
this->glGetClipPlanef(var_pname, (GLfloat*)(outptr_eqn.get()));
|
|
outptr_eqn.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetClipPlanef");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetFloatv: {
|
|
android::base::beginTrace("glGetFloatv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetFloatv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetFloatv(var_pname, (GLfloat*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetFloatv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetLightfv: {
|
|
android::base::beginTrace("glGetLightfv decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetLightfv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetLightfv(var_light, var_pname, (GLfloat*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetLightfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetMaterialfv: {
|
|
android::base::beginTrace("glGetMaterialfv decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetMaterialfv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetMaterialfv(var_face, var_pname, (GLfloat*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetMaterialfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexEnvfv: {
|
|
android::base::beginTrace("glGetTexEnvfv decode");
|
|
GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexEnvfv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexEnvfv(var_env, var_pname, (GLfloat*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexEnvfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexParameterfv: {
|
|
android::base::beginTrace("glGetTexParameterfv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexParameterfv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexParameterfv(var_target, var_pname, (GLfloat*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexParameterfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightModelf: {
|
|
android::base::beginTrace("glLightModelf decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLightModelf: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLightModelf(var_pname, var_param);
|
|
SET_LASTCALL("glLightModelf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightModelfv: {
|
|
android::base::beginTrace("glLightModelfv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightModelfv(var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glLightModelfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightf: {
|
|
android::base::beginTrace("glLightf decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightf(var_light, var_pname, var_param);
|
|
SET_LASTCALL("glLightf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightfv: {
|
|
android::base::beginTrace("glLightfv decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightfv(var_light, var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glLightfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLineWidth: {
|
|
android::base::beginTrace("glLineWidth decode");
|
|
GLfloat var_width = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLineWidth: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLineWidth(var_width);
|
|
SET_LASTCALL("glLineWidth");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLoadMatrixf: {
|
|
android::base::beginTrace("glLoadMatrixf decode");
|
|
uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_m(ptr + 8 + 4, size_m);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLoadMatrixf((const GLfloat*)(inptr_m.get()));
|
|
SET_LASTCALL("glLoadMatrixf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMaterialf: {
|
|
android::base::beginTrace("glMaterialf decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMaterialf(var_face, var_pname, var_param);
|
|
SET_LASTCALL("glMaterialf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMaterialfv: {
|
|
android::base::beginTrace("glMaterialfv decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMaterialfv(var_face, var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glMaterialfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultMatrixf: {
|
|
android::base::beginTrace("glMultMatrixf decode");
|
|
uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_m(ptr + 8 + 4, size_m);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultMatrixf((const GLfloat*)(inptr_m.get()));
|
|
SET_LASTCALL("glMultMatrixf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultiTexCoord4f: {
|
|
android::base::beginTrace("glMultiTexCoord4f decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfloat var_s = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_t = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_r = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfloat var_q = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultiTexCoord4f(var_target, var_s, var_t, var_r, var_q);
|
|
SET_LASTCALL("glMultiTexCoord4f");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glNormal3f: {
|
|
android::base::beginTrace("glNormal3f decode");
|
|
GLfloat var_nx = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_ny = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_nz = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glNormal3f(var_nx, var_ny, var_nz);
|
|
SET_LASTCALL("glNormal3f");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glOrthof: {
|
|
android::base::beginTrace("glOrthof decode");
|
|
GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glOrthof(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glOrthof");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointParameterf: {
|
|
android::base::beginTrace("glPointParameterf decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPointParameterf: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPointParameterf(var_pname, var_param);
|
|
SET_LASTCALL("glPointParameterf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointParameterfv: {
|
|
android::base::beginTrace("glPointParameterfv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glPointParameterfv(var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glPointParameterfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointSize: {
|
|
android::base::beginTrace("glPointSize decode");
|
|
GLfloat var_size = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPointSize: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPointSize(var_size);
|
|
SET_LASTCALL("glPointSize");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPolygonOffset: {
|
|
android::base::beginTrace("glPolygonOffset decode");
|
|
GLfloat var_factor = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_units = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPolygonOffset: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPolygonOffset(var_factor, var_units);
|
|
SET_LASTCALL("glPolygonOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glRotatef: {
|
|
android::base::beginTrace("glRotatef decode");
|
|
GLfloat var_angle = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glRotatef(var_angle, var_x, var_y, var_z);
|
|
SET_LASTCALL("glRotatef");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glScalef: {
|
|
android::base::beginTrace("glScalef decode");
|
|
GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glScalef(var_x, var_y, var_z);
|
|
SET_LASTCALL("glScalef");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnvf: {
|
|
android::base::beginTrace("glTexEnvf decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnvf(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexEnvf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnvfv: {
|
|
android::base::beginTrace("glTexEnvfv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnvfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexEnvfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexParameterf: {
|
|
android::base::beginTrace("glTexParameterf decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameterf(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexParameterf");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexParameterfv: {
|
|
android::base::beginTrace("glTexParameterfv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameterfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexParameterfv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTranslatef: {
|
|
android::base::beginTrace("glTranslatef decode");
|
|
GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTranslatef(var_x, var_y, var_z);
|
|
SET_LASTCALL("glTranslatef");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glActiveTexture: {
|
|
android::base::beginTrace("glActiveTexture decode");
|
|
GLenum var_texture = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glActiveTexture: GL checksumCalculator failure\n");
|
|
}
|
|
this->glActiveTexture(var_texture);
|
|
SET_LASTCALL("glActiveTexture");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glAlphaFuncx: {
|
|
android::base::beginTrace("glAlphaFuncx decode");
|
|
GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLclampx var_ref = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glAlphaFuncx: GL checksumCalculator failure\n");
|
|
}
|
|
this->glAlphaFuncx(var_func, var_ref);
|
|
SET_LASTCALL("glAlphaFuncx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBindBuffer: {
|
|
android::base::beginTrace("glBindBuffer decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLuint var_buffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBindBuffer: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBindBuffer(var_target, var_buffer);
|
|
SET_LASTCALL("glBindBuffer");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBindTexture: {
|
|
android::base::beginTrace("glBindTexture decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBindTexture: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBindTexture(var_target, var_texture);
|
|
SET_LASTCALL("glBindTexture");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBlendFunc: {
|
|
android::base::beginTrace("glBlendFunc decode");
|
|
GLenum var_sfactor = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_dfactor = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBlendFunc: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBlendFunc(var_sfactor, var_dfactor);
|
|
SET_LASTCALL("glBlendFunc");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBufferData: {
|
|
android::base::beginTrace("glBufferData decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizeiptr var_size = Unpack<GLsizeiptr,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
|
|
GLenum var_usage = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glBufferData(var_target, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()), var_usage);
|
|
SET_LASTCALL("glBufferData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBufferSubData: {
|
|
android::base::beginTrace("glBufferSubData decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLintptr var_offset = Unpack<GLintptr,uint32_t>(ptr + 8 + 4);
|
|
GLsizeiptr var_size = Unpack<GLsizeiptr,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glBufferSubData(var_target, var_offset, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
|
|
SET_LASTCALL("glBufferSubData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClear: {
|
|
android::base::beginTrace("glClear decode");
|
|
GLbitfield var_mask = Unpack<GLbitfield,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glClear: GL checksumCalculator failure\n");
|
|
}
|
|
this->glClear(var_mask);
|
|
SET_LASTCALL("glClear");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearColorx: {
|
|
android::base::beginTrace("glClearColorx decode");
|
|
GLclampx var_red = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
GLclampx var_green = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
|
|
GLclampx var_blue = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLclampx var_alpha = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClearColorx(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glClearColorx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearDepthx: {
|
|
android::base::beginTrace("glClearDepthx decode");
|
|
GLclampx var_depth = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glClearDepthx: GL checksumCalculator failure\n");
|
|
}
|
|
this->glClearDepthx(var_depth);
|
|
SET_LASTCALL("glClearDepthx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearStencil: {
|
|
android::base::beginTrace("glClearStencil decode");
|
|
GLint var_s = Unpack<GLint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glClearStencil: GL checksumCalculator failure\n");
|
|
}
|
|
this->glClearStencil(var_s);
|
|
SET_LASTCALL("glClearStencil");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClientActiveTexture: {
|
|
android::base::beginTrace("glClientActiveTexture decode");
|
|
GLenum var_texture = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glClientActiveTexture: GL checksumCalculator failure\n");
|
|
}
|
|
this->glClientActiveTexture(var_texture);
|
|
SET_LASTCALL("glClientActiveTexture");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColor4ub: {
|
|
android::base::beginTrace("glColor4ub decode");
|
|
GLubyte var_red = Unpack<GLubyte,uint8_t>(ptr + 8);
|
|
GLubyte var_green = Unpack<GLubyte,uint8_t>(ptr + 8 + 1);
|
|
GLubyte var_blue = Unpack<GLubyte,uint8_t>(ptr + 8 + 1 + 1);
|
|
GLubyte var_alpha = Unpack<GLubyte,uint8_t>(ptr + 8 + 1 + 1 + 1);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColor4ub(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glColor4ub");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColor4x: {
|
|
android::base::beginTrace("glColor4x decode");
|
|
GLfixed var_red = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_green = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_blue = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_alpha = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColor4x(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glColor4x");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColorMask: {
|
|
android::base::beginTrace("glColorMask decode");
|
|
GLboolean var_red = Unpack<GLboolean,uint8_t>(ptr + 8);
|
|
GLboolean var_green = Unpack<GLboolean,uint8_t>(ptr + 8 + 1);
|
|
GLboolean var_blue = Unpack<GLboolean,uint8_t>(ptr + 8 + 1 + 1);
|
|
GLboolean var_alpha = Unpack<GLboolean,uint8_t>(ptr + 8 + 1 + 1 + 1);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColorMask(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glColorMask");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColorPointer: {
|
|
android::base::beginTrace("glColorPointer decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColorPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
|
|
SET_LASTCALL("glColorPointer");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glCompressedTexImage2D: {
|
|
android::base::beginTrace("glCompressedTexImage2D decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_imageSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
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();
|
|
break;
|
|
}
|
|
case OP_glCompressedTexSubImage2D: {
|
|
android::base::beginTrace("glCompressedTexSubImage2D decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_imageSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
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();
|
|
break;
|
|
}
|
|
case OP_glCopyTexImage2D: {
|
|
android::base::beginTrace("glCopyTexImage2D decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glCopyTexImage2D(var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
|
|
SET_LASTCALL("glCopyTexImage2D");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glCopyTexSubImage2D: {
|
|
android::base::beginTrace("glCopyTexSubImage2D decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glCopyTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
|
|
SET_LASTCALL("glCopyTexSubImage2D");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glCullFace: {
|
|
android::base::beginTrace("glCullFace decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glCullFace: GL checksumCalculator failure\n");
|
|
}
|
|
this->glCullFace(var_mode);
|
|
SET_LASTCALL("glCullFace");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDeleteBuffers: {
|
|
android::base::beginTrace("glDeleteBuffers decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_buffers(ptr + 8 + 4 + 4, size_buffers);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDeleteBuffers_dec(this, var_n, (const GLuint*)(inptr_buffers.get()));
|
|
SET_LASTCALL("glDeleteBuffers");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDeleteTextures: {
|
|
android::base::beginTrace("glDeleteTextures decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_textures(ptr + 8 + 4 + 4, size_textures);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDeleteTextures_dec(this, var_n, (const GLuint*)(inptr_textures.get()));
|
|
SET_LASTCALL("glDeleteTextures");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDepthFunc: {
|
|
android::base::beginTrace("glDepthFunc decode");
|
|
GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDepthFunc: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDepthFunc(var_func);
|
|
SET_LASTCALL("glDepthFunc");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDepthMask: {
|
|
android::base::beginTrace("glDepthMask decode");
|
|
GLboolean var_flag = Unpack<GLboolean,uint8_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1, ptr + 8 + 1, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDepthMask: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDepthMask(var_flag);
|
|
SET_LASTCALL("glDepthMask");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDepthRangex: {
|
|
android::base::beginTrace("glDepthRangex decode");
|
|
GLclampx var_zNear = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
GLclampx var_zFar = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDepthRangex: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDepthRangex(var_zNear, var_zFar);
|
|
SET_LASTCALL("glDepthRangex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDisable: {
|
|
android::base::beginTrace("glDisable decode");
|
|
GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDisable: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDisable(var_cap);
|
|
SET_LASTCALL("glDisable");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDisableClientState: {
|
|
android::base::beginTrace("glDisableClientState decode");
|
|
GLenum var_array = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDisableClientState: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDisableClientState(var_array);
|
|
SET_LASTCALL("glDisableClientState");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawArrays: {
|
|
android::base::beginTrace("glDrawArrays decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_first = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawArrays(var_mode, var_first, var_count);
|
|
SET_LASTCALL("glDrawArrays");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawElements: {
|
|
android::base::beginTrace("glDrawElements decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_indices(ptr + 8 + 4 + 4 + 4 + 4, size_indices);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawElements(var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()));
|
|
SET_LASTCALL("glDrawElements");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glEnable: {
|
|
android::base::beginTrace("glEnable decode");
|
|
GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glEnable: GL checksumCalculator failure\n");
|
|
}
|
|
this->glEnable(var_cap);
|
|
SET_LASTCALL("glEnable");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glEnableClientState: {
|
|
android::base::beginTrace("glEnableClientState decode");
|
|
GLenum var_array = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glEnableClientState: GL checksumCalculator failure\n");
|
|
}
|
|
this->glEnableClientState(var_array);
|
|
SET_LASTCALL("glEnableClientState");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFinish: {
|
|
android::base::beginTrace("glFinish decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFinish: GL checksumCalculator failure\n");
|
|
}
|
|
this->glFinish();
|
|
SET_LASTCALL("glFinish");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFlush: {
|
|
android::base::beginTrace("glFlush decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFlush: GL checksumCalculator failure\n");
|
|
}
|
|
this->glFlush();
|
|
SET_LASTCALL("glFlush");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFogx: {
|
|
android::base::beginTrace("glFogx decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFogx: GL checksumCalculator failure\n");
|
|
}
|
|
this->glFogx(var_pname, var_param);
|
|
SET_LASTCALL("glFogx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFogxv: {
|
|
android::base::beginTrace("glFogxv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFogxv(var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glFogxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFrontFace: {
|
|
android::base::beginTrace("glFrontFace decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFrontFace: GL checksumCalculator failure\n");
|
|
}
|
|
this->glFrontFace(var_mode);
|
|
SET_LASTCALL("glFrontFace");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFrustumx: {
|
|
android::base::beginTrace("glFrustumx decode");
|
|
GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFrustumx(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glFrustumx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetBooleanv: {
|
|
android::base::beginTrace("glGetBooleanv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetBooleanv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetBooleanv(var_pname, (GLboolean*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetBooleanv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetBufferParameteriv: {
|
|
android::base::beginTrace("glGetBufferParameteriv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetBufferParameteriv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetBufferParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetBufferParameteriv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClipPlanex: {
|
|
android::base::beginTrace("glClipPlanex decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_eqn(ptr + 8 + 4 + 4, size_eqn);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClipPlanex(var_pname, (const GLfixed*)(inptr_eqn.get()));
|
|
SET_LASTCALL("glClipPlanex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGenBuffers: {
|
|
android::base::beginTrace("glGenBuffers decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGenBuffers: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_buffers;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
|
|
this->glGenBuffers_dec(this, var_n, (GLuint*)(outptr_buffers.get()));
|
|
outptr_buffers.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGenBuffers");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGenTextures: {
|
|
android::base::beginTrace("glGenTextures decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGenTextures: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_textures;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
|
|
this->glGenTextures_dec(this, var_n, (GLuint*)(outptr_textures.get()));
|
|
outptr_textures.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGenTextures");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetError: {
|
|
android::base::beginTrace("glGetError decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetError: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLenum);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLenum *)(&tmpBuf[0]) = this->glGetError();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetError");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetFixedv: {
|
|
android::base::beginTrace("glGetFixedv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetFixedv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetFixedv(var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetFixedv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetIntegerv: {
|
|
android::base::beginTrace("glGetIntegerv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetIntegerv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetIntegerv(var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetIntegerv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetLightxv: {
|
|
android::base::beginTrace("glGetLightxv decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetLightxv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetLightxv(var_light, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetLightxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetMaterialxv: {
|
|
android::base::beginTrace("glGetMaterialxv decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetMaterialxv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetMaterialxv(var_face, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetMaterialxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetPointerv: {
|
|
android::base::beginTrace("glGetPointerv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glGetPointerv(var_pname, (GLvoid**)(inptr_params.get()));
|
|
SET_LASTCALL("glGetPointerv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetString: {
|
|
android::base::beginTrace("glGetString decode");
|
|
GLenum var_name = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetString: GL checksumCalculator failure\n");
|
|
}
|
|
this->glGetString(var_name);
|
|
SET_LASTCALL("glGetString");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexEnviv: {
|
|
android::base::beginTrace("glGetTexEnviv decode");
|
|
GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexEnviv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexEnviv(var_env, var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexEnviv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexEnvxv: {
|
|
android::base::beginTrace("glGetTexEnvxv decode");
|
|
GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexEnvxv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexEnvxv(var_env, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexEnvxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexParameteriv: {
|
|
android::base::beginTrace("glGetTexParameteriv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexParameteriv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexParameteriv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexParameterxv: {
|
|
android::base::beginTrace("glGetTexParameterxv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexParameterxv: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexParameterxv(var_target, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexParameterxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glHint: {
|
|
android::base::beginTrace("glHint decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glHint: GL checksumCalculator failure\n");
|
|
}
|
|
this->glHint(var_target, var_mode);
|
|
SET_LASTCALL("glHint");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glIsBuffer: {
|
|
android::base::beginTrace("glIsBuffer decode");
|
|
GLuint var_buffer = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glIsBuffer: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glIsBuffer(var_buffer);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glIsBuffer");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glIsEnabled: {
|
|
android::base::beginTrace("glIsEnabled decode");
|
|
GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glIsEnabled: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glIsEnabled(var_cap);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glIsEnabled");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glIsTexture: {
|
|
android::base::beginTrace("glIsTexture decode");
|
|
GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glIsTexture: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glIsTexture(var_texture);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glIsTexture");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightModelx: {
|
|
android::base::beginTrace("glLightModelx decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLightModelx: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLightModelx(var_pname, var_param);
|
|
SET_LASTCALL("glLightModelx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightModelxv: {
|
|
android::base::beginTrace("glLightModelxv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightModelxv(var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glLightModelxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightx: {
|
|
android::base::beginTrace("glLightx decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightx(var_light, var_pname, var_param);
|
|
SET_LASTCALL("glLightx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightxv: {
|
|
android::base::beginTrace("glLightxv decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightxv(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glLightxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLineWidthx: {
|
|
android::base::beginTrace("glLineWidthx decode");
|
|
GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLineWidthx: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLineWidthx(var_width);
|
|
SET_LASTCALL("glLineWidthx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLoadIdentity: {
|
|
android::base::beginTrace("glLoadIdentity decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLoadIdentity: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLoadIdentity();
|
|
SET_LASTCALL("glLoadIdentity");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLoadMatrixx: {
|
|
android::base::beginTrace("glLoadMatrixx decode");
|
|
uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_m(ptr + 8 + 4, size_m);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLoadMatrixx((const GLfixed*)(inptr_m.get()));
|
|
SET_LASTCALL("glLoadMatrixx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLogicOp: {
|
|
android::base::beginTrace("glLogicOp decode");
|
|
GLenum var_opcode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLogicOp: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLogicOp(var_opcode);
|
|
SET_LASTCALL("glLogicOp");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMaterialx: {
|
|
android::base::beginTrace("glMaterialx decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMaterialx(var_face, var_pname, var_param);
|
|
SET_LASTCALL("glMaterialx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMaterialxv: {
|
|
android::base::beginTrace("glMaterialxv decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMaterialxv(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glMaterialxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMatrixMode: {
|
|
android::base::beginTrace("glMatrixMode decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glMatrixMode: GL checksumCalculator failure\n");
|
|
}
|
|
this->glMatrixMode(var_mode);
|
|
SET_LASTCALL("glMatrixMode");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultMatrixx: {
|
|
android::base::beginTrace("glMultMatrixx decode");
|
|
uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_m(ptr + 8 + 4, size_m);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultMatrixx((const GLfixed*)(inptr_m.get()));
|
|
SET_LASTCALL("glMultMatrixx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultiTexCoord4x: {
|
|
android::base::beginTrace("glMultiTexCoord4x decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_s = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_t = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_r = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfixed var_q = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultiTexCoord4x(var_target, var_s, var_t, var_r, var_q);
|
|
SET_LASTCALL("glMultiTexCoord4x");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glNormal3x: {
|
|
android::base::beginTrace("glNormal3x decode");
|
|
GLfixed var_nx = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_ny = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_nz = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glNormal3x(var_nx, var_ny, var_nz);
|
|
SET_LASTCALL("glNormal3x");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glNormalPointer: {
|
|
android::base::beginTrace("glNormalPointer decode");
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4, size_pointer);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glNormalPointer(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
|
|
SET_LASTCALL("glNormalPointer");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glOrthox: {
|
|
android::base::beginTrace("glOrthox decode");
|
|
GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glOrthox(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glOrthox");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPixelStorei: {
|
|
android::base::beginTrace("glPixelStorei decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPixelStorei: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPixelStorei(var_pname, var_param);
|
|
SET_LASTCALL("glPixelStorei");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointParameterx: {
|
|
android::base::beginTrace("glPointParameterx decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPointParameterx: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPointParameterx(var_pname, var_param);
|
|
SET_LASTCALL("glPointParameterx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointParameterxv: {
|
|
android::base::beginTrace("glPointParameterxv decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glPointParameterxv(var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glPointParameterxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointSizex: {
|
|
android::base::beginTrace("glPointSizex decode");
|
|
GLfixed var_size = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPointSizex: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPointSizex(var_size);
|
|
SET_LASTCALL("glPointSizex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPolygonOffsetx: {
|
|
android::base::beginTrace("glPolygonOffsetx decode");
|
|
GLfixed var_factor = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_units = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPolygonOffsetx: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPolygonOffsetx(var_factor, var_units);
|
|
SET_LASTCALL("glPolygonOffsetx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPopMatrix: {
|
|
android::base::beginTrace("glPopMatrix decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPopMatrix: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPopMatrix();
|
|
SET_LASTCALL("glPopMatrix");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPushMatrix: {
|
|
android::base::beginTrace("glPushMatrix decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPushMatrix: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPushMatrix();
|
|
SET_LASTCALL("glPushMatrix");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glReadPixels: {
|
|
android::base::beginTrace("glReadPixels decode");
|
|
GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glReadPixels: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_pixels;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_pixels(&tmpBuf[0], 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) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glReadPixels");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glRotatex: {
|
|
android::base::beginTrace("glRotatex decode");
|
|
GLfixed var_angle = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glRotatex(var_angle, var_x, var_y, var_z);
|
|
SET_LASTCALL("glRotatex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glSampleCoverage: {
|
|
android::base::beginTrace("glSampleCoverage decode");
|
|
GLclampf var_value = Unpack<GLclampf,uint32_t>(ptr + 8);
|
|
GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glSampleCoverage: GL checksumCalculator failure\n");
|
|
}
|
|
this->glSampleCoverage(var_value, var_invert);
|
|
SET_LASTCALL("glSampleCoverage");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glSampleCoveragex: {
|
|
android::base::beginTrace("glSampleCoveragex decode");
|
|
GLclampx var_value = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glSampleCoveragex: GL checksumCalculator failure\n");
|
|
}
|
|
this->glSampleCoveragex(var_value, var_invert);
|
|
SET_LASTCALL("glSampleCoveragex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glScalex: {
|
|
android::base::beginTrace("glScalex decode");
|
|
GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glScalex(var_x, var_y, var_z);
|
|
SET_LASTCALL("glScalex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glScissor: {
|
|
android::base::beginTrace("glScissor decode");
|
|
GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glScissor(var_x, var_y, var_width, var_height);
|
|
SET_LASTCALL("glScissor");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glShadeModel: {
|
|
android::base::beginTrace("glShadeModel decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glShadeModel: GL checksumCalculator failure\n");
|
|
}
|
|
this->glShadeModel(var_mode);
|
|
SET_LASTCALL("glShadeModel");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glStencilFunc: {
|
|
android::base::beginTrace("glStencilFunc decode");
|
|
GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_ref = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLuint var_mask = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glStencilFunc(var_func, var_ref, var_mask);
|
|
SET_LASTCALL("glStencilFunc");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glStencilMask: {
|
|
android::base::beginTrace("glStencilMask decode");
|
|
GLuint var_mask = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glStencilMask: GL checksumCalculator failure\n");
|
|
}
|
|
this->glStencilMask(var_mask);
|
|
SET_LASTCALL("glStencilMask");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glStencilOp: {
|
|
android::base::beginTrace("glStencilOp decode");
|
|
GLenum var_fail = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_zfail = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_zpass = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glStencilOp(var_fail, var_zfail, var_zpass);
|
|
SET_LASTCALL("glStencilOp");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexCoordPointer: {
|
|
android::base::beginTrace("glTexCoordPointer decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexCoordPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
|
|
SET_LASTCALL("glTexCoordPointer");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnvi: {
|
|
android::base::beginTrace("glTexEnvi decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnvi(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexEnvi");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnvx: {
|
|
android::base::beginTrace("glTexEnvx decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnvx(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexEnvx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnviv: {
|
|
android::base::beginTrace("glTexEnviv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnviv(var_target, var_pname, (const GLint*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexEnviv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnvxv: {
|
|
android::base::beginTrace("glTexEnvxv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnvxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexEnvxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexImage2D: {
|
|
android::base::beginTrace("glTexImage2D decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLint var_internalformat = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
InputBuffer inptr_pixels(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_pixels);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
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();
|
|
break;
|
|
}
|
|
case OP_glTexParameteri: {
|
|
android::base::beginTrace("glTexParameteri decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameteri(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexParameteri");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexParameterx: {
|
|
android::base::beginTrace("glTexParameterx decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameterx(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexParameterx");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexParameteriv: {
|
|
android::base::beginTrace("glTexParameteriv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameteriv(var_target, var_pname, (const GLint*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexParameteriv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexParameterxv: {
|
|
android::base::beginTrace("glTexParameterxv decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameterxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexParameterxv");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexSubImage2D: {
|
|
android::base::beginTrace("glTexSubImage2D decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
InputBuffer inptr_pixels(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_pixels);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
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();
|
|
break;
|
|
}
|
|
case OP_glTranslatex: {
|
|
android::base::beginTrace("glTranslatex decode");
|
|
GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTranslatex(var_x, var_y, var_z);
|
|
SET_LASTCALL("glTranslatex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glVertexPointer: {
|
|
android::base::beginTrace("glVertexPointer decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glVertexPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
|
|
SET_LASTCALL("glVertexPointer");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glViewport: {
|
|
android::base::beginTrace("glViewport decode");
|
|
GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glViewport(var_x, var_y, var_width, var_height);
|
|
SET_LASTCALL("glViewport");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointSizePointerOES: {
|
|
android::base::beginTrace("glPointSizePointerOES decode");
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4, size_pointer);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glPointSizePointerOES(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
|
|
SET_LASTCALL("glPointSizePointerOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glVertexPointerOffset: {
|
|
android::base::beginTrace("glVertexPointerOffset decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glVertexPointerOffset(this, var_size, var_type, var_stride, var_offset);
|
|
SET_LASTCALL("glVertexPointerOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColorPointerOffset: {
|
|
android::base::beginTrace("glColorPointerOffset decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColorPointerOffset(this, var_size, var_type, var_stride, var_offset);
|
|
SET_LASTCALL("glColorPointerOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glNormalPointerOffset: {
|
|
android::base::beginTrace("glNormalPointerOffset decode");
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glNormalPointerOffset(this, var_type, var_stride, var_offset);
|
|
SET_LASTCALL("glNormalPointerOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointSizePointerOffset: {
|
|
android::base::beginTrace("glPointSizePointerOffset decode");
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glPointSizePointerOffset(this, var_type, var_stride, var_offset);
|
|
SET_LASTCALL("glPointSizePointerOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexCoordPointerOffset: {
|
|
android::base::beginTrace("glTexCoordPointerOffset decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexCoordPointerOffset(this, var_size, var_type, var_stride, var_offset);
|
|
SET_LASTCALL("glTexCoordPointerOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glWeightPointerOffset: {
|
|
android::base::beginTrace("glWeightPointerOffset decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glWeightPointerOffset(this, var_size, var_type, var_stride, var_offset);
|
|
SET_LASTCALL("glWeightPointerOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMatrixIndexPointerOffset: {
|
|
android::base::beginTrace("glMatrixIndexPointerOffset decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMatrixIndexPointerOffset(this, var_size, var_type, var_stride, var_offset);
|
|
SET_LASTCALL("glMatrixIndexPointerOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glVertexPointerData: {
|
|
android::base::beginTrace("glVertexPointerData decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glVertexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glVertexPointerData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColorPointerData: {
|
|
android::base::beginTrace("glColorPointerData decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColorPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glColorPointerData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glNormalPointerData: {
|
|
android::base::beginTrace("glNormalPointerData decode");
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glNormalPointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glNormalPointerData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexCoordPointerData: {
|
|
android::base::beginTrace("glTexCoordPointerData decode");
|
|
GLint var_unit = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexCoordPointerData(this, var_unit, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glTexCoordPointerData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointSizePointerData: {
|
|
android::base::beginTrace("glPointSizePointerData decode");
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glPointSizePointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glPointSizePointerData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glWeightPointerData: {
|
|
android::base::beginTrace("glWeightPointerData decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glWeightPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glWeightPointerData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMatrixIndexPointerData: {
|
|
android::base::beginTrace("glMatrixIndexPointerData decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMatrixIndexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glMatrixIndexPointerData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawElementsOffset: {
|
|
android::base::beginTrace("glDrawElementsOffset decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawElementsOffset(this, var_mode, var_count, var_type, var_offset);
|
|
SET_LASTCALL("glDrawElementsOffset");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawElementsData: {
|
|
android::base::beginTrace("glDrawElementsData decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
|
|
GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawElementsData(this, var_mode, var_count, var_type, (void*)(inptr_data.get()), var_datalen);
|
|
SET_LASTCALL("glDrawElementsData");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetCompressedTextureFormats: {
|
|
android::base::beginTrace("glGetCompressedTextureFormats decode");
|
|
int var_count = Unpack<int,uint32_t>(ptr + 8);
|
|
uint32_t size_formats __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetCompressedTextureFormats: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_formats;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_formats(&tmpBuf[0], size_formats);
|
|
this->glGetCompressedTextureFormats(this, var_count, (GLint*)(outptr_formats.get()));
|
|
outptr_formats.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetCompressedTextureFormats");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFinishRoundTrip: {
|
|
android::base::beginTrace("glFinishRoundTrip decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFinishRoundTrip: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(int);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(int *)(&tmpBuf[0]) = this->glFinishRoundTrip(this);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glFinishRoundTrip");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBlendEquationSeparateOES: {
|
|
android::base::beginTrace("glBlendEquationSeparateOES decode");
|
|
GLenum var_modeRGB = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_modeAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBlendEquationSeparateOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBlendEquationSeparateOES(var_modeRGB, var_modeAlpha);
|
|
SET_LASTCALL("glBlendEquationSeparateOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBlendFuncSeparateOES: {
|
|
android::base::beginTrace("glBlendFuncSeparateOES decode");
|
|
GLenum var_srcRGB = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_dstRGB = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_srcAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLenum var_dstAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glBlendFuncSeparateOES(var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
|
|
SET_LASTCALL("glBlendFuncSeparateOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBlendEquationOES: {
|
|
android::base::beginTrace("glBlendEquationOES decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBlendEquationOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBlendEquationOES(var_mode);
|
|
SET_LASTCALL("glBlendEquationOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexsOES: {
|
|
android::base::beginTrace("glDrawTexsOES decode");
|
|
GLshort var_x = Unpack<GLshort,uint16_t>(ptr + 8);
|
|
GLshort var_y = Unpack<GLshort,uint16_t>(ptr + 8 + 2);
|
|
GLshort var_z = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2);
|
|
GLshort var_width = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2 + 2);
|
|
GLshort var_height = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2 + 2 + 2);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexsOES(var_x, var_y, var_z, var_width, var_height);
|
|
SET_LASTCALL("glDrawTexsOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexiOES: {
|
|
android::base::beginTrace("glDrawTexiOES decode");
|
|
GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLint var_z = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLint var_width = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLint var_height = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexiOES(var_x, var_y, var_z, var_width, var_height);
|
|
SET_LASTCALL("glDrawTexiOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexxOES: {
|
|
android::base::beginTrace("glDrawTexxOES decode");
|
|
GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfixed var_height = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexxOES(var_x, var_y, var_z, var_width, var_height);
|
|
SET_LASTCALL("glDrawTexxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexsvOES: {
|
|
android::base::beginTrace("glDrawTexsvOES decode");
|
|
uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexsvOES((const GLshort*)(inptr_coords.get()));
|
|
SET_LASTCALL("glDrawTexsvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexivOES: {
|
|
android::base::beginTrace("glDrawTexivOES decode");
|
|
uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexivOES((const GLint*)(inptr_coords.get()));
|
|
SET_LASTCALL("glDrawTexivOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexxvOES: {
|
|
android::base::beginTrace("glDrawTexxvOES decode");
|
|
uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexxvOES((const GLfixed*)(inptr_coords.get()));
|
|
SET_LASTCALL("glDrawTexxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexfOES: {
|
|
android::base::beginTrace("glDrawTexfOES decode");
|
|
GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_width = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfloat var_height = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexfOES(var_x, var_y, var_z, var_width, var_height);
|
|
SET_LASTCALL("glDrawTexfOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDrawTexfvOES: {
|
|
android::base::beginTrace("glDrawTexfvOES decode");
|
|
uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDrawTexfvOES((const GLfloat*)(inptr_coords.get()));
|
|
SET_LASTCALL("glDrawTexfvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glEGLImageTargetTexture2DOES: {
|
|
android::base::beginTrace("glEGLImageTargetTexture2DOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLeglImageOES var_image = Unpack<GLeglImageOES,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glEGLImageTargetTexture2DOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glEGLImageTargetTexture2DOES(var_target, var_image);
|
|
SET_LASTCALL("glEGLImageTargetTexture2DOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glEGLImageTargetRenderbufferStorageOES: {
|
|
android::base::beginTrace("glEGLImageTargetRenderbufferStorageOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLeglImageOES var_image = Unpack<GLeglImageOES,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glEGLImageTargetRenderbufferStorageOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glEGLImageTargetRenderbufferStorageOES(var_target, var_image);
|
|
SET_LASTCALL("glEGLImageTargetRenderbufferStorageOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glAlphaFuncxOES: {
|
|
android::base::beginTrace("glAlphaFuncxOES decode");
|
|
GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLclampx var_ref = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glAlphaFuncxOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glAlphaFuncxOES(var_func, var_ref);
|
|
SET_LASTCALL("glAlphaFuncxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearColorxOES: {
|
|
android::base::beginTrace("glClearColorxOES decode");
|
|
GLclampx var_red = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
GLclampx var_green = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
|
|
GLclampx var_blue = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLclampx var_alpha = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClearColorxOES(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glClearColorxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearDepthxOES: {
|
|
android::base::beginTrace("glClearDepthxOES decode");
|
|
GLclampx var_depth = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glClearDepthxOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glClearDepthxOES(var_depth);
|
|
SET_LASTCALL("glClearDepthxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClipPlanexOES: {
|
|
android::base::beginTrace("glClipPlanexOES decode");
|
|
GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClipPlanexOES(var_plane, (const GLfixed*)(inptr_equation.get()));
|
|
SET_LASTCALL("glClipPlanexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClipPlanexIMG: {
|
|
android::base::beginTrace("glClipPlanexIMG decode");
|
|
GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClipPlanexIMG(var_plane, (const GLfixed*)(inptr_equation.get()));
|
|
SET_LASTCALL("glClipPlanexIMG");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glColor4xOES: {
|
|
android::base::beginTrace("glColor4xOES decode");
|
|
GLfixed var_red = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_green = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_blue = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_alpha = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glColor4xOES(var_red, var_green, var_blue, var_alpha);
|
|
SET_LASTCALL("glColor4xOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDepthRangexOES: {
|
|
android::base::beginTrace("glDepthRangexOES decode");
|
|
GLclampx var_zNear = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
GLclampx var_zFar = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDepthRangexOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDepthRangexOES(var_zNear, var_zFar);
|
|
SET_LASTCALL("glDepthRangexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFogxOES: {
|
|
android::base::beginTrace("glFogxOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFogxOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glFogxOES(var_pname, var_param);
|
|
SET_LASTCALL("glFogxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFogxvOES: {
|
|
android::base::beginTrace("glFogxvOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFogxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glFogxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFrustumxOES: {
|
|
android::base::beginTrace("glFrustumxOES decode");
|
|
GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFrustumxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glFrustumxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetClipPlanexOES: {
|
|
android::base::beginTrace("glGetClipPlanexOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetClipPlanexOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_eqn;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
|
|
this->glGetClipPlanexOES(var_pname, (GLfixed*)(outptr_eqn.get()));
|
|
outptr_eqn.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetClipPlanexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetClipPlanex: {
|
|
android::base::beginTrace("glGetClipPlanex decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetClipPlanex: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_eqn;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
|
|
this->glGetClipPlanex(var_pname, (GLfixed*)(outptr_eqn.get()));
|
|
outptr_eqn.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetClipPlanex");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetFixedvOES: {
|
|
android::base::beginTrace("glGetFixedvOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetFixedvOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetFixedvOES(var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetFixedvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetLightxvOES: {
|
|
android::base::beginTrace("glGetLightxvOES decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetLightxvOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetLightxvOES(var_light, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetLightxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetMaterialxvOES: {
|
|
android::base::beginTrace("glGetMaterialxvOES decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetMaterialxvOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetMaterialxvOES(var_face, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetMaterialxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexEnvxvOES: {
|
|
android::base::beginTrace("glGetTexEnvxvOES decode");
|
|
GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexEnvxvOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexEnvxvOES(var_env, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexEnvxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexParameterxvOES: {
|
|
android::base::beginTrace("glGetTexParameterxvOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetTexParameterxvOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetTexParameterxvOES(var_target, var_pname, (GLfixed*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetTexParameterxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightModelxOES: {
|
|
android::base::beginTrace("glLightModelxOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLightModelxOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLightModelxOES(var_pname, var_param);
|
|
SET_LASTCALL("glLightModelxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightModelxvOES: {
|
|
android::base::beginTrace("glLightModelxvOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightModelxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glLightModelxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightxOES: {
|
|
android::base::beginTrace("glLightxOES decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightxOES(var_light, var_pname, var_param);
|
|
SET_LASTCALL("glLightxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLightxvOES: {
|
|
android::base::beginTrace("glLightxvOES decode");
|
|
GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLightxvOES(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glLightxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLineWidthxOES: {
|
|
android::base::beginTrace("glLineWidthxOES decode");
|
|
GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLineWidthxOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLineWidthxOES(var_width);
|
|
SET_LASTCALL("glLineWidthxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLoadMatrixxOES: {
|
|
android::base::beginTrace("glLoadMatrixxOES decode");
|
|
uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_m(ptr + 8 + 4, size_m);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glLoadMatrixxOES((const GLfixed*)(inptr_m.get()));
|
|
SET_LASTCALL("glLoadMatrixxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMaterialxOES: {
|
|
android::base::beginTrace("glMaterialxOES decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMaterialxOES(var_face, var_pname, var_param);
|
|
SET_LASTCALL("glMaterialxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMaterialxvOES: {
|
|
android::base::beginTrace("glMaterialxvOES decode");
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMaterialxvOES(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glMaterialxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultMatrixxOES: {
|
|
android::base::beginTrace("glMultMatrixxOES decode");
|
|
uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
InputBuffer inptr_m(ptr + 8 + 4, size_m);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultMatrixxOES((const GLfixed*)(inptr_m.get()));
|
|
SET_LASTCALL("glMultMatrixxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultiTexCoord4xOES: {
|
|
android::base::beginTrace("glMultiTexCoord4xOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_s = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_t = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_r = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfixed var_q = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultiTexCoord4xOES(var_target, var_s, var_t, var_r, var_q);
|
|
SET_LASTCALL("glMultiTexCoord4xOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glNormal3xOES: {
|
|
android::base::beginTrace("glNormal3xOES decode");
|
|
GLfixed var_nx = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_ny = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_nz = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glNormal3xOES(var_nx, var_ny, var_nz);
|
|
SET_LASTCALL("glNormal3xOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glOrthoxOES: {
|
|
android::base::beginTrace("glOrthoxOES decode");
|
|
GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glOrthoxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glOrthoxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointParameterxOES: {
|
|
android::base::beginTrace("glPointParameterxOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPointParameterxOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPointParameterxOES(var_pname, var_param);
|
|
SET_LASTCALL("glPointParameterxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointParameterxvOES: {
|
|
android::base::beginTrace("glPointParameterxvOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glPointParameterxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glPointParameterxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPointSizexOES: {
|
|
android::base::beginTrace("glPointSizexOES decode");
|
|
GLfixed var_size = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPointSizexOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPointSizexOES(var_size);
|
|
SET_LASTCALL("glPointSizexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glPolygonOffsetxOES: {
|
|
android::base::beginTrace("glPolygonOffsetxOES decode");
|
|
GLfixed var_factor = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_units = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glPolygonOffsetxOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glPolygonOffsetxOES(var_factor, var_units);
|
|
SET_LASTCALL("glPolygonOffsetxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glRotatexOES: {
|
|
android::base::beginTrace("glRotatexOES decode");
|
|
GLfixed var_angle = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glRotatexOES(var_angle, var_x, var_y, var_z);
|
|
SET_LASTCALL("glRotatexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glSampleCoveragexOES: {
|
|
android::base::beginTrace("glSampleCoveragexOES decode");
|
|
GLclampx var_value = Unpack<GLclampx,uint32_t>(ptr + 8);
|
|
GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glSampleCoveragexOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glSampleCoveragexOES(var_value, var_invert);
|
|
SET_LASTCALL("glSampleCoveragexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glScalexOES: {
|
|
android::base::beginTrace("glScalexOES decode");
|
|
GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glScalexOES(var_x, var_y, var_z);
|
|
SET_LASTCALL("glScalexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnvxOES: {
|
|
android::base::beginTrace("glTexEnvxOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnvxOES(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexEnvxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexEnvxvOES: {
|
|
android::base::beginTrace("glTexEnvxvOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexEnvxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexEnvxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexParameterxOES: {
|
|
android::base::beginTrace("glTexParameterxOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameterxOES(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glTexParameterxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexParameterxvOES: {
|
|
android::base::beginTrace("glTexParameterxvOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexParameterxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexParameterxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTranslatexOES: {
|
|
android::base::beginTrace("glTranslatexOES decode");
|
|
GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
|
|
GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTranslatexOES(var_x, var_y, var_z);
|
|
SET_LASTCALL("glTranslatexOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glIsRenderbufferOES: {
|
|
android::base::beginTrace("glIsRenderbufferOES decode");
|
|
GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glIsRenderbufferOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glIsRenderbufferOES(var_renderbuffer);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glIsRenderbufferOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBindRenderbufferOES: {
|
|
android::base::beginTrace("glBindRenderbufferOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBindRenderbufferOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBindRenderbufferOES(var_target, var_renderbuffer);
|
|
SET_LASTCALL("glBindRenderbufferOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDeleteRenderbuffersOES: {
|
|
android::base::beginTrace("glDeleteRenderbuffersOES decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_renderbuffers(ptr + 8 + 4 + 4, size_renderbuffers);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDeleteRenderbuffersOES_dec(this, var_n, (const GLuint*)(inptr_renderbuffers.get()));
|
|
SET_LASTCALL("glDeleteRenderbuffersOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGenRenderbuffersOES: {
|
|
android::base::beginTrace("glGenRenderbuffersOES decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGenRenderbuffersOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_renderbuffers;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
|
|
this->glGenRenderbuffersOES_dec(this, var_n, (GLuint*)(outptr_renderbuffers.get()));
|
|
outptr_renderbuffers.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGenRenderbuffersOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glRenderbufferStorageOES: {
|
|
android::base::beginTrace("glRenderbufferStorageOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glRenderbufferStorageOES(var_target, var_internalformat, var_width, var_height);
|
|
SET_LASTCALL("glRenderbufferStorageOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetRenderbufferParameterivOES: {
|
|
android::base::beginTrace("glGetRenderbufferParameterivOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetRenderbufferParameterivOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetRenderbufferParameterivOES(var_target, var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetRenderbufferParameterivOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glIsFramebufferOES: {
|
|
android::base::beginTrace("glIsFramebufferOES decode");
|
|
GLuint var_framebuffer = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glIsFramebufferOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glIsFramebufferOES(var_framebuffer);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glIsFramebufferOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBindFramebufferOES: {
|
|
android::base::beginTrace("glBindFramebufferOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLuint var_framebuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBindFramebufferOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBindFramebufferOES(var_target, var_framebuffer);
|
|
SET_LASTCALL("glBindFramebufferOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDeleteFramebuffersOES: {
|
|
android::base::beginTrace("glDeleteFramebuffersOES decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_framebuffers(ptr + 8 + 4 + 4, size_framebuffers);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDeleteFramebuffersOES_dec(this, var_n, (const GLuint*)(inptr_framebuffers.get()));
|
|
SET_LASTCALL("glDeleteFramebuffersOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGenFramebuffersOES: {
|
|
android::base::beginTrace("glGenFramebuffersOES decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGenFramebuffersOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_framebuffers;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
|
|
this->glGenFramebuffersOES_dec(this, var_n, (GLuint*)(outptr_framebuffers.get()));
|
|
outptr_framebuffers.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGenFramebuffersOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glCheckFramebufferStatusOES: {
|
|
android::base::beginTrace("glCheckFramebufferStatusOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glCheckFramebufferStatusOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLenum);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLenum *)(&tmpBuf[0]) = this->glCheckFramebufferStatusOES(var_target);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glCheckFramebufferStatusOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFramebufferRenderbufferOES: {
|
|
android::base::beginTrace("glFramebufferRenderbufferOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_renderbuffertarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFramebufferRenderbufferOES(var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
|
|
SET_LASTCALL("glFramebufferRenderbufferOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFramebufferTexture2DOES: {
|
|
android::base::beginTrace("glFramebufferTexture2DOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_textarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFramebufferTexture2DOES(var_target, var_attachment, var_textarget, var_texture, var_level);
|
|
SET_LASTCALL("glFramebufferTexture2DOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetFramebufferAttachmentParameterivOES: {
|
|
android::base::beginTrace("glGetFramebufferAttachmentParameterivOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetFramebufferAttachmentParameterivOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetFramebufferAttachmentParameterivOES(var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetFramebufferAttachmentParameterivOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGenerateMipmapOES: {
|
|
android::base::beginTrace("glGenerateMipmapOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGenerateMipmapOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glGenerateMipmapOES(var_target);
|
|
SET_LASTCALL("glGenerateMipmapOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMapBufferOES: {
|
|
android::base::beginTrace("glMapBufferOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_access = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glMapBufferOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glMapBufferOES(var_target, var_access);
|
|
SET_LASTCALL("glMapBufferOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glUnmapBufferOES: {
|
|
android::base::beginTrace("glUnmapBufferOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glUnmapBufferOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glUnmapBufferOES(var_target);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glUnmapBufferOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetBufferPointervOES: {
|
|
android::base::beginTrace("glGetBufferPointervOES decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glGetBufferPointervOES(var_target, var_pname, (GLvoid**)(inptr_params.get()));
|
|
SET_LASTCALL("glGetBufferPointervOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glCurrentPaletteMatrixOES: {
|
|
android::base::beginTrace("glCurrentPaletteMatrixOES decode");
|
|
GLuint var_matrixpaletteindex = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glCurrentPaletteMatrixOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glCurrentPaletteMatrixOES(var_matrixpaletteindex);
|
|
SET_LASTCALL("glCurrentPaletteMatrixOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glLoadPaletteFromModelViewMatrixOES: {
|
|
android::base::beginTrace("glLoadPaletteFromModelViewMatrixOES decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glLoadPaletteFromModelViewMatrixOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glLoadPaletteFromModelViewMatrixOES();
|
|
SET_LASTCALL("glLoadPaletteFromModelViewMatrixOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMatrixIndexPointerOES: {
|
|
android::base::beginTrace("glMatrixIndexPointerOES decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMatrixIndexPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
|
|
SET_LASTCALL("glMatrixIndexPointerOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glWeightPointerOES: {
|
|
android::base::beginTrace("glWeightPointerOES decode");
|
|
GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glWeightPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
|
|
SET_LASTCALL("glWeightPointerOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glQueryMatrixxOES: {
|
|
android::base::beginTrace("glQueryMatrixxOES decode");
|
|
uint32_t size_mantissa __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
uint32_t size_exponent __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glQueryMatrixxOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_mantissa;
|
|
totalTmpSize += size_exponent;
|
|
totalTmpSize += sizeof(GLbitfield);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_mantissa(&tmpBuf[0], size_mantissa);
|
|
OutputBuffer outptr_exponent(&tmpBuf[0 + size_mantissa], 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();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glQueryMatrixxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDepthRangefOES: {
|
|
android::base::beginTrace("glDepthRangefOES decode");
|
|
GLclampf var_zNear = Unpack<GLclampf,uint32_t>(ptr + 8);
|
|
GLclampf var_zFar = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDepthRangefOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDepthRangefOES(var_zNear, var_zFar);
|
|
SET_LASTCALL("glDepthRangefOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFrustumfOES: {
|
|
android::base::beginTrace("glFrustumfOES decode");
|
|
GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFrustumfOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glFrustumfOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glOrthofOES: {
|
|
android::base::beginTrace("glOrthofOES decode");
|
|
GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
|
|
GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glOrthofOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
|
|
SET_LASTCALL("glOrthofOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClipPlanefOES: {
|
|
android::base::beginTrace("glClipPlanefOES decode");
|
|
GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClipPlanefOES(var_plane, (const GLfloat*)(inptr_equation.get()));
|
|
SET_LASTCALL("glClipPlanefOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClipPlanefIMG: {
|
|
android::base::beginTrace("glClipPlanefIMG decode");
|
|
GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glClipPlanefIMG(var_plane, (const GLfloat*)(inptr_equation.get()));
|
|
SET_LASTCALL("glClipPlanefIMG");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetClipPlanefOES: {
|
|
android::base::beginTrace("glGetClipPlanefOES decode");
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetClipPlanefOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_eqn;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
|
|
this->glGetClipPlanefOES(var_pname, (GLfloat*)(outptr_eqn.get()));
|
|
outptr_eqn.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetClipPlanefOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glClearDepthfOES: {
|
|
android::base::beginTrace("glClearDepthfOES decode");
|
|
GLclampf var_depth = Unpack<GLclampf,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glClearDepthfOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glClearDepthfOES(var_depth);
|
|
SET_LASTCALL("glClearDepthfOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexGenfOES: {
|
|
android::base::beginTrace("glTexGenfOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexGenfOES(var_coord, var_pname, var_param);
|
|
SET_LASTCALL("glTexGenfOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexGenfvOES: {
|
|
android::base::beginTrace("glTexGenfvOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexGenfvOES(var_coord, var_pname, (const GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexGenfvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexGeniOES: {
|
|
android::base::beginTrace("glTexGeniOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexGeniOES(var_coord, var_pname, var_param);
|
|
SET_LASTCALL("glTexGeniOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexGenivOES: {
|
|
android::base::beginTrace("glTexGenivOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexGenivOES(var_coord, var_pname, (const GLint*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexGenivOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexGenxOES: {
|
|
android::base::beginTrace("glTexGenxOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexGenxOES(var_coord, var_pname, var_param);
|
|
SET_LASTCALL("glTexGenxOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTexGenxvOES: {
|
|
android::base::beginTrace("glTexGenxvOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glTexGenxvOES(var_coord, var_pname, (const GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glTexGenxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexGenfvOES: {
|
|
android::base::beginTrace("glGetTexGenfvOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glGetTexGenfvOES(var_coord, var_pname, (GLfloat*)(inptr_params.get()));
|
|
SET_LASTCALL("glGetTexGenfvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexGenivOES: {
|
|
android::base::beginTrace("glGetTexGenivOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glGetTexGenivOES(var_coord, var_pname, (GLint*)(inptr_params.get()));
|
|
SET_LASTCALL("glGetTexGenivOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetTexGenxvOES: {
|
|
android::base::beginTrace("glGetTexGenxvOES decode");
|
|
GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glGetTexGenxvOES(var_coord, var_pname, (GLfixed*)(inptr_params.get()));
|
|
SET_LASTCALL("glGetTexGenxvOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glBindVertexArrayOES: {
|
|
android::base::beginTrace("glBindVertexArrayOES decode");
|
|
GLuint var_array = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glBindVertexArrayOES: GL checksumCalculator failure\n");
|
|
}
|
|
this->glBindVertexArrayOES(var_array);
|
|
SET_LASTCALL("glBindVertexArrayOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDeleteVertexArraysOES: {
|
|
android::base::beginTrace("glDeleteVertexArraysOES decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_arrays __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_arrays(ptr + 8 + 4 + 4, size_arrays);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDeleteVertexArraysOES_dec(this, var_n, (const GLuint*)(inptr_arrays.get()));
|
|
SET_LASTCALL("glDeleteVertexArraysOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGenVertexArraysOES: {
|
|
android::base::beginTrace("glGenVertexArraysOES decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_arrays __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGenVertexArraysOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_arrays;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_arrays(&tmpBuf[0], size_arrays);
|
|
this->glGenVertexArraysOES_dec(this, var_n, (GLuint*)(outptr_arrays.get()));
|
|
outptr_arrays.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGenVertexArraysOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glIsVertexArrayOES: {
|
|
android::base::beginTrace("glIsVertexArrayOES decode");
|
|
GLuint var_array = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glIsVertexArrayOES: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glIsVertexArrayOES(var_array);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glIsVertexArrayOES");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDiscardFramebufferEXT: {
|
|
android::base::beginTrace("glDiscardFramebufferEXT decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_numAttachments = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_attachments __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_attachments(ptr + 8 + 4 + 4 + 4, size_attachments);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDiscardFramebufferEXT(var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()));
|
|
SET_LASTCALL("glDiscardFramebufferEXT");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultiDrawArraysEXT: {
|
|
android::base::beginTrace("glMultiDrawArraysEXT decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_first __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_first(ptr + 8 + 4 + 4, size_first);
|
|
uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_first);
|
|
InputBuffer inptr_count(ptr + 8 + 4 + 4 + size_first + 4, size_count);
|
|
GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_first + 4 + size_count);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultiDrawArraysEXT(var_mode, (const GLint*)(inptr_first.get()), (const GLsizei*)(inptr_count.get()), var_primcount);
|
|
SET_LASTCALL("glMultiDrawArraysEXT");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultiDrawElementsEXT: {
|
|
android::base::beginTrace("glMultiDrawElementsEXT decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_count(ptr + 8 + 4 + 4, size_count);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + size_count);
|
|
uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4);
|
|
InputBuffer inptr_indices(ptr + 8 + 4 + 4 + size_count + 4 + 4, size_indices);
|
|
GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
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();
|
|
break;
|
|
}
|
|
case OP_glMultiDrawArraysSUN: {
|
|
android::base::beginTrace("glMultiDrawArraysSUN decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_first __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_first(ptr + 8 + 4 + 4, size_first);
|
|
uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_first);
|
|
InputBuffer inptr_count(ptr + 8 + 4 + 4 + size_first + 4, size_count);
|
|
GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_first + 4 + size_count);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultiDrawArraysSUN(var_mode, (GLint*)(inptr_first.get()), (GLsizei*)(inptr_count.get()), var_primcount);
|
|
SET_LASTCALL("glMultiDrawArraysSUN");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glMultiDrawElementsSUN: {
|
|
android::base::beginTrace("glMultiDrawElementsSUN decode");
|
|
GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_count(ptr + 8 + 4 + 4, size_count);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + size_count);
|
|
uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4);
|
|
InputBuffer inptr_indices(ptr + 8 + 4 + 4 + size_count + 4 + 4, size_indices);
|
|
GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glMultiDrawElementsSUN(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid**)(inptr_indices.get()), var_primcount);
|
|
SET_LASTCALL("glMultiDrawElementsSUN");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glRenderbufferStorageMultisampleIMG: {
|
|
android::base::beginTrace("glRenderbufferStorageMultisampleIMG decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLsizei var_samples = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glRenderbufferStorageMultisampleIMG(var_target, var_samples, var_internalformat, var_width, var_height);
|
|
SET_LASTCALL("glRenderbufferStorageMultisampleIMG");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFramebufferTexture2DMultisampleIMG: {
|
|
android::base::beginTrace("glFramebufferTexture2DMultisampleIMG decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLenum var_textarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLsizei var_samples = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glFramebufferTexture2DMultisampleIMG(var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
|
|
SET_LASTCALL("glFramebufferTexture2DMultisampleIMG");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDeleteFencesNV: {
|
|
android::base::beginTrace("glDeleteFencesNV decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_fences __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_fences(ptr + 8 + 4 + 4, size_fences);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glDeleteFencesNV(var_n, (const GLuint*)(inptr_fences.get()));
|
|
SET_LASTCALL("glDeleteFencesNV");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGenFencesNV: {
|
|
android::base::beginTrace("glGenFencesNV decode");
|
|
GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
|
|
uint32_t size_fences __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_fences(ptr + 8 + 4 + 4, size_fences);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glGenFencesNV(var_n, (GLuint*)(inptr_fences.get()));
|
|
SET_LASTCALL("glGenFencesNV");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glIsFenceNV: {
|
|
android::base::beginTrace("glIsFenceNV decode");
|
|
GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glIsFenceNV: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glIsFenceNV(var_fence);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glIsFenceNV");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glTestFenceNV: {
|
|
android::base::beginTrace("glTestFenceNV decode");
|
|
GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glTestFenceNV: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glTestFenceNV(var_fence);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glTestFenceNV");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetFenceivNV: {
|
|
android::base::beginTrace("glGetFenceivNV decode");
|
|
GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetFenceivNV: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glGetFenceivNV(var_fence, var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetFenceivNV");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glFinishFenceNV: {
|
|
android::base::beginTrace("glFinishFenceNV decode");
|
|
GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glFinishFenceNV: GL checksumCalculator failure\n");
|
|
}
|
|
this->glFinishFenceNV(var_fence);
|
|
SET_LASTCALL("glFinishFenceNV");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glSetFenceNV: {
|
|
android::base::beginTrace("glSetFenceNV decode");
|
|
GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
GLenum var_condition = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glSetFenceNV: GL checksumCalculator failure\n");
|
|
}
|
|
this->glSetFenceNV(var_fence, var_condition);
|
|
SET_LASTCALL("glSetFenceNV");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetDriverControlsQCOM: {
|
|
android::base::beginTrace("glGetDriverControlsQCOM decode");
|
|
uint32_t size_num __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
GLsizei var_size = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_driverControls __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetDriverControlsQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_num;
|
|
totalTmpSize += size_driverControls;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_num(&tmpBuf[0], size_num);
|
|
OutputBuffer outptr_driverControls(&tmpBuf[0 + size_num], size_driverControls);
|
|
this->glGetDriverControlsQCOM((GLint*)(outptr_num.get()), var_size, (GLuint*)(outptr_driverControls.get()));
|
|
outptr_num.flush();
|
|
outptr_driverControls.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetDriverControlsQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetDriverControlStringQCOM: {
|
|
android::base::beginTrace("glGetDriverControlStringQCOM decode");
|
|
GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
GLsizei var_bufSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_length __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
uint32_t size_driverControlString __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetDriverControlStringQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_length;
|
|
totalTmpSize += size_driverControlString;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_length(&tmpBuf[0], size_length);
|
|
OutputBuffer outptr_driverControlString(&tmpBuf[0 + size_length], size_driverControlString);
|
|
this->glGetDriverControlStringQCOM(var_driverControl, var_bufSize, (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_driverControlString.get()));
|
|
outptr_length.flush();
|
|
outptr_driverControlString.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetDriverControlStringQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glEnableDriverControlQCOM: {
|
|
android::base::beginTrace("glEnableDriverControlQCOM decode");
|
|
GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glEnableDriverControlQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
this->glEnableDriverControlQCOM(var_driverControl);
|
|
SET_LASTCALL("glEnableDriverControlQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glDisableDriverControlQCOM: {
|
|
android::base::beginTrace("glDisableDriverControlQCOM decode");
|
|
GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glDisableDriverControlQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
this->glDisableDriverControlQCOM(var_driverControl);
|
|
SET_LASTCALL("glDisableDriverControlQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetTexturesQCOM: {
|
|
android::base::beginTrace("glExtGetTexturesQCOM decode");
|
|
uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
GLint var_maxTextures = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_numTextures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetTexturesQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_textures;
|
|
totalTmpSize += size_numTextures;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
|
|
OutputBuffer outptr_numTextures(&tmpBuf[0 + size_textures], size_numTextures);
|
|
this->glExtGetTexturesQCOM((GLuint*)(outptr_textures.get()), var_maxTextures, (GLint*)(outptr_numTextures.get()));
|
|
outptr_textures.flush();
|
|
outptr_numTextures.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetTexturesQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetBuffersQCOM: {
|
|
android::base::beginTrace("glExtGetBuffersQCOM decode");
|
|
uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
GLint var_maxBuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_numBuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetBuffersQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_buffers;
|
|
totalTmpSize += size_numBuffers;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
|
|
OutputBuffer outptr_numBuffers(&tmpBuf[0 + size_buffers], size_numBuffers);
|
|
this->glExtGetBuffersQCOM((GLuint*)(outptr_buffers.get()), var_maxBuffers, (GLint*)(outptr_numBuffers.get()));
|
|
outptr_buffers.flush();
|
|
outptr_numBuffers.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetBuffersQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetRenderbuffersQCOM: {
|
|
android::base::beginTrace("glExtGetRenderbuffersQCOM decode");
|
|
uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
GLint var_maxRenderbuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_numRenderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetRenderbuffersQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_renderbuffers;
|
|
totalTmpSize += size_numRenderbuffers;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
|
|
OutputBuffer outptr_numRenderbuffers(&tmpBuf[0 + size_renderbuffers], size_numRenderbuffers);
|
|
this->glExtGetRenderbuffersQCOM((GLuint*)(outptr_renderbuffers.get()), var_maxRenderbuffers, (GLint*)(outptr_numRenderbuffers.get()));
|
|
outptr_renderbuffers.flush();
|
|
outptr_numRenderbuffers.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetRenderbuffersQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetFramebuffersQCOM: {
|
|
android::base::beginTrace("glExtGetFramebuffersQCOM decode");
|
|
uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
GLint var_maxFramebuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_numFramebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetFramebuffersQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_framebuffers;
|
|
totalTmpSize += size_numFramebuffers;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
|
|
OutputBuffer outptr_numFramebuffers(&tmpBuf[0 + size_framebuffers], size_numFramebuffers);
|
|
this->glExtGetFramebuffersQCOM((GLuint*)(outptr_framebuffers.get()), var_maxFramebuffers, (GLint*)(outptr_numFramebuffers.get()));
|
|
outptr_framebuffers.flush();
|
|
outptr_numFramebuffers.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetFramebuffersQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetTexLevelParameterivQCOM: {
|
|
android::base::beginTrace("glExtGetTexLevelParameterivQCOM decode");
|
|
GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetTexLevelParameterivQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_params;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_params(&tmpBuf[0], size_params);
|
|
this->glExtGetTexLevelParameterivQCOM(var_texture, var_face, var_level, var_pname, (GLint*)(outptr_params.get()));
|
|
outptr_params.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetTexLevelParameterivQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtTexObjectStateOverrideiQCOM: {
|
|
android::base::beginTrace("glExtTexObjectStateOverrideiQCOM decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glExtTexObjectStateOverrideiQCOM(var_target, var_pname, var_param);
|
|
SET_LASTCALL("glExtTexObjectStateOverrideiQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetTexSubImageQCOM: {
|
|
android::base::beginTrace("glExtGetTexSubImageQCOM decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLint var_zoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_depth = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
uint32_t size_texels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetTexSubImageQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_texels;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_texels(&tmpBuf[0], 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) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetTexSubImageQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetBufferPointervQCOM: {
|
|
android::base::beginTrace("glExtGetBufferPointervQCOM decode");
|
|
GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
|
|
uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
|
|
InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glExtGetBufferPointervQCOM(var_target, (GLvoid**)(inptr_params.get()));
|
|
SET_LASTCALL("glExtGetBufferPointervQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetShadersQCOM: {
|
|
android::base::beginTrace("glExtGetShadersQCOM decode");
|
|
uint32_t size_shaders __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
GLint var_maxShaders = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_numShaders __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetShadersQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_shaders;
|
|
totalTmpSize += size_numShaders;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_shaders(&tmpBuf[0], size_shaders);
|
|
OutputBuffer outptr_numShaders(&tmpBuf[0 + size_shaders], size_numShaders);
|
|
this->glExtGetShadersQCOM((GLuint*)(outptr_shaders.get()), var_maxShaders, (GLint*)(outptr_numShaders.get()));
|
|
outptr_shaders.flush();
|
|
outptr_numShaders.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetShadersQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetProgramsQCOM: {
|
|
android::base::beginTrace("glExtGetProgramsQCOM decode");
|
|
uint32_t size_programs __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
|
|
GLint var_maxPrograms = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_numPrograms __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtGetProgramsQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_programs;
|
|
totalTmpSize += size_numPrograms;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_programs(&tmpBuf[0], size_programs);
|
|
OutputBuffer outptr_numPrograms(&tmpBuf[0 + size_programs], size_numPrograms);
|
|
this->glExtGetProgramsQCOM((GLuint*)(outptr_programs.get()), var_maxPrograms, (GLint*)(outptr_numPrograms.get()));
|
|
outptr_programs.flush();
|
|
outptr_numPrograms.flush();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtGetProgramsQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtIsProgramBinaryQCOM: {
|
|
android::base::beginTrace("glExtIsProgramBinaryQCOM decode");
|
|
GLuint var_program = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glExtIsProgramBinaryQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLboolean);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLboolean *)(&tmpBuf[0]) = this->glExtIsProgramBinaryQCOM(var_program);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glExtIsProgramBinaryQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glExtGetProgramBinarySourceQCOM: {
|
|
android::base::beginTrace("glExtGetProgramBinarySourceQCOM decode");
|
|
GLuint var_program = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
GLenum var_shadertype = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
|
|
uint32_t size_source __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
|
|
InputBuffer inptr_source(ptr + 8 + 4 + 4 + 4, size_source);
|
|
uint32_t size_length __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_source);
|
|
InputBuffer inptr_length(ptr + 8 + 4 + 4 + 4 + size_source + 4, size_length);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glExtGetProgramBinarySourceQCOM(var_program, var_shadertype, (GLchar*)(inptr_source.get()), (GLint*)(inptr_length.get()));
|
|
SET_LASTCALL("glExtGetProgramBinarySourceQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glStartTilingQCOM: {
|
|
android::base::beginTrace("glStartTilingQCOM decode");
|
|
GLuint var_x = Unpack<GLuint,uint32_t>(ptr + 8);
|
|
GLuint var_y = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
|
|
GLuint var_width = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLuint var_height = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLbitfield var_preserveMask = Unpack<GLbitfield,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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");
|
|
}
|
|
this->glStartTilingQCOM(var_x, var_y, var_width, var_height, var_preserveMask);
|
|
SET_LASTCALL("glStartTilingQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glEndTilingQCOM: {
|
|
android::base::beginTrace("glEndTilingQCOM decode");
|
|
GLbitfield var_preserveMask = Unpack<GLbitfield,uint32_t>(ptr + 8);
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glEndTilingQCOM: GL checksumCalculator failure\n");
|
|
}
|
|
this->glEndTilingQCOM(var_preserveMask);
|
|
SET_LASTCALL("glEndTilingQCOM");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glGetGraphicsResetStatusEXT: {
|
|
android::base::beginTrace("glGetGraphicsResetStatusEXT decode");
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
|
|
"gles1_decoder_context_t::decode, OP_glGetGraphicsResetStatusEXT: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = sizeof(GLenum);
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
*(GLenum *)(&tmpBuf[0]) = this->glGetGraphicsResetStatusEXT();
|
|
if (useChecksum) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glGetGraphicsResetStatusEXT");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
case OP_glReadnPixelsEXT: {
|
|
android::base::beginTrace("glReadnPixelsEXT decode");
|
|
GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
|
|
GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
|
|
GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
|
|
GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
|
|
GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
|
|
GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
|
|
GLsizei var_bufSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
|
|
if (useChecksum) {
|
|
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_glReadnPixelsEXT: GL checksumCalculator failure\n");
|
|
}
|
|
size_t totalTmpSize = size_data;
|
|
totalTmpSize += checksumSize;
|
|
unsigned char *tmpBuf = stream->alloc(totalTmpSize);
|
|
OutputBuffer outptr_data(&tmpBuf[0], 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) {
|
|
ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
|
|
}
|
|
stream->flush();
|
|
SET_LASTCALL("glReadnPixelsEXT");
|
|
android::base::endTrace();
|
|
break;
|
|
}
|
|
default:
|
|
return ptr - (unsigned char*)buf;
|
|
} //switch
|
|
#ifdef CHECK_GL_ERRORS
|
|
GLint err = this->glGetError();
|
|
if (err) fprintf(stderr, "gles1 Error (post-call): 0x%X in %s\n", err, lastCall);
|
|
#endif
|
|
ptr += packetLen;
|
|
} // while
|
|
return ptr - (unsigned char*)buf;
|
|
}
|